@rpgjs/server 5.0.0-alpha.43 → 5.0.0-alpha.44

package/dist/module-CuaepWlN.js

@@ -0,0 +1,3965 @@
+var __defProp$5 = Object.defineProperty;
+var __name$2 = (target, value) => __defProp$5(target, "name", { value, configurable: true });
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf ||
+      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+  return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() { this.constructor = d; }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+  return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+      function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+
+function __generator(thisArg, body) {
+  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+  return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+  function verb(n) { return function (v) { return step([n, v]); }; }
+  function step(op) {
+      if (f) throw new TypeError("Generator is already executing.");
+      while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+              case 0: case 1: t = op; break;
+              case 4: _.label++; return { value: op[1], done: false };
+              case 5: _.label++; y = op[1]; op = [0]; continue;
+              case 7: op = _.ops.pop(); _.trys.pop(); continue;
+              default:
+                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                  if (t[2]) _.ops.pop();
+                  _.trys.pop(); continue;
+          }
+          op = body.call(thisArg, _);
+      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+  }
+}
+
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+      next: function () {
+          if (o && i >= o.length) o = void 0;
+          return { value: o && o[i++], done: !o };
+      }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  }
+  catch (error) { e = { error: error }; }
+  finally {
+      try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+      }
+      finally { if (e) throw e.error; }
+  }
+  return ar;
+}
+
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+      if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+      }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+  function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+  function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+  function fulfill(value) { resume("next", value); }
+  function reject(value) { resume("throw", value); }
+  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function isFunction$1(value) {
+    return typeof value === 'function';
+}
+
+function createErrorClass(createImpl) {
+    var _super = function (instance) {
+        Error.call(instance);
+        instance.stack = new Error().stack;
+    };
+    var ctorFunc = createImpl(_super);
+    ctorFunc.prototype = Object.create(Error.prototype);
+    ctorFunc.prototype.constructor = ctorFunc;
+    return ctorFunc;
+}
+
+var UnsubscriptionError = createErrorClass(function (_super) {
+    return function UnsubscriptionErrorImpl(errors) {
+        _super(this);
+        this.message = errors
+            ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n  ')
+            : '';
+        this.name = 'UnsubscriptionError';
+        this.errors = errors;
+    };
+});
+
+function arrRemove(arr, item) {
+    if (arr) {
+        var index = arr.indexOf(item);
+        0 <= index && arr.splice(index, 1);
+    }
+}
+
+var Subscription = (function () {
+    function Subscription(initialTeardown) {
+        this.initialTeardown = initialTeardown;
+        this.closed = false;
+        this._parentage = null;
+        this._finalizers = null;
+    }
+    Subscription.prototype.unsubscribe = function () {
+        var e_1, _a, e_2, _b;
+        var errors;
+        if (!this.closed) {
+            this.closed = true;
+            var _parentage = this._parentage;
+            if (_parentage) {
+                this._parentage = null;
+                if (Array.isArray(_parentage)) {
+                    try {
+                        for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+                            var parent_1 = _parentage_1_1.value;
+                            parent_1.remove(this);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+                else {
+                    _parentage.remove(this);
+                }
+            }
+            var initialFinalizer = this.initialTeardown;
+            if (isFunction$1(initialFinalizer)) {
+                try {
+                    initialFinalizer();
+                }
+                catch (e) {
+                    errors = e instanceof UnsubscriptionError ? e.errors : [e];
+                }
+            }
+            var _finalizers = this._finalizers;
+            if (_finalizers) {
+                this._finalizers = null;
+                try {
+                    for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+                        var finalizer = _finalizers_1_1.value;
+                        try {
+                            execFinalizer(finalizer);
+                        }
+                        catch (err) {
+                            errors = errors !== null && errors !== void 0 ? errors : [];
+                            if (err instanceof UnsubscriptionError) {
+                                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+                            }
+                            else {
+                                errors.push(err);
+                            }
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            if (errors) {
+                throw new UnsubscriptionError(errors);
+            }
+        }
+    };
+    Subscription.prototype.add = function (teardown) {
+        var _a;
+        if (teardown && teardown !== this) {
+            if (this.closed) {
+                execFinalizer(teardown);
+            }
+            else {
+                if (teardown instanceof Subscription) {
+                    if (teardown.closed || teardown._hasParent(this)) {
+                        return;
+                    }
+                    teardown._addParent(this);
+                }
+                (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+            }
+        }
+    };
+    Subscription.prototype._hasParent = function (parent) {
+        var _parentage = this._parentage;
+        return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
+    };
+    Subscription.prototype._addParent = function (parent) {
+        var _parentage = this._parentage;
+        this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+    };
+    Subscription.prototype._removeParent = function (parent) {
+        var _parentage = this._parentage;
+        if (_parentage === parent) {
+            this._parentage = null;
+        }
+        else if (Array.isArray(_parentage)) {
+            arrRemove(_parentage, parent);
+        }
+    };
+    Subscription.prototype.remove = function (teardown) {
+        var _finalizers = this._finalizers;
+        _finalizers && arrRemove(_finalizers, teardown);
+        if (teardown instanceof Subscription) {
+            teardown._removeParent(this);
+        }
+    };
+    Subscription.EMPTY = (function () {
+        var empty = new Subscription();
+        empty.closed = true;
+        return empty;
+    })();
+    return Subscription;
+}());
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+    return (value instanceof Subscription ||
+        (value && 'closed' in value && isFunction$1(value.remove) && isFunction$1(value.add) && isFunction$1(value.unsubscribe)));
+}
+function execFinalizer(finalizer) {
+    if (isFunction$1(finalizer)) {
+        finalizer();
+    }
+    else {
+        finalizer.unsubscribe();
+    }
+}
+
+var config = {
+    Promise: undefined};
+
+var timeoutProvider = {
+    setTimeout: function (handler, timeout) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+    },
+    clearTimeout: function (handle) {
+        return (clearTimeout)(handle);
+    },
+    delegate: undefined,
+};
+
+function reportUnhandledError(err) {
+    timeoutProvider.setTimeout(function () {
+        {
+            throw err;
+        }
+    });
+}
+
+function noop() { }
+
+function errorContext(cb) {
+    {
+        cb();
+    }
+}
+
+var Subscriber = (function (_super) {
+    __extends(Subscriber, _super);
+    function Subscriber(destination) {
+        var _this = _super.call(this) || this;
+        _this.isStopped = false;
+        if (destination) {
+            _this.destination = destination;
+            if (isSubscription(destination)) {
+                destination.add(_this);
+            }
+        }
+        else {
+            _this.destination = EMPTY_OBSERVER;
+        }
+        return _this;
+    }
+    Subscriber.create = function (next, error, complete) {
+        return new SafeSubscriber(next, error, complete);
+    };
+    Subscriber.prototype.next = function (value) {
+        if (this.isStopped) ;
+        else {
+            this._next(value);
+        }
+    };
+    Subscriber.prototype.error = function (err) {
+        if (this.isStopped) ;
+        else {
+            this.isStopped = true;
+            this._error(err);
+        }
+    };
+    Subscriber.prototype.complete = function () {
+        if (this.isStopped) ;
+        else {
+            this.isStopped = true;
+            this._complete();
+        }
+    };
+    Subscriber.prototype.unsubscribe = function () {
+        if (!this.closed) {
+            this.isStopped = true;
+            _super.prototype.unsubscribe.call(this);
+            this.destination = null;
+        }
+    };
+    Subscriber.prototype._next = function (value) {
+        this.destination.next(value);
+    };
+    Subscriber.prototype._error = function (err) {
+        try {
+            this.destination.error(err);
+        }
+        finally {
+            this.unsubscribe();
+        }
+    };
+    Subscriber.prototype._complete = function () {
+        try {
+            this.destination.complete();
+        }
+        finally {
+            this.unsubscribe();
+        }
+    };
+    return Subscriber;
+}(Subscription));
+var ConsumerObserver = (function () {
+    function ConsumerObserver(partialObserver) {
+        this.partialObserver = partialObserver;
+    }
+    ConsumerObserver.prototype.next = function (value) {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.next) {
+            try {
+                partialObserver.next(value);
+            }
+            catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+    };
+    ConsumerObserver.prototype.error = function (err) {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.error) {
+            try {
+                partialObserver.error(err);
+            }
+            catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+        else {
+            handleUnhandledError(err);
+        }
+    };
+    ConsumerObserver.prototype.complete = function () {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.complete) {
+            try {
+                partialObserver.complete();
+            }
+            catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+    };
+    return ConsumerObserver;
+}());
+var SafeSubscriber = (function (_super) {
+    __extends(SafeSubscriber, _super);
+    function SafeSubscriber(observerOrNext, error, complete) {
+        var _this = _super.call(this) || this;
+        var partialObserver;
+        if (isFunction$1(observerOrNext) || !observerOrNext) {
+            partialObserver = {
+                next: (observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined),
+                error: error !== null && error !== void 0 ? error : undefined,
+                complete: complete !== null && complete !== void 0 ? complete : undefined,
+            };
+        }
+        else {
+            {
+                partialObserver = observerOrNext;
+            }
+        }
+        _this.destination = new ConsumerObserver(partialObserver);
+        return _this;
+    }
+    return SafeSubscriber;
+}(Subscriber));
+function handleUnhandledError(error) {
+    {
+        reportUnhandledError(error);
+    }
+}
+function defaultErrorHandler(err) {
+    throw err;
+}
+var EMPTY_OBSERVER = {
+    closed: true,
+    next: noop,
+    error: defaultErrorHandler,
+    complete: noop,
+};
+
+var observable = (function () { return (typeof Symbol === 'function' && Symbol.observable) || '@@observable'; })();
+
+function identity(x) {
+    return x;
+}
+
+function pipeFromArray(fns) {
+    if (fns.length === 0) {
+        return identity;
+    }
+    if (fns.length === 1) {
+        return fns[0];
+    }
+    return function piped(input) {
+        return fns.reduce(function (prev, fn) { return fn(prev); }, input);
+    };
+}
+
+var Observable = (function () {
+    function Observable(subscribe) {
+        if (subscribe) {
+            this._subscribe = subscribe;
+        }
+    }
+    Observable.prototype.lift = function (operator) {
+        var observable = new Observable();
+        observable.source = this;
+        observable.operator = operator;
+        return observable;
+    };
+    Observable.prototype.subscribe = function (observerOrNext, error, complete) {
+        var _this = this;
+        var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+        errorContext(function () {
+            var _a = _this, operator = _a.operator, source = _a.source;
+            subscriber.add(operator
+                ?
+                    operator.call(subscriber, source)
+                : source
+                    ?
+                        _this._subscribe(subscriber)
+                    :
+                        _this._trySubscribe(subscriber));
+        });
+        return subscriber;
+    };
+    Observable.prototype._trySubscribe = function (sink) {
+        try {
+            return this._subscribe(sink);
+        }
+        catch (err) {
+            sink.error(err);
+        }
+    };
+    Observable.prototype.forEach = function (next, promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function (resolve, reject) {
+            var subscriber = new SafeSubscriber({
+                next: function (value) {
+                    try {
+                        next(value);
+                    }
+                    catch (err) {
+                        reject(err);
+                        subscriber.unsubscribe();
+                    }
+                },
+                error: reject,
+                complete: resolve,
+            });
+            _this.subscribe(subscriber);
+        });
+    };
+    Observable.prototype._subscribe = function (subscriber) {
+        var _a;
+        return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+    };
+    Observable.prototype[observable] = function () {
+        return this;
+    };
+    Observable.prototype.pipe = function () {
+        var operations = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            operations[_i] = arguments[_i];
+        }
+        return pipeFromArray(operations)(this);
+    };
+    Observable.prototype.toPromise = function (promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function (resolve, reject) {
+            var value;
+            _this.subscribe(function (x) { return (value = x); }, function (err) { return reject(err); }, function () { return resolve(value); });
+        });
+    };
+    Observable.create = function (subscribe) {
+        return new Observable(subscribe);
+    };
+    return Observable;
+}());
+function getPromiseCtor(promiseCtor) {
+    var _a;
+    return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+}
+function isObserver(value) {
+    return value && isFunction$1(value.next) && isFunction$1(value.error) && isFunction$1(value.complete);
+}
+function isSubscriber(value) {
+    return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
+}
+
+function hasLift(source) {
+    return isFunction$1(source === null || source === void 0 ? void 0 : source.lift);
+}
+function operate(init) {
+    return function (source) {
+        if (hasLift(source)) {
+            return source.lift(function (liftedSource) {
+                try {
+                    return init(liftedSource, this);
+                }
+                catch (err) {
+                    this.error(err);
+                }
+            });
+        }
+        throw new TypeError('Unable to lift unknown Observable type');
+    };
+}
+
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+    return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = (function (_super) {
+    __extends(OperatorSubscriber, _super);
+    function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+        var _this = _super.call(this, destination) || this;
+        _this.onFinalize = onFinalize;
+        _this.shouldUnsubscribe = shouldUnsubscribe;
+        _this._next = onNext
+            ? function (value) {
+                try {
+                    onNext(value);
+                }
+                catch (err) {
+                    destination.error(err);
+                }
+            }
+            : _super.prototype._next;
+        _this._error = onError
+            ? function (err) {
+                try {
+                    onError(err);
+                }
+                catch (err) {
+                    destination.error(err);
+                }
+                finally {
+                    this.unsubscribe();
+                }
+            }
+            : _super.prototype._error;
+        _this._complete = onComplete
+            ? function () {
+                try {
+                    onComplete();
+                }
+                catch (err) {
+                    destination.error(err);
+                }
+                finally {
+                    this.unsubscribe();
+                }
+            }
+            : _super.prototype._complete;
+        return _this;
+    }
+    OperatorSubscriber.prototype.unsubscribe = function () {
+        var _a;
+        if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+            var closed_1 = this.closed;
+            _super.prototype.unsubscribe.call(this);
+            !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+        }
+    };
+    return OperatorSubscriber;
+}(Subscriber));
+
+var ObjectUnsubscribedError = createErrorClass(function (_super) {
+    return function ObjectUnsubscribedErrorImpl() {
+        _super(this);
+        this.name = 'ObjectUnsubscribedError';
+        this.message = 'object unsubscribed';
+    };
+});
+
+var Subject = (function (_super) {
+    __extends(Subject, _super);
+    function Subject() {
+        var _this = _super.call(this) || this;
+        _this.closed = false;
+        _this.currentObservers = null;
+        _this.observers = [];
+        _this.isStopped = false;
+        _this.hasError = false;
+        _this.thrownError = null;
+        return _this;
+    }
+    Subject.prototype.lift = function (operator) {
+        var subject = new AnonymousSubject(this, this);
+        subject.operator = operator;
+        return subject;
+    };
+    Subject.prototype._throwIfClosed = function () {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+    };
+    Subject.prototype.next = function (value) {
+        var _this = this;
+        errorContext(function () {
+            var e_1, _a;
+            _this._throwIfClosed();
+            if (!_this.isStopped) {
+                if (!_this.currentObservers) {
+                    _this.currentObservers = Array.from(_this.observers);
+                }
+                try {
+                    for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var observer = _c.value;
+                        observer.next(value);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+        });
+    };
+    Subject.prototype.error = function (err) {
+        var _this = this;
+        errorContext(function () {
+            _this._throwIfClosed();
+            if (!_this.isStopped) {
+                _this.hasError = _this.isStopped = true;
+                _this.thrownError = err;
+                var observers = _this.observers;
+                while (observers.length) {
+                    observers.shift().error(err);
+                }
+            }
+        });
+    };
+    Subject.prototype.complete = function () {
+        var _this = this;
+        errorContext(function () {
+            _this._throwIfClosed();
+            if (!_this.isStopped) {
+                _this.isStopped = true;
+                var observers = _this.observers;
+                while (observers.length) {
+                    observers.shift().complete();
+                }
+            }
+        });
+    };
+    Subject.prototype.unsubscribe = function () {
+        this.isStopped = this.closed = true;
+        this.observers = this.currentObservers = null;
+    };
+    Object.defineProperty(Subject.prototype, "observed", {
+        get: function () {
+            var _a;
+            return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Subject.prototype._trySubscribe = function (subscriber) {
+        this._throwIfClosed();
+        return _super.prototype._trySubscribe.call(this, subscriber);
+    };
+    Subject.prototype._subscribe = function (subscriber) {
+        this._throwIfClosed();
+        this._checkFinalizedStatuses(subscriber);
+        return this._innerSubscribe(subscriber);
+    };
+    Subject.prototype._innerSubscribe = function (subscriber) {
+        var _this = this;
+        var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+        if (hasError || isStopped) {
+            return EMPTY_SUBSCRIPTION;
+        }
+        this.currentObservers = null;
+        observers.push(subscriber);
+        return new Subscription(function () {
+            _this.currentObservers = null;
+            arrRemove(observers, subscriber);
+        });
+    };
+    Subject.prototype._checkFinalizedStatuses = function (subscriber) {
+        var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+        if (hasError) {
+            subscriber.error(thrownError);
+        }
+        else if (isStopped) {
+            subscriber.complete();
+        }
+    };
+    Subject.prototype.asObservable = function () {
+        var observable = new Observable();
+        observable.source = this;
+        return observable;
+    };
+    Subject.create = function (destination, source) {
+        return new AnonymousSubject(destination, source);
+    };
+    return Subject;
+}(Observable));
+var AnonymousSubject = (function (_super) {
+    __extends(AnonymousSubject, _super);
+    function AnonymousSubject(destination, source) {
+        var _this = _super.call(this) || this;
+        _this.destination = destination;
+        _this.source = source;
+        return _this;
+    }
+    AnonymousSubject.prototype.next = function (value) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+    };
+    AnonymousSubject.prototype.error = function (err) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+    };
+    AnonymousSubject.prototype.complete = function () {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+    };
+    AnonymousSubject.prototype._subscribe = function (subscriber) {
+        var _a, _b;
+        return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+    };
+    return AnonymousSubject;
+}(Subject));
+
+var BehaviorSubject = (function (_super) {
+    __extends(BehaviorSubject, _super);
+    function BehaviorSubject(_value) {
+        var _this = _super.call(this) || this;
+        _this._value = _value;
+        return _this;
+    }
+    Object.defineProperty(BehaviorSubject.prototype, "value", {
+        get: function () {
+            return this.getValue();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BehaviorSubject.prototype._subscribe = function (subscriber) {
+        var subscription = _super.prototype._subscribe.call(this, subscriber);
+        !subscription.closed && subscriber.next(this._value);
+        return subscription;
+    };
+    BehaviorSubject.prototype.getValue = function () {
+        var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, _value = _a._value;
+        if (hasError) {
+            throw thrownError;
+        }
+        this._throwIfClosed();
+        return _value;
+    };
+    BehaviorSubject.prototype.next = function (value) {
+        _super.prototype.next.call(this, (this._value = value));
+    };
+    return BehaviorSubject;
+}(Subject));
+
+function isScheduler(value) {
+    return value && isFunction$1(value.schedule);
+}
+
+function last(arr) {
+    return arr[arr.length - 1];
+}
+function popResultSelector(args) {
+    return isFunction$1(last(args)) ? args.pop() : undefined;
+}
+function popScheduler(args) {
+    return isScheduler(last(args)) ? args.pop() : undefined;
+}
+
+var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });
+
+function isPromise(value) {
+    return isFunction$1(value === null || value === void 0 ? void 0 : value.then);
+}
+
+function isInteropObservable(input) {
+    return isFunction$1(input[observable]);
+}
+
+function isAsyncIterable(obj) {
+    return Symbol.asyncIterator && isFunction$1(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+}
+
+function createInvalidObservableTypeError(input) {
+    return new TypeError("You provided " + (input !== null && typeof input === 'object' ? 'an invalid object' : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+
+function getSymbolIterator() {
+    if (typeof Symbol !== 'function' || !Symbol.iterator) {
+        return '@@iterator';
+    }
+    return Symbol.iterator;
+}
+var iterator = getSymbolIterator();
+
+function isIterable(input) {
+    return isFunction$1(input === null || input === void 0 ? void 0 : input[iterator]);
+}
+
+function readableStreamLikeToAsyncGenerator(readableStream) {
+    return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+        var reader, _a, value, done;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    reader = readableStream.getReader();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, , 9, 10]);
+                    _b.label = 2;
+                case 2:
+                    return [4, __await(reader.read())];
+                case 3:
+                    _a = _b.sent(), value = _a.value, done = _a.done;
+                    if (!done) return [3, 5];
+                    return [4, __await(void 0)];
+                case 4: return [2, _b.sent()];
+                case 5: return [4, __await(value)];
+                case 6: return [4, _b.sent()];
+                case 7:
+                    _b.sent();
+                    return [3, 2];
+                case 8: return [3, 10];
+                case 9:
+                    reader.releaseLock();
+                    return [7];
+                case 10: return [2];
+            }
+        });
+    });
+}
+function isReadableStreamLike(obj) {
+    return isFunction$1(obj === null || obj === void 0 ? void 0 : obj.getReader);
+}
+
+function innerFrom(input) {
+    if (input instanceof Observable) {
+        return input;
+    }
+    if (input != null) {
+        if (isInteropObservable(input)) {
+            return fromInteropObservable(input);
+        }
+        if (isArrayLike(input)) {
+            return fromArrayLike(input);
+        }
+        if (isPromise(input)) {
+            return fromPromise(input);
+        }
+        if (isAsyncIterable(input)) {
+            return fromAsyncIterable(input);
+        }
+        if (isIterable(input)) {
+            return fromIterable(input);
+        }
+        if (isReadableStreamLike(input)) {
+            return fromReadableStreamLike(input);
+        }
+    }
+    throw createInvalidObservableTypeError(input);
+}
+function fromInteropObservable(obj) {
+    return new Observable(function (subscriber) {
+        var obs = obj[observable]();
+        if (isFunction$1(obs.subscribe)) {
+            return obs.subscribe(subscriber);
+        }
+        throw new TypeError('Provided object does not correctly implement Symbol.observable');
+    });
+}
+function fromArrayLike(array) {
+    return new Observable(function (subscriber) {
+        for (var i = 0; i < array.length && !subscriber.closed; i++) {
+            subscriber.next(array[i]);
+        }
+        subscriber.complete();
+    });
+}
+function fromPromise(promise) {
+    return new Observable(function (subscriber) {
+        promise
+            .then(function (value) {
+            if (!subscriber.closed) {
+                subscriber.next(value);
+                subscriber.complete();
+            }
+        }, function (err) { return subscriber.error(err); })
+            .then(null, reportUnhandledError);
+    });
+}
+function fromIterable(iterable) {
+    return new Observable(function (subscriber) {
+        var e_1, _a;
+        try {
+            for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
+                var value = iterable_1_1.value;
+                subscriber.next(value);
+                if (subscriber.closed) {
+                    return;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        subscriber.complete();
+    });
+}
+function fromAsyncIterable(asyncIterable) {
+    return new Observable(function (subscriber) {
+        process$1(asyncIterable, subscriber).catch(function (err) { return subscriber.error(err); });
+    });
+}
+function fromReadableStreamLike(readableStream) {
+    return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
+}
+function process$1(asyncIterable, subscriber) {
+    var asyncIterable_1, asyncIterable_1_1;
+    var e_2, _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var value, e_2_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 5, 6, 11]);
+                    asyncIterable_1 = __asyncValues(asyncIterable);
+                    _b.label = 1;
+                case 1: return [4, asyncIterable_1.next()];
+                case 2:
+                    if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
+                    value = asyncIterable_1_1.value;
+                    subscriber.next(value);
+                    if (subscriber.closed) {
+                        return [2];
+                    }
+                    _b.label = 3;
+                case 3: return [3, 1];
+                case 4: return [3, 11];
+                case 5:
+                    e_2_1 = _b.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3, 11];
+                case 6:
+                    _b.trys.push([6, , 9, 10]);
+                    if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
+                    return [4, _a.call(asyncIterable_1)];
+                case 7:
+                    _b.sent();
+                    _b.label = 8;
+                case 8: return [3, 10];
+                case 9:
+                    if (e_2) throw e_2.error;
+                    return [7];
+                case 10: return [7];
+                case 11:
+                    subscriber.complete();
+                    return [2];
+            }
+        });
+    });
+}
+
+function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
+    if (delay === void 0) { delay = 0; }
+    if (repeat === void 0) { repeat = false; }
+    var scheduleSubscription = scheduler.schedule(function () {
+        work();
+        if (repeat) {
+            parentSubscription.add(this.schedule(null, delay));
+        }
+        else {
+            this.unsubscribe();
+        }
+    }, delay);
+    parentSubscription.add(scheduleSubscription);
+    if (!repeat) {
+        return scheduleSubscription;
+    }
+}
+
+function observeOn(scheduler, delay) {
+    if (delay === void 0) { delay = 0; }
+    return operate(function (source, subscriber) {
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) { return executeSchedule(subscriber, scheduler, function () { return subscriber.next(value); }, delay); }, function () { return executeSchedule(subscriber, scheduler, function () { return subscriber.complete(); }, delay); }, function (err) { return executeSchedule(subscriber, scheduler, function () { return subscriber.error(err); }, delay); }));
+    });
+}
+
+function subscribeOn(scheduler, delay) {
+    if (delay === void 0) { delay = 0; }
+    return operate(function (source, subscriber) {
+        subscriber.add(scheduler.schedule(function () { return source.subscribe(subscriber); }, delay));
+    });
+}
+
+function scheduleObservable(input, scheduler) {
+    return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+
+function schedulePromise(input, scheduler) {
+    return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+
+function scheduleArray(input, scheduler) {
+    return new Observable(function (subscriber) {
+        var i = 0;
+        return scheduler.schedule(function () {
+            if (i === input.length) {
+                subscriber.complete();
+            }
+            else {
+                subscriber.next(input[i++]);
+                if (!subscriber.closed) {
+                    this.schedule();
+                }
+            }
+        });
+    });
+}
+
+function scheduleIterable(input, scheduler) {
+    return new Observable(function (subscriber) {
+        var iterator$1;
+        executeSchedule(subscriber, scheduler, function () {
+            iterator$1 = input[iterator]();
+            executeSchedule(subscriber, scheduler, function () {
+                var _a;
+                var value;
+                var done;
+                try {
+                    (_a = iterator$1.next(), value = _a.value, done = _a.done);
+                }
+                catch (err) {
+                    subscriber.error(err);
+                    return;
+                }
+                if (done) {
+                    subscriber.complete();
+                }
+                else {
+                    subscriber.next(value);
+                }
+            }, 0, true);
+        });
+        return function () { return isFunction$1(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return(); };
+    });
+}
+
+function scheduleAsyncIterable(input, scheduler) {
+    if (!input) {
+        throw new Error('Iterable cannot be null');
+    }
+    return new Observable(function (subscriber) {
+        executeSchedule(subscriber, scheduler, function () {
+            var iterator = input[Symbol.asyncIterator]();
+            executeSchedule(subscriber, scheduler, function () {
+                iterator.next().then(function (result) {
+                    if (result.done) {
+                        subscriber.complete();
+                    }
+                    else {
+                        subscriber.next(result.value);
+                    }
+                });
+            }, 0, true);
+        });
+    });
+}
+
+function scheduleReadableStreamLike(input, scheduler) {
+    return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
+}
+
+function scheduled(input, scheduler) {
+    if (input != null) {
+        if (isInteropObservable(input)) {
+            return scheduleObservable(input, scheduler);
+        }
+        if (isArrayLike(input)) {
+            return scheduleArray(input, scheduler);
+        }
+        if (isPromise(input)) {
+            return schedulePromise(input, scheduler);
+        }
+        if (isAsyncIterable(input)) {
+            return scheduleAsyncIterable(input, scheduler);
+        }
+        if (isIterable(input)) {
+            return scheduleIterable(input, scheduler);
+        }
+        if (isReadableStreamLike(input)) {
+            return scheduleReadableStreamLike(input, scheduler);
+        }
+    }
+    throw createInvalidObservableTypeError(input);
+}
+
+function from(input, scheduler) {
+    return scheduler ? scheduled(input, scheduler) : innerFrom(input);
+}
+
+function map(project, thisArg) {
+    return operate(function (source, subscriber) {
+        var index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+            subscriber.next(project.call(thisArg, value, index++));
+        }));
+    });
+}
+
+var isArray$1 = Array.isArray;
+function callOrApply(fn, args) {
+    return isArray$1(args) ? fn.apply(void 0, __spreadArray([], __read(args))) : fn(args);
+}
+function mapOneOrManyArgs(fn) {
+    return map(function (args) { return callOrApply(fn, args); });
+}
+
+var isArray = Array.isArray;
+var getPrototypeOf = Object.getPrototypeOf, objectProto = Object.prototype, getKeys = Object.keys;
+function argsArgArrayOrObject(args) {
+    if (args.length === 1) {
+        var first_1 = args[0];
+        if (isArray(first_1)) {
+            return { args: first_1, keys: null };
+        }
+        if (isPOJO(first_1)) {
+            var keys = getKeys(first_1);
+            return {
+                args: keys.map(function (key) { return first_1[key]; }),
+                keys: keys,
+            };
+        }
+    }
+    return { args: args, keys: null };
+}
+function isPOJO(obj) {
+    return obj && typeof obj === 'object' && getPrototypeOf(obj) === objectProto;
+}
+
+function createObject(keys, values) {
+    return keys.reduce(function (result, key, i) { return ((result[key] = values[i]), result); }, {});
+}
+
+function combineLatest() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var scheduler = popScheduler(args);
+    var resultSelector = popResultSelector(args);
+    var _a = argsArgArrayOrObject(args), observables = _a.args, keys = _a.keys;
+    if (observables.length === 0) {
+        return from([], scheduler);
+    }
+    var result = new Observable(combineLatestInit(observables, scheduler, keys
+        ?
+            function (values) { return createObject(keys, values); }
+        :
+            identity));
+    return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
+}
+function combineLatestInit(observables, scheduler, valueTransform) {
+    if (valueTransform === void 0) { valueTransform = identity; }
+    return function (subscriber) {
+        maybeSchedule(scheduler, function () {
+            var length = observables.length;
+            var values = new Array(length);
+            var active = length;
+            var remainingFirstValues = length;
+            var _loop_1 = function (i) {
+                maybeSchedule(scheduler, function () {
+                    var source = from(observables[i], scheduler);
+                    var hasFirstValue = false;
+                    source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+                        values[i] = value;
+                        if (!hasFirstValue) {
+                            hasFirstValue = true;
+                            remainingFirstValues--;
+                        }
+                        if (!remainingFirstValues) {
+                            subscriber.next(valueTransform(values.slice()));
+                        }
+                    }, function () {
+                        if (!--active) {
+                            subscriber.complete();
+                        }
+                    }));
+                }, subscriber);
+            };
+            for (var i = 0; i < length; i++) {
+                _loop_1(i);
+            }
+        }, subscriber);
+    };
+}
+function maybeSchedule(scheduler, execute, subscription) {
+    if (scheduler) {
+        executeSchedule(subscription, scheduler, execute);
+    }
+    else {
+        execute();
+    }
+}
+
+function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
+    var buffer = [];
+    var active = 0;
+    var index = 0;
+    var isComplete = false;
+    var checkComplete = function () {
+        if (isComplete && !buffer.length && !active) {
+            subscriber.complete();
+        }
+    };
+    var outerNext = function (value) { return (active < concurrent ? doInnerSub(value) : buffer.push(value)); };
+    var doInnerSub = function (value) {
+        active++;
+        var innerComplete = false;
+        innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, function (innerValue) {
+            {
+                subscriber.next(innerValue);
+            }
+        }, function () {
+            innerComplete = true;
+        }, undefined, function () {
+            if (innerComplete) {
+                try {
+                    active--;
+                    var _loop_1 = function () {
+                        var bufferedValue = buffer.shift();
+                        if (innerSubScheduler) ;
+                        else {
+                            doInnerSub(bufferedValue);
+                        }
+                    };
+                    while (buffer.length && active < concurrent) {
+                        _loop_1();
+                    }
+                    checkComplete();
+                }
+                catch (err) {
+                    subscriber.error(err);
+                }
+            }
+        }));
+    };
+    source.subscribe(createOperatorSubscriber(subscriber, outerNext, function () {
+        isComplete = true;
+        checkComplete();
+    }));
+    return function () {
+    };
+}
+
+function mergeMap(project, resultSelector, concurrent) {
+    if (concurrent === void 0) { concurrent = Infinity; }
+    if (isFunction$1(resultSelector)) {
+        return mergeMap(function (a, i) { return map(function (b, ii) { return resultSelector(a, b, i, ii); })(innerFrom(project(a, i))); }, concurrent);
+    }
+    else if (typeof resultSelector === 'number') {
+        concurrent = resultSelector;
+    }
+    return operate(function (source, subscriber) { return mergeInternals(source, subscriber, project, concurrent); });
+}
+
+function filter(predicate, thisArg) {
+    return operate(function (source, subscriber) {
+        var index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) { return predicate.call(thisArg, value, index++) && subscriber.next(value); }));
+    });
+}
+
+function scanInternals(accumulator, seed, hasSeed, emitOnNext, emitBeforeComplete) {
+    return function (source, subscriber) {
+        var hasState = hasSeed;
+        var state = seed;
+        var index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+            var i = index++;
+            state = hasState
+                ?
+                    accumulator(state, value, i)
+                :
+                    ((hasState = true), value);
+        }, (function () {
+                hasState && subscriber.next(state);
+                subscriber.complete();
+            })));
+    };
+}
+
+function reduce(accumulator, seed) {
+    return operate(scanInternals(accumulator, seed, arguments.length >= 2, false, true));
+}
+
+var arrReducer = function (arr, value) { return (arr.push(value), arr); };
+function toArray() {
+    return operate(function (source, subscriber) {
+        reduce(arrReducer, [])(source).subscribe(subscriber);
+    });
+}
+
+function finalize(callback) {
+    return operate(function (source, subscriber) {
+        try {
+            source.subscribe(subscriber);
+        }
+        finally {
+            subscriber.add(callback);
+        }
+    });
+}
+
+var __defProp$4 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$4(target, "name", { value, configurable: true });
+var ArraySubject = class extends BehaviorSubject {
+  static {
+    __name$1(this, "ArraySubject");
+  }
+  _items = [];
+  constructor(items = []) {
+    super({
+      type: "init",
+      items
+    });
+    this.createProxy(items);
+  }
+  createProxy(items) {
+    this._items = new Proxy(items, {
+      get: /* @__PURE__ */ __name$1((target, prop, receiver) => {
+        const origMethod = target[prop];
+        if (typeof origMethod === "function") {
+          return (...args) => {
+            let changeType = "update";
+            let index = void 0;
+            let isMutateFn = false;
+            let itemsToEmit = [];
+            let changeSplice = true;
+            switch (prop) {
+              case "push":
+                index = target.length;
+                changeType = "add";
+                isMutateFn = true;
+                break;
+              case "pop":
+                index = target.length - 1;
+                changeType = "remove";
+                isMutateFn = true;
+                break;
+              case "unshift":
+                index = 0;
+                changeType = "add";
+                isMutateFn = true;
+                break;
+              case "shift":
+                index = 0;
+                changeType = "remove";
+                isMutateFn = true;
+                break;
+              case "splice":
+                index = args[0];
+                const deleteCount = args[1];
+                const newItems = args.slice(2);
+                itemsToEmit = newItems;
+                if (deleteCount > 0 && newItems.length === 0) {
+                  changeType = "remove";
+                } else if (deleteCount === 0 && newItems.length > 0) {
+                  changeType = "add";
+                } else if (deleteCount === 0 && newItems.length === 0) {
+                  changeSplice = false;
+                } else {
+                  changeType = "update";
+                }
+                isMutateFn = true;
+                break;
+            }
+            const result = origMethod.apply(target, args);
+            if (isMutateFn && changeSplice) {
+              if (prop === "splice") {
+                this.next({
+                  type: changeType,
+                  index,
+                  items: itemsToEmit
+                });
+              } else {
+                this.next({
+                  type: changeType,
+                  index,
+                  items: args
+                });
+              }
+            }
+            return result;
+          };
+        }
+        return Reflect.get(target, prop, receiver);
+      }, "get"),
+      set: /* @__PURE__ */ __name$1((target, prop, value) => {
+        const index = !isNaN(Number(prop)) ? Number(prop) : void 0;
+        target[prop] = value;
+        this.next({
+          type: "update",
+          index,
+          items: [
+            value
+          ]
+        });
+        return true;
+      }, "set")
+    });
+  }
+  get items() {
+    return this._items;
+  }
+  set items(newItems) {
+    this.createProxy(newItems);
+    this.next({
+      type: "reset",
+      items: newItems
+    });
+  }
+};
+var isArraySubject = /* @__PURE__ */ __name$1((value) => {
+  return "_items" in value;
+}, "isArraySubject");
+var ObjectSubject = class extends BehaviorSubject {
+  static {
+    __name$1(this, "ObjectSubject");
+  }
+  _obj;
+  constructor(obj = {}) {
+    super({
+      type: "init",
+      value: obj
+    });
+    this.createProxy(obj);
+  }
+  createProxy(obj) {
+    this._obj = new Proxy(obj, {
+      get: /* @__PURE__ */ __name$1((target, prop, receiver) => {
+        return Reflect.get(target, prop, receiver);
+      }, "get"),
+      set: /* @__PURE__ */ __name$1((target, prop, value, receiver) => {
+        const key = prop;
+        const changeType = key in target ? "update" : "add";
+        target[key] = value;
+        this.next({
+          type: changeType,
+          key,
+          value
+        });
+        return true;
+      }, "set"),
+      deleteProperty: /* @__PURE__ */ __name$1((target, prop) => {
+        const key = prop;
+        if (key in target) {
+          const value = target[key];
+          delete target[key];
+          this.next({
+            type: "remove",
+            key,
+            value
+          });
+          return true;
+        }
+        return false;
+      }, "deleteProperty")
+    });
+  }
+  get obj() {
+    return this._obj;
+  }
+  set obj(newObj) {
+    this.createProxy(newObj);
+    this.next({
+      type: "reset",
+      value: newObj
+    });
+  }
+};
+var isObjectSubject = /* @__PURE__ */ __name$1((value) => {
+  return "_obj" in value;
+}, "isObjectSubject");
+var getGlobalReactiveStore = /* @__PURE__ */ __name$1(() => {
+  const globalKey = "__REACTIVE_STORE__";
+  if (typeof globalThis !== "undefined") {
+    if (!globalThis[globalKey]) {
+      globalThis[globalKey] = {
+        currentDependencyTracker: null,
+        currentSubscriptionsTracker: null
+      };
+    }
+    return globalThis[globalKey];
+  }
+  let globalObj;
+  if (typeof window !== "undefined") {
+    globalObj = window;
+  } else if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    globalObj = Function("return this")();
+  } else if (typeof self !== "undefined") {
+    globalObj = self;
+  } else {
+    console.warn("Unable to find global object, using local instance");
+    return {
+      currentDependencyTracker: null,
+      currentSubscriptionsTracker: null
+    };
+  }
+  if (!globalObj[globalKey]) {
+    globalObj[globalKey] = {
+      currentDependencyTracker: null,
+      currentSubscriptionsTracker: null
+    };
+  }
+  return globalObj[globalKey];
+}, "getGlobalReactiveStore");
+var reactiveStore = getGlobalReactiveStore();
+var trackDependency = /* @__PURE__ */ __name$1((signal2) => {
+  if (reactiveStore.currentDependencyTracker) {
+    reactiveStore.currentDependencyTracker(signal2);
+  }
+}, "trackDependency");
+function signal(defaultValue, options) {
+  let subject;
+  if (Array.isArray(defaultValue)) {
+    subject = new ArraySubject(defaultValue);
+  } else if (typeof defaultValue === "object" && defaultValue !== null) {
+    subject = new ObjectSubject(defaultValue);
+  } else {
+    subject = new BehaviorSubject(defaultValue);
+  }
+  const getValue = /* @__PURE__ */ __name$1(() => {
+    if (subject instanceof ArraySubject) {
+      return subject.items;
+    } else if (subject instanceof ObjectSubject) {
+      return subject.obj;
+    }
+    return subject.value;
+  }, "getValue");
+  const fn = /* @__PURE__ */ __name$1(function() {
+    trackDependency(fn);
+    return getValue();
+  }, "fn");
+  fn.set = (value) => {
+    const currentValue = getValue();
+    let shouldEmit = true;
+    if (options?.equal) {
+      shouldEmit = !options.equal(currentValue, value);
+    } else {
+      shouldEmit = currentValue !== value;
+    }
+    if (shouldEmit) {
+      if (subject instanceof ArraySubject) {
+        subject.items = value;
+      } else if (subject instanceof ObjectSubject) {
+        subject.obj = value;
+      } else {
+        subject.next(value);
+      }
+    }
+  };
+  fn._isFrozen = false;
+  fn.freeze = () => {
+    fn._isFrozen = true;
+  };
+  fn.unfreeze = () => {
+    fn._isFrozen = false;
+    if (subject instanceof ArraySubject) {
+      subject.next({
+        type: "init",
+        items: subject.items
+      });
+    } else if (subject instanceof ObjectSubject) {
+      subject.next({
+        type: "init",
+        value: subject.obj
+      });
+    } else {
+      subject.next(subject.value);
+    }
+  };
+  fn.mutate = (mutateFn) => {
+    const value = getValue();
+    mutateFn(value);
+  };
+  fn.update = (updateFn) => {
+    const updatedValue = updateFn(getValue());
+    fn.set(updatedValue);
+  };
+  fn.observable = subject.asObservable().pipe(filter(() => !fn._isFrozen));
+  fn._subject = subject;
+  return fn;
+}
+__name$1(signal, "signal");
+function isSignal(value) {
+  return !!(value && value.observable);
+}
+__name$1(isSignal, "isSignal");
+function isComputed(value) {
+  return isSignal(value) && !!value.dependencies;
+}
+__name$1(isComputed, "isComputed");
+function computed(computeFunction, disposableFn) {
+  const dependencies = /* @__PURE__ */ new Set();
+  let init = true;
+  let lastComputedValue;
+  const previousTracker = reactiveStore.currentDependencyTracker;
+  reactiveStore.currentDependencyTracker = (signal2) => {
+    dependencies.add(signal2);
+  };
+  lastComputedValue = computeFunction();
+  if (computeFunction["isEffect"]) {
+    disposableFn = lastComputedValue;
+  }
+  reactiveStore.currentDependencyTracker = previousTracker;
+  const observables = [
+    ...dependencies
+  ].map((dep) => {
+    if (isComputed(dep) && "dependencies" in dep) {
+      const computedDep = dep;
+      if (computedDep.dependencies.size === 0) {
+        return new BehaviorSubject(computedDep()).asObservable();
+      }
+    }
+    return dep.observable;
+  });
+  const computedObservable = combineLatest(observables).pipe(filter(() => !init), map(() => computeFunction()), finalize(() => disposableFn?.()));
+  const fn = /* @__PURE__ */ __name$1(function() {
+    trackDependency(fn);
+    return lastComputedValue;
+  }, "fn");
+  fn.observable = computedObservable;
+  fn.subscription = computedObservable.subscribe((value) => {
+    lastComputedValue = value;
+  });
+  fn.dependencies = dependencies;
+  reactiveStore.currentSubscriptionsTracker?.(fn.subscription);
+  init = false;
+  return fn;
+}
+__name$1(computed, "computed");
+function linkedSignal(computationOrOptions, simpleOptions) {
+  const dependencies = /* @__PURE__ */ new Set();
+  let init = true;
+  let lastComputedValue;
+  let computeFunction;
+  let sourceSignal;
+  let computationFn;
+  let equalFn;
+  let previousValue;
+  let isOverridden = false;
+  let overriddenValue;
+  let depVersion = 0;
+  let overrideDepVersion = null;
+  if (typeof computationOrOptions === "function") {
+    computeFunction = computationOrOptions;
+    equalFn = simpleOptions?.equal;
+  } else {
+    const options = computationOrOptions;
+    sourceSignal = options.source;
+    computationFn = options.computation;
+    equalFn = options.equal;
+    if (typeof sourceSignal === "function" && !isSignal(sourceSignal)) {
+      const sourceFn = sourceSignal;
+      computeFunction = /* @__PURE__ */ __name$1(() => {
+        const sourceValue = sourceFn();
+        if (computationFn.length > 1) {
+          const result = computationFn(sourceValue, previousValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        } else {
+          const result = computationFn(sourceValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        }
+      }, "computeFunction");
+    } else {
+      const source = typeof sourceSignal === "function" ? sourceSignal : sourceSignal;
+      computeFunction = /* @__PURE__ */ __name$1(() => {
+        const sourceValue = source();
+        if (computationFn.length > 1) {
+          const result = computationFn(sourceValue, previousValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        } else {
+          const result = computationFn(sourceValue);
+          previousValue = {
+            source: sourceValue,
+            value: result
+          };
+          return result;
+        }
+      }, "computeFunction");
+    }
+  }
+  const previousTracker = reactiveStore.currentDependencyTracker;
+  reactiveStore.currentDependencyTracker = (signal2) => {
+    dependencies.add(signal2);
+  };
+  if (sourceSignal && typeof sourceSignal === "function" && !isSignal(sourceSignal)) {
+    lastComputedValue = computeFunction();
+  } else if (sourceSignal && isSignal(sourceSignal)) {
+    dependencies.add(sourceSignal);
+    lastComputedValue = computeFunction();
+  } else {
+    lastComputedValue = computeFunction();
+  }
+  reactiveStore.currentDependencyTracker = previousTracker;
+  const subject = new BehaviorSubject(lastComputedValue);
+  const observables = [
+    ...dependencies
+  ].map((dep) => {
+    if (isComputed(dep) && "dependencies" in dep) {
+      const computedDep = dep;
+      if (computedDep.dependencies.size === 0) {
+        return new BehaviorSubject(computedDep()).asObservable();
+      }
+    }
+    return dep.observable;
+  });
+  let linkedObservable;
+  if (observables.length > 0) {
+    linkedObservable = combineLatest(observables).pipe(filter(() => !init), map(() => {
+      const computed2 = computeFunction();
+      if (equalFn) {
+        if (!equalFn(lastComputedValue, computed2)) {
+          lastComputedValue = computed2;
+          isOverridden = false;
+        }
+      } else {
+        if (lastComputedValue !== computed2) {
+          lastComputedValue = computed2;
+          isOverridden = false;
+        }
+      }
+      return lastComputedValue;
+    }));
+  } else {
+    linkedObservable = subject.asObservable().pipe(filter(() => !init));
+  }
+  const fn = /* @__PURE__ */ __name$1(function() {
+    trackDependency(fn);
+    if (isOverridden && dependencies.size > 0) {
+      if (overrideDepVersion !== depVersion) {
+        const computed2 = computeFunction();
+        isOverridden = false;
+        overriddenValue = void 0;
+        lastComputedValue = computed2;
+        overrideDepVersion = null;
+        return computed2;
+      }
+      return overriddenValue;
+    }
+    if (isOverridden) {
+      return overriddenValue;
+    }
+    if (dependencies.size === 0) {
+      const computed2 = computeFunction();
+      lastComputedValue = computed2;
+    }
+    return lastComputedValue;
+  }, "fn");
+  fn.observable = new Observable((observer) => {
+    const depSubscription = linkedObservable.subscribe((value) => {
+      if (dependencies.size > 0) {
+        depVersion++;
+        isOverridden = false;
+        overrideDepVersion = null;
+        lastComputedValue = value;
+      } else {
+        lastComputedValue = value;
+      }
+      observer.next(value);
+    });
+    let subjectSubscription;
+    if (dependencies.size === 0) {
+      subjectSubscription = subject.pipe(filter(() => !init)).subscribe((value) => {
+        observer.next(value);
+      });
+    }
+    observer.next(lastComputedValue);
+    return () => {
+      depSubscription.unsubscribe();
+      if (subjectSubscription) {
+        subjectSubscription.unsubscribe();
+      }
+    };
+  });
+  fn.subscription = fn.observable.subscribe(() => {
+  });
+  fn.dependencies = dependencies;
+  fn._subject = subject;
+  fn.set = (value) => {
+    if (!isOverridden) {
+      overrideDepVersion = depVersion;
+      if (computationFn && sourceSignal) {
+        const sourceValue = untracked(() => {
+          if (typeof sourceSignal === "function") {
+            const source = sourceSignal;
+            return isSignal(source) ? source() : sourceSignal();
+          }
+          return sourceSignal();
+        });
+        previousValue = {
+          source: sourceValue,
+          value
+        };
+      }
+    }
+    isOverridden = true;
+    overriddenValue = value;
+    lastComputedValue = value;
+    subject.next(value);
+  };
+  reactiveStore.currentSubscriptionsTracker?.(fn.subscription);
+  init = false;
+  return fn;
+}
+__name$1(linkedSignal, "linkedSignal");
+function untracked(fn) {
+  const prevDepTracker = reactiveStore.currentDependencyTracker;
+  const prevSubTracker = reactiveStore.currentSubscriptionsTracker;
+  reactiveStore.currentDependencyTracker = null;
+  reactiveStore.currentSubscriptionsTracker = null;
+  try {
+    return fn();
+  } finally {
+    reactiveStore.currentDependencyTracker = prevDepTracker;
+    reactiveStore.currentSubscriptionsTracker = prevSubTracker;
+  }
+}
+__name$1(untracked, "untracked");
+
+// src/effect.ts
+function effect(fn) {
+  fn["isEffect"] = true;
+  return computed(fn);
+}
+__name$1(effect, "effect");
+
+// src/utils.ts
+function isFunction(val) {
+  return {}.toString.call(val) === "[object Function]";
+}
+__name$2(isFunction, "isFunction");
+function isClass(obj) {
+  return typeof obj === "function" && obj.prototype && obj.prototype.constructor === obj;
+}
+__name$2(isClass, "isClass");
+var isObject = /* @__PURE__ */ __name$2((item) => item && typeof item === "object" && !Array.isArray(item) && item !== null, "isObject");
+function isInstanceOfClass(value) {
+  if (value === null || typeof value !== "object" || value === void 0 || Array.isArray(value)) {
+    return false;
+  }
+  return Object.getPrototypeOf(value) !== Object.prototype;
+}
+__name$2(isInstanceOfClass, "isInstanceOfClass");
+function generateShortUUID() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let uuid = "";
+  for (let i = 0; i < 8; i++) {
+    const randomIndex = Math.floor(Math.random() * chars.length);
+    uuid += chars[randomIndex];
+  }
+  return uuid;
+}
+__name$2(generateShortUUID, "generateShortUUID");
+
+// src/core.ts
+var DELETE_TOKEN = "$delete";
+var syncClass = /* @__PURE__ */ __name$2((instance, options = {}) => {
+  const cacheSync = /* @__PURE__ */ new Map();
+  const cachePersist = /* @__PURE__ */ new Map();
+  instance.$valuesChanges = {
+    set: /* @__PURE__ */ __name$2((path, value) => {
+      cacheSync.set(path, value);
+      options.onSync?.(cacheSync);
+    }, "set"),
+    setPersist: /* @__PURE__ */ __name$2((path, value) => {
+      if (path == "") path = ".";
+      cachePersist.set(path, value);
+      options.onPersist?.(cachePersist);
+    }, "setPersist"),
+    has: /* @__PURE__ */ __name$2((path) => {
+      return cacheSync.has(path);
+    }, "has"),
+    get: /* @__PURE__ */ __name$2((path) => {
+      return cacheSync.get(path);
+    }, "get")
+  };
+  createSyncClass(instance);
+}, "syncClass");
+function createStatesSnapshot(instance) {
+  let persistObject = {};
+  if (instance?.$snapshot) {
+    for (const key of instance.$snapshot.keys()) {
+      const signal = instance.$snapshot.get(key);
+      const persist2 = signal.options.persist ?? true;
+      let value = signal();
+      if (isObject(value) || Array.isArray(value)) {
+        continue;
+      }
+      if (persist2) {
+        persistObject[key] = value;
+      }
+    }
+  }
+  return persistObject;
+}
+__name$2(createStatesSnapshot, "createStatesSnapshot");
+var SNAPSHOT_SKIP = Symbol("snapshot-skip");
+var serializeSnapshotDeep = /* @__PURE__ */ __name$2((value, path, options, seen) => {
+  if (isSignal(value)) {
+    return serializeSnapshotDeep(value(), path, options, seen);
+  }
+  if (value instanceof Map) {
+    return SNAPSHOT_SKIP;
+  }
+  if (options.filter && !options.filter(value, path)) {
+    return SNAPSHOT_SKIP;
+  }
+  if (value instanceof Date) {
+    return options.dateToString ? options.dateToString(value) : value.toISOString();
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return SNAPSHOT_SKIP;
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+      const result2 = [];
+      value.forEach((item, index) => {
+        const itemPath = path ? `${path}.${index}` : String(index);
+        const serialized = serializeSnapshotDeep(item, itemPath, options, seen);
+        if (serialized !== SNAPSHOT_SKIP) {
+          result2.push(serialized);
+        }
+      });
+      return result2;
+    }
+    const result = {};
+    const idKey = isInstanceOfClass(value) ? value.constructor?._propertyMetadata?.get("id") : void 0;
+    const entries = Object.entries(value).filter(([key]) => isInstanceOfClass(value) ? key.startsWith("__") || (idKey ? key === idKey : false) : true);
+    for (const [key, childValue] of entries) {
+      const normalizedKey = key.startsWith("__") ? key.slice(2) : key;
+      const childPath = path ? `${path}.${normalizedKey}` : normalizedKey;
+      const serialized = serializeSnapshotDeep(childValue, childPath, options, seen);
+      if (serialized !== SNAPSHOT_SKIP) {
+        result[normalizedKey] = serialized;
+      }
+    }
+    return result;
+  }
+  return value;
+}, "serializeSnapshotDeep");
+function createStatesSnapshotDeep(instance, options = {}) {
+  const persistObject = {};
+  if (instance?.$snapshot) {
+    for (const key of instance.$snapshot.keys()) {
+      const signal = instance.$snapshot.get(key);
+      const persist2 = signal.options.persist ?? true;
+      if (!persist2) {
+        continue;
+      }
+      const value = signal();
+      const serialized = serializeSnapshotDeep(value, key, options, /* @__PURE__ */ new WeakSet());
+      if (serialized !== SNAPSHOT_SKIP) {
+        persistObject[key] = serialized;
+      }
+    }
+  }
+  return persistObject;
+}
+__name$2(createStatesSnapshotDeep, "createStatesSnapshotDeep");
+function setMetadata(target, key, value) {
+  const meta = target.constructor._propertyMetadata;
+  const propId = meta?.get(key);
+  if (propId) {
+    if (isSignal(target[propId])) {
+      target[propId].set(value);
+    } else {
+      target[propId] = value;
+    }
+  }
+}
+__name$2(setMetadata, "setMetadata");
+var createSyncClass = /* @__PURE__ */ __name$2((currentClass, parentKey = null, parentClass = null, path = "") => {
+  currentClass.$path = path;
+  if (parentClass) {
+    currentClass.$valuesChanges = parentClass.$valuesChanges;
+  }
+  if (parentKey) {
+    setMetadata(currentClass, "id", parentKey);
+  }
+  if (currentClass.$snapshot) {
+    for (const key of currentClass.$snapshot.keys()) {
+      const signal = currentClass.$snapshot.get(key);
+      const syncToClient = signal.options?.syncToClient ?? true;
+      const persist2 = signal.options?.persist ?? true;
+      const transform = signal.options?.transform;
+      let signalValue = signal();
+      if (transform) {
+        signalValue = transform(signalValue);
+      }
+      if (isObject(signalValue) || Array.isArray(signalValue)) {
+        signalValue = {
+          ...signalValue
+        };
+      }
+      const transformedValue = signalValue;
+      const newPath = (path ? path + "." : "") + key;
+      if (syncToClient) {
+        currentClass.$valuesChanges.set(newPath, transformedValue);
+      }
+      if (persist2) {
+        if (parentClass) currentClass.$valuesChanges.setPersist(path, transformedValue);
+      }
+      if (isComputed(signal)) {
+        signal.observable.subscribe((newValue) => {
+          if (syncToClient) {
+            const transformedNewValue = transform ? transform(newValue) : newValue;
+            currentClass.$valuesChanges.set(newPath, transformedNewValue);
+          }
+        });
+      }
+    }
+  }
+}, "createSyncClass");
+var type = /* @__PURE__ */ __name$2((_signal, path, options = {}, currentInstance) => {
+  const { syncToClient = true, persist: persist2 = true, transform } = options;
+  let init = true;
+  const handleObjectSubject = /* @__PURE__ */ __name$2((value, propPath) => {
+    const newPath = `${propPath}${value.key ? `.${value.key}` : ""}`;
+    if ([
+      "add",
+      "reset",
+      "update"
+    ].includes(value.type)) {
+      if (isInstanceOfClass(value.value)) {
+        createSyncClass(value.value, value.key, currentInstance, newPath);
+      } else if (value.type === "update" && (isObject(value.value) || Array.isArray(value.value))) {
+        createSyncClass(value.value, value.key, currentInstance, newPath);
+      } else {
+        savePath(newPath, value.value);
+      }
+    } else if (value.type === "remove") {
+      savePath(newPath, DELETE_TOKEN);
+    }
+  }, "handleObjectSubject");
+  const handleArraySubject = /* @__PURE__ */ __name$2((value, propPath) => {
+    if (value.type === "reset" && Array.isArray(value.items)) {
+      value.items.forEach((item, index) => {
+        const newPath2 = `${propPath}.${index}`;
+        if (isInstanceOfClass(item)) {
+          createSyncClass(item, value.key, currentInstance, newPath2);
+        } else {
+          savePath(newPath2, item);
+        }
+      });
+      return;
+    }
+    const newPath = `${propPath}.${value.index}`;
+    const firstItem = value.items?.[0];
+    if ([
+      "add",
+      "update"
+    ].includes(value.type) && firstItem !== void 0) {
+      if (isInstanceOfClass(firstItem)) {
+        createSyncClass(firstItem, value.key, currentInstance, newPath);
+      } else if (value.type === "update" && (isObject(firstItem) || Array.isArray(firstItem))) {
+        createSyncClass(firstItem, value.key, currentInstance, newPath);
+      } else {
+        savePath(newPath, firstItem);
+      }
+    } else if (value.type === "remove") {
+      savePath(newPath, DELETE_TOKEN);
+    }
+  }, "handleArraySubject");
+  const savePath = /* @__PURE__ */ __name$2((propPath, value) => {
+    const transformedValue = transform && value !== DELETE_TOKEN ? transform(value) : value;
+    if (syncToClient) {
+      currentInstance.$valuesChanges.set(propPath, transformedValue);
+    }
+    if (persist2 && currentInstance.$path !== void 0) {
+      currentInstance.$valuesChanges.setPersist(transformedValue == DELETE_TOKEN ? propPath : currentInstance.$path, transformedValue);
+    }
+  }, "savePath");
+  const setupSubscription = /* @__PURE__ */ __name$2((signal, signalPath) => {
+    if (!isSignal(signal)) return;
+    if (syncToClient && currentInstance.$valuesChanges) {
+      const initialValue = signal();
+      const transformedInitialValue = transform ? transform(initialValue) : initialValue;
+      currentInstance.$valuesChanges.set(signalPath, transformedInitialValue);
+    }
+    signal.options = options;
+    signal.observable.subscribe((value) => {
+      if (init) return;
+      if (currentInstance.$path !== void 0) {
+        const fullPath = `${currentInstance.$path ? currentInstance.$path + "." : ""}${signalPath}`;
+        if (isComputed(signal)) {
+          savePath(fullPath, value);
+        } else if (isObjectSubject(signal._subject)) {
+          handleObjectSubject(value, fullPath);
+        } else if (isArraySubject(signal._subject)) {
+          handleArraySubject(value, fullPath);
+        } else {
+          savePath(fullPath, value);
+        }
+      }
+    });
+    if (!currentInstance.$snapshot) {
+      currentInstance.$snapshot = /* @__PURE__ */ new Map();
+    }
+    currentInstance.$snapshot.set(path, signal);
+  }, "setupSubscription");
+  if (!isSignal(_signal)) {
+    if (_signal && typeof _signal === "object" && !Array.isArray(_signal)) {
+      for (const key in _signal) {
+        if (Object.prototype.hasOwnProperty.call(_signal, key)) {
+          const value = _signal[key];
+          const propertyPath = `${path}.${key}`;
+          if (isSignal(value)) {
+            setupSubscription(value, propertyPath);
+          } else if (value && typeof value === "object" && !Array.isArray(value)) {
+            type(value, propertyPath, options, currentInstance);
+          }
+        }
+      }
+      init = false;
+    }
+    return _signal;
+  }
+  setupSubscription(_signal, path);
+  init = false;
+  return _signal;
+}, "type");
+
+// src/decorators.ts
+function sync(options) {
+  let classType;
+  let persist2 = true;
+  let syncToClient = true;
+  let transform;
+  if (typeof options === "function") {
+    classType = options;
+  } else if (typeof options === "object") {
+    classType = options.classType;
+    if (options.hasOwnProperty("persist")) {
+      persist2 = options.persist;
+    }
+    if (options.hasOwnProperty("syncToClient")) {
+      syncToClient = options.syncToClient;
+    }
+    if (options.hasOwnProperty("transform")) {
+      transform = options.transform;
+    }
+  }
+  return function(target, propertyKey) {
+    const privatePropertyKey = `__${propertyKey}`;
+    const getter = /* @__PURE__ */ __name$2(function() {
+      return this[privatePropertyKey];
+    }, "getter");
+    const setter = /* @__PURE__ */ __name$2(function(newVal) {
+      this[privatePropertyKey] = type(newVal, propertyKey, {
+        classType,
+        persist: persist2,
+        syncToClient,
+        transform
+      }, this);
+    }, "setter");
+    Object.defineProperty(target, propertyKey, {
+      get: getter,
+      set: setter,
+      enumerable: true,
+      configurable: true
+    });
+  };
+}
+__name$2(sync, "sync");
+function id() {
+  return function(target, propertyKey) {
+    if (!target.constructor._propertyMetadata) {
+      target.constructor._propertyMetadata = /* @__PURE__ */ new Map();
+    }
+    target.constructor._propertyMetadata.set("id", propertyKey);
+  };
+}
+__name$2(id, "id");
+function users(options) {
+  return function(target, propertyKey) {
+    if (!target.constructor._propertyMetadata) {
+      target.constructor._propertyMetadata = /* @__PURE__ */ new Map();
+    }
+    target.constructor._propertyMetadata.set("users", propertyKey);
+    sync(options)(target, propertyKey);
+  };
+}
+__name$2(users, "users");
+function persist() {
+  return sync({
+    persist: true,
+    syncToClient: false
+  });
+}
+__name$2(persist, "persist");
+function connected() {
+  return function(target, propertyKey) {
+    if (!target.constructor._propertyMetadata) {
+      target.constructor._propertyMetadata = /* @__PURE__ */ new Map();
+    }
+    target.constructor._propertyMetadata.set("connected", propertyKey);
+    sync({
+      persist: false
+    })(target, propertyKey);
+  };
+}
+__name$2(connected, "connected");
+function load(rootInstance, values, valueIsObject) {
+  if (valueIsObject) {
+    loadFromObject(rootInstance, values);
+  } else {
+    loadFromPaths(rootInstance, values);
+  }
+}
+__name$2(load, "load");
+function loadFromPaths(rootInstance, values) {
+  for (const [path, value] of Object.entries(values)) {
+    const parts = path.split(".");
+    loadValue(rootInstance, parts, value);
+  }
+}
+__name$2(loadFromPaths, "loadFromPaths");
+function loadFromObject(rootInstance, values, currentPath = "") {
+  for (let key in values) {
+    const value = values[key];
+    const newPath = currentPath ? `${currentPath}.${key}` : key;
+    if (typeof value === "object" && !Array.isArray(value) && value !== null) {
+      loadFromObject(rootInstance, value, newPath);
+    } else {
+      const parts = newPath.split(".");
+      loadValue(rootInstance, parts, value);
+    }
+  }
+}
+__name$2(loadFromObject, "loadFromObject");
+function loadValue(rootInstance, parts, value) {
+  let current = rootInstance;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (i === parts.length - 1) {
+      if (value == DELETE_TOKEN) {
+        if (isSignal(current)) {
+          current = current();
+        }
+        Reflect.deleteProperty(current, part);
+      } else if (current[part]?._subject) {
+        current[part].set(value);
+      } else if (isSignal(current) && Array.isArray(current()) && !isNaN(Number(part))) {
+        current()[Number(part)] = value;
+      } else {
+        current[part] = value;
+      }
+    } else {
+      if (isSignal(current)) {
+        current = current();
+      }
+      const currentValue = current[part];
+      if (currentValue === void 0) {
+        const parentInstance = getByPath(rootInstance, parts.slice(0, i).join("."));
+        const classType = parentInstance?.options?.classType;
+        if (classType) {
+          current[part] = !isClass(classType) ? classType(part) : new classType();
+          setMetadata(current[part], "id", part);
+        } else {
+          current[part] = {};
+        }
+      }
+      current = current[part];
+    }
+  }
+}
+__name$2(loadValue, "loadValue");
+function getByPath(root, path) {
+  const parts = path.split(".");
+  let current = root;
+  for (const part of parts) {
+    if (isSignal(current)) {
+      current = current();
+    }
+    if (current[part]) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+__name$2(getByPath, "getByPath");
+
+var __defProp$3 = Object.defineProperty;
+var __decorateClass$2 = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp$3(target, key, result);
+  return result;
+};
+class Item {
+  constructor(data) {
+    this.id = signal("");
+    this.name = signal("");
+    this.description = signal("");
+    this.price = signal(0);
+    this.atk = signal(0);
+    this.pdef = signal(0);
+    this.sdef = signal(0);
+    this.icon = signal("");
+    this.quantity = signal(1);
+    this.onAdd = () => {
+    };
+    this.description.set(data?.description ?? "");
+    this.price.set(data?.price ?? 0);
+    this.name.set(data?.name ?? "");
+    this.atk.set(data?.atk ?? 0);
+    this.pdef.set(data?.pdef ?? 0);
+    this.sdef.set(data?.sdef ?? 0);
+    this.icon.set(data?.icon ?? "");
+    this.onAdd = data?.onAdd?.bind(this) ?? (() => {
+    });
+  }
+}
+__decorateClass$2([
+  id()
+], Item.prototype, "id");
+__decorateClass$2([
+  sync()
+], Item.prototype, "name");
+__decorateClass$2([
+  sync()
+], Item.prototype, "icon");
+__decorateClass$2([
+  sync()
+], Item.prototype, "quantity");
+
+var __defProp$2 = Object.defineProperty;
+var __decorateClass$1 = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp$2(target, key, result);
+  return result;
+};
+class Skill {
+  constructor(data) {
+    this.id = signal("");
+    this.name = signal("");
+    this.description = signal("");
+    this.spCost = signal(0);
+    this.icon = signal("");
+    this.hitRate = signal(0);
+    this.power = signal(0);
+    this.coefficient = signal({});
+    this.id.set(data?.id ?? "");
+    this.name.set(data?.name ?? "");
+    this.description.set(data?.description ?? "");
+    this.spCost.set(data?.spCost ?? 0);
+    this.hitRate.set(data?.hitRate ?? 0);
+    this.power.set(data?.power ?? 0);
+    this.coefficient.set(data?.coefficient ?? {});
+    this.icon.set(data?.icon ?? "");
+  }
+}
+__decorateClass$1([
+  id()
+], Skill.prototype, "id");
+__decorateClass$1([
+  sync()
+], Skill.prototype, "name");
+__decorateClass$1([
+  sync()
+], Skill.prototype, "spCost");
+__decorateClass$1([
+  sync()
+], Skill.prototype, "icon");
+
+var __defProp$1 = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0 ;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(target, key, result) ) || result;
+  if (result) __defProp$1(target, key, result);
+  return result;
+};
+var Direction = /* @__PURE__ */ ((Direction2) => {
+  Direction2["Up"] = "up";
+  Direction2["Down"] = "down";
+  Direction2["Left"] = "left";
+  Direction2["Right"] = "right";
+  return Direction2;
+})(Direction || {});
+class RpgCommonPlayer {
+  constructor() {
+    this.name = signal("");
+    this.type = signal("");
+    this.x = signal(0);
+    this.y = signal(0);
+    this.z = signal(0);
+    this.tint = signal("white");
+    this.direction = signal("down" /* Down */);
+    this.speed = signal(4);
+    this.graphics = signal([]);
+    this.canMove = signal(true);
+    this.hitbox = signal({
+      w: 32,
+      h: 32
+    });
+    this._gold = signal(0);
+    this.animationName = signal("stand");
+    this.hpSignal = signal(0);
+    this.spSignal = signal(0);
+    this._exp = signal(0);
+    this._level = signal(1);
+    this._class = signal({});
+    this.items = signal([]);
+    this.equipments = signal([]);
+    this.states = signal([]);
+    this.skills = signal([]);
+    this._effects = signal([]);
+    this._through = signal(false);
+    this._throughOtherPlayer = signal(true);
+    this._throughEvent = signal(false);
+    this._frequency = signal(0);
+    this._frames = signal([]);
+    this.componentsTop = signal(null);
+    this.componentsBottom = signal(null);
+    this.componentsCenter = signal(null);
+    this.componentsLeft = signal(null);
+    this.componentsRight = signal(null);
+    this.isConnected = signal(false);
+    // Store intended movement direction (not synced, only used locally)
+    this._intendedDirection = null;
+    // Direction and animation locking (server-side only, not synced)
+    this._directionFixed = signal(false);
+    this._animationFixed = signal(false);
+    this.pendingInputs = [];
+  }
+  /**
+   * Get whether direction changes are locked
+   * 
+   * @returns True if direction is locked and cannot be changed automatically
+   * 
+   * @example
+   * ```ts
+   * if (player.directionFixed) {
+   *   // Direction is locked, won't change automatically
+   * }
+   * ```
+   */
+  get directionFixed() {
+    return this._directionFixed();
+  }
+  /**
+   * Set whether direction changes are locked
+   * 
+   * When set to true, the player's direction will not change automatically
+   * during movement or from physics engine callbacks.
+   * 
+   * @param value - True to lock direction, false to allow automatic changes
+   * 
+   * @example
+   * ```ts
+   * // Lock direction during a special animation
+   * player.directionFixed = true;
+   * player.setAnimation('attack');
+   * // ... later
+   * player.directionFixed = false;
+   * ```
+   */
+  set directionFixed(value) {
+    this._directionFixed.set(value);
+  }
+  /**
+   * Get whether animation changes are locked
+   * 
+   * @returns True if animation is locked and cannot be changed automatically
+   * 
+   * @example
+   * ```ts
+   * if (player.animationFixed) {
+   *   // Animation is locked, won't change automatically
+   * }
+   * ```
+   */
+  get animationFixed() {
+    return this._animationFixed();
+  }
+  /**
+   * Set whether animation changes are locked
+   * 
+   * When set to true, the player's animation will not change automatically
+   * during movement or from physics engine callbacks.
+   * 
+   * @param value - True to lock animation, false to allow automatic changes
+   * 
+   * @example
+   * ```ts
+   * // Lock animation during a special skill
+   * player.animationFixed = true;
+   * player.setAnimation('skill');
+   * // ... later
+   * player.animationFixed = false;
+   * ```
+   */
+  set animationFixed(value) {
+    this._animationFixed.set(value);
+  }
+  /**
+   * Change the player's facing direction
+   *
+   * Updates the direction the player is facing, which affects animations
+   * and directional abilities. This should be called when the player
+   * intends to move in a specific direction, not when they are pushed
+   * by physics or sliding.
+   * 
+   * If `directionFixed` is true, this method will not change the direction.
+   *
+   * @param direction - The new direction to face
+   *
+   * @example
+   * ```ts
+   * // Player presses right arrow key
+   * player.changeDirection(Direction.Right);
+   * 
+   * // Lock direction to prevent automatic changes
+   * player.directionFixed = true;
+   * player.changeDirection(Direction.Up); // This will be ignored
+   * ```
+   */
+  changeDirection(direction) {
+    if (this._directionFixed()) {
+      return;
+    }
+    this.direction.set(direction);
+  }
+  /**
+   * Get the current facing direction
+   *
+   * @returns Current direction the player is facing
+   *
+   * @example
+   * ```ts
+   * const currentDirection = player.getDirection();
+   * if (currentDirection === Direction.Up) {
+   *   // Player is facing up
+   * }
+   * ```
+   */
+  getDirection() {
+    return this.direction();
+  }
+}
+__decorateClass([
+  id()
+], RpgCommonPlayer.prototype, "id");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "name");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "type");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "x");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "y");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "z");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "tint");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "direction");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "speed");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "graphics");
+__decorateClass([
+  sync({
+    persist: false
+  })
+], RpgCommonPlayer.prototype, "canMove");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "hitbox");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "_gold");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "animationName");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "hpSignal");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "spSignal");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "_exp");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "_level");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "_class");
+__decorateClass([
+  sync(Item)
+], RpgCommonPlayer.prototype, "items");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "equipments");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "states");
+__decorateClass([
+  sync(Skill)
+], RpgCommonPlayer.prototype, "skills");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "_effects");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "_through");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "_throughOtherPlayer");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "_throughEvent");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "_frequency");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "_frames");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "componentsTop");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "componentsBottom");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "componentsCenter");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "componentsLeft");
+__decorateClass([
+  sync()
+], RpgCommonPlayer.prototype, "componentsRight");
+__decorateClass([
+  connected()
+], RpgCommonPlayer.prototype, "isConnected");
+
+class Vector2 {
+  /**
+   * Creates a new Vector2
+   * 
+   * @param x - X component (default: 0)
+   * @param y - Y component (default: 0)
+   */
+  constructor(x = 0, y = 0) {
+    this.x = x;
+    this.y = y;
+  }
+  /**
+   * Creates a copy of this vector
+   * 
+   * @returns A new Vector2 with the same values
+   */
+  clone() {
+    return new Vector2(this.x, this.y);
+  }
+  /**
+   * Sets the components of this vector
+   * 
+   * @param x - X component
+   * @param y - Y component
+   * @returns This vector for chaining
+   */
+  set(x, y) {
+    this.x = x;
+    this.y = y;
+    return this;
+  }
+  /**
+   * Copies values from another vector
+   * 
+   * @param other - Vector to copy from
+   * @returns This vector for chaining
+   */
+  copyFrom(other) {
+    this.x = other.x;
+    this.y = other.y;
+    return this;
+  }
+  /**
+   * Adds another vector to this vector (immutable)
+   * 
+   * @param other - Vector to add
+   * @returns New vector with the result
+   */
+  add(other) {
+    return new Vector2(this.x + other.x, this.y + other.y);
+  }
+  /**
+   * Adds another vector to this vector (in-place)
+   * 
+   * @param other - Vector to add
+   * @returns This vector for chaining
+   */
+  addInPlace(other) {
+    this.x += other.x;
+    this.y += other.y;
+    return this;
+  }
+  /**
+   * Subtracts another vector from this vector (immutable)
+   * 
+   * @param other - Vector to subtract
+   * @returns New vector with the result
+   */
+  sub(other) {
+    return new Vector2(this.x - other.x, this.y - other.y);
+  }
+  /**
+   * Subtracts another vector from this vector (in-place)
+   * 
+   * @param other - Vector to subtract
+   * @returns This vector for chaining
+   */
+  subInPlace(other) {
+    this.x -= other.x;
+    this.y -= other.y;
+    return this;
+  }
+  /**
+   * Multiplies this vector by a scalar (immutable)
+   * 
+   * @param scalar - Scalar value
+   * @returns New vector with the result
+   */
+  mul(scalar) {
+    return new Vector2(this.x * scalar, this.y * scalar);
+  }
+  /**
+   * Multiplies this vector by a scalar (in-place)
+   * 
+   * @param scalar - Scalar value
+   * @returns This vector for chaining
+   */
+  mulInPlace(scalar) {
+    this.x *= scalar;
+    this.y *= scalar;
+    return this;
+  }
+  /**
+   * Divides this vector by a scalar (immutable)
+   * 
+   * @param scalar - Scalar value (must not be zero)
+   * @returns New vector with the result
+   */
+  div(scalar) {
+    return new Vector2(this.x / scalar, this.y / scalar);
+  }
+  /**
+   * Divides this vector by a scalar (in-place)
+   * 
+   * @param scalar - Scalar value (must not be zero)
+   * @returns This vector for chaining
+   */
+  divInPlace(scalar) {
+    this.x /= scalar;
+    this.y /= scalar;
+    return this;
+  }
+  /**
+   * Calculates the dot product with another vector
+   * 
+   * @param other - Vector to dot with
+   * @returns Dot product value
+   */
+  dot(other) {
+    return this.x * other.x + this.y * other.y;
+  }
+  /**
+   * Calculates the 2D cross product (scalar result)
+   * 
+   * @param other - Vector to cross with
+   * @returns Cross product value (z-component of 3D cross product)
+   */
+  cross(other) {
+    return this.x * other.y - this.y * other.x;
+  }
+  /**
+   * Calculates the squared length (faster than length, avoids sqrt)
+   * 
+   * @returns Squared length
+   */
+  lengthSquared() {
+    return this.x * this.x + this.y * this.y;
+  }
+  /**
+   * Calculates the length (magnitude) of the vector
+   * 
+   * @returns Length
+   */
+  length() {
+    return Math.sqrt(this.lengthSquared());
+  }
+  /**
+   * Normalizes this vector to unit length (immutable)
+   * 
+   * @returns New normalized vector
+   */
+  normalize() {
+    const len = this.length();
+    if (len === 0) {
+      return new Vector2(0, 0);
+    }
+    return this.div(len);
+  }
+  /**
+   * Normalizes this vector to unit length (in-place)
+   * 
+   * @returns This vector for chaining
+   */
+  normalizeInPlace() {
+    const len = this.length();
+    if (len === 0) {
+      this.x = 0;
+      this.y = 0;
+    } else {
+      this.divInPlace(len);
+    }
+    return this;
+  }
+  /**
+   * Calculates the distance to another vector
+   * 
+   * @param other - Target vector
+   * @returns Distance
+   */
+  distanceTo(other) {
+    return this.sub(other).length();
+  }
+  /**
+   * Calculates the squared distance to another vector (faster)
+   * 
+   * @param other - Target vector
+   * @returns Squared distance
+   */
+  distanceToSquared(other) {
+    return this.sub(other).lengthSquared();
+  }
+  /**
+   * Rotates this vector by an angle in radians (immutable)
+   * 
+   * @param angle - Angle in radians
+   * @returns New rotated vector
+   */
+  rotate(angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return new Vector2(
+      this.x * cos - this.y * sin,
+      this.x * sin + this.y * cos
+    );
+  }
+  /**
+   * Rotates this vector by an angle in radians (in-place)
+   * 
+   * @param angle - Angle in radians
+   * @returns This vector for chaining
+   */
+  rotateInPlace(angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const x = this.x * cos - this.y * sin;
+    const y = this.x * sin + this.y * cos;
+    this.x = x;
+    this.y = y;
+    return this;
+  }
+  /**
+   * Calculates the angle of this vector in radians
+   * 
+   * @returns Angle in radians (range: -π to π)
+   */
+  angle() {
+    return Math.atan2(this.y, this.x);
+  }
+  /**
+   * Linearly interpolates between this vector and another
+   * 
+   * @param other - Target vector
+   * @param t - Interpolation factor (0 to 1)
+   * @returns New interpolated vector
+   */
+  lerp(other, t) {
+    return new Vector2(
+      this.x + (other.x - this.x) * t,
+      this.y + (other.y - this.y) * t
+    );
+  }
+  /**
+   * Checks if this vector equals another (with epsilon tolerance)
+   * 
+   * @param other - Vector to compare
+   * @param epsilon - Tolerance for comparison (default: 1e-5)
+   * @returns True if vectors are approximately equal
+   */
+  equals(other, epsilon = 1e-5) {
+    return Math.abs(this.x - other.x) < epsilon && Math.abs(this.y - other.y) < epsilon;
+  }
+  /**
+   * Returns a string representation of this vector
+   * 
+   * @returns String representation
+   */
+  toString() {
+    return `Vector2(${this.x}, ${this.y})`;
+  }
+  static {
+    /**
+     * Static zero vector
+     */
+    this.ZERO = new Vector2(0, 0);
+  }
+  static {
+    /**
+     * Static unit X vector
+     */
+    this.UNIT_X = new Vector2(1, 0);
+  }
+  static {
+    /**
+     * Static unit Y vector
+     */
+    this.UNIT_Y = new Vector2(0, 1);
+  }
+}
+
+const ModulesToken = "ModulesToken";
+function RpgModule(options) {
+  return (target) => {
+    if (options.hooks) {
+      target.hooks = options.hooks;
+    }
+    for (let key in options) {
+      target.prototype[key] = options[key];
+    }
+  };
+}
+class Hooks {
+  constructor(modules, namespace) {
+    this.modules = modules;
+    this.namespace = namespace;
+    /**
+     * Store of all module hooks by ID
+     */
+    this.moduleHooks = {};
+    /**
+     * Store of all hook functions by ID
+     */
+    this.hookFunctions = {};
+    this.init();
+  }
+  init() {
+    for (const module of this.modules) {
+      for (const type in module) {
+        const hookObject = module[type];
+        for (const hook in hookObject) {
+          const hookFunction = hookObject[hook];
+          if (hookFunction) {
+            const hookId = `${this.namespace}-${type}-${hook}`;
+            if (!this.moduleHooks[hookId]) {
+              this.moduleHooks[hookId] = new Subject();
+            }
+            if (!this.hookFunctions[hookId]) {
+              this.hookFunctions[hookId] = [];
+            }
+            if (!this.hookFunctions[hookId].includes(hookFunction)) {
+              this.hookFunctions[hookId].push(hookFunction);
+            }
+          }
+        }
+      }
+    }
+    return this.moduleHooks;
+  }
+  /**
+   * Call hooks for a specific ID, passing arguments to all subscribed hooks
+   *
+   * @param hookId - The unique identifier of the module hook
+   * @param args - Arguments to pass to the hook functions
+   * @returns An Observable that emits an array with all hook results when subscribed
+   * @example
+   * ```ts
+   * // Call all hook functions for the ID 'my-namespace-type-hook'
+   * callHooks('my-namespace-type-hook', { x: 10, y: 20 }).subscribe(results => {
+   *   console.log('Hook results:', results);  // Array of all hook function results
+   * });
+   * 
+   * // Hook functions are only executed when you subscribe to the returned Observable
+   * const observable = callHooks('my-namespace-type-hook', player);
+   * // ... later ...
+   * observable.subscribe(results => {
+   *   // Process results array
+   * });
+   * ```
+   */
+  callHooks(hookId, ...args) {
+    if (!this.moduleHooks[hookId]) {
+      this.moduleHooks[hookId] = new Subject();
+    }
+    return new Observable((subscriber) => {
+      if (this.hookFunctions[hookId] && this.hookFunctions[hookId].length > 0) {
+        const hookResults$ = from(this.hookFunctions[hookId]).pipe(
+          mergeMap((hookFunction) => {
+            let result;
+            try {
+              result = hookFunction(...args);
+              return from(Promise.resolve(result));
+            } catch (error) {
+              subscriber.error(error);
+              return [];
+            }
+          }),
+          toArray()
+          // Collect all results into an array
+        );
+        const subscription = hookResults$.subscribe({
+          next: (results) => {
+            this.moduleHooks[hookId].next(results);
+            subscriber.next(results);
+            subscriber.complete();
+          },
+          error: (err) => {
+            subscriber.error(err);
+          }
+        });
+        return () => {
+          subscription.unsubscribe();
+        };
+      } else {
+        subscriber.next([]);
+        subscriber.complete();
+        return () => {
+        };
+      }
+    });
+  }
+}
+function provideModules(modules, namespace, transform) {
+  return {
+    provide: ModulesToken,
+    useFactory: (context) => {
+      modules = transform ? transform(modules, context) : modules;
+      return new Hooks(modules, namespace);
+    }
+  };
+}
+function findModules(context, namespace) {
+  let modules = [];
+  for (let key in context["values"]) {
+    if (key.endsWith("Module" + namespace)) {
+      modules.push(context["values"][key].values.get("__default__"));
+    }
+  }
+  return modules;
+}
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/inject.ts
+var DEFAULT_INSTANCE_KEY = "__default__";
+function toTokenName(token) {
+  return typeof token === "function" ? token.name : token;
+}
+__name(toTokenName, "toTokenName");
+function toInstanceKey(name) {
+  return name ?? DEFAULT_INSTANCE_KEY;
+}
+__name(toInstanceKey, "toInstanceKey");
+function getRecord(context, token) {
+  return context.get("inject:" + toTokenName(token));
+}
+__name(getRecord, "getRecord");
+function ensureRecord(context, token) {
+  const key = "inject:" + toTokenName(token);
+  let record = context.get(key);
+  if (!record) {
+    record = {
+      multi: false,
+      values: /* @__PURE__ */ new Map(),
+      injected: /* @__PURE__ */ new Set()
+    };
+  }
+  context.set(key, record);
+  return record;
+}
+__name(ensureRecord, "ensureRecord");
+function provide(context, token, value, options = {}) {
+  const record = ensureRecord(context, token);
+  const instanceKey = toInstanceKey(options.name);
+  if (options.multi) {
+    record.multi = true;
+  }
+  if (!record.multi && instanceKey !== DEFAULT_INSTANCE_KEY) {
+    record.multi = true;
+  }
+  record.values.set(instanceKey, value);
+  return value;
+}
+__name(provide, "provide");
+function isInjected(context, token, options = {}) {
+  const record = getRecord(context, token);
+  if (!record) {
+    return false;
+  }
+  if (options.name) {
+    return record.injected.has(toInstanceKey(options.name));
+  }
+  if (record.multi) {
+    return record.injected.size > 0;
+  }
+  return record.injected.has(DEFAULT_INSTANCE_KEY);
+}
+__name(isInjected, "isInjected");
+function isProvided(context, token, options = {}) {
+  const record = getRecord(context, token);
+  if (!record) {
+    return false;
+  }
+  if (options.name) {
+    return record.values.has(toInstanceKey(options.name));
+  }
+  if (record.multi) {
+    return record.values.size > 0;
+  }
+  return record.values.has(DEFAULT_INSTANCE_KEY);
+}
+__name(isProvided, "isProvided");
+function hasInstance(context, token, options = {}) {
+  return isProvided(context, token, options);
+}
+__name(hasInstance, "hasInstance");
+function handleMissingInjection(token, options) {
+  const name = toTokenName(token);
+  if (options.name) {
+    throw new Error(`Injection provider ${name} with name ${options.name} not found`);
+  }
+  throw new Error(`Injection provider ${name} not found`);
+}
+__name(handleMissingInjection, "handleMissingInjection");
+function markInjected(record, key) {
+  record.injected.add(key);
+}
+__name(markInjected, "markInjected");
+function markAllInjected(record) {
+  for (const key of record.values.keys()) {
+    record.injected.add(key);
+  }
+}
+__name(markAllInjected, "markAllInjected");
+function inject$1(context, token, options = {}) {
+  const record = getRecord(context, token);
+  if (!record) {
+    if (options.optional) {
+      return options.multi ? [] : void 0;
+    }
+    return handleMissingInjection(token, options);
+  }
+  if (options.name) {
+    const instanceKey = toInstanceKey(options.name);
+    if (!record.values.has(instanceKey)) {
+      if (options.optional) {
+        return void 0;
+      }
+      return handleMissingInjection(token, options);
+    }
+    const value2 = record.values.get(instanceKey);
+    markInjected(record, instanceKey);
+    return value2;
+  }
+  if (options.multi || record.multi) {
+    if (record.values.size === 0) {
+      if (options.optional) {
+        return [];
+      }
+      return handleMissingInjection(token, options);
+    }
+    markAllInjected(record);
+    return Array.from(record.values.values());
+  }
+  const value = record.values.get(DEFAULT_INSTANCE_KEY);
+  if (value === void 0) {
+    if (options.optional) {
+      return void 0;
+    }
+    return handleMissingInjection(token, options);
+  }
+  markInjected(record, DEFAULT_INSTANCE_KEY);
+  return value;
+}
+__name(inject$1, "inject");
+function override(providers, newProvider, options) {
+  let { upsert = false, key } = options ?? {};
+  if (!key) {
+    key = typeof newProvider === "function" ? newProvider.name : newProvider.provide;
+  }
+  const flatProviders = providers.flat();
+  const exists = flatProviders.some((provider) => {
+    if (typeof provider === "function") {
+      return provider.name === key;
+    } else if (typeof provider === "object") {
+      return provider.provide === key;
+    }
+    return false;
+  });
+  const mappedProviders = flatProviders.map((provider) => {
+    if (typeof provider === "function" && provider.name === key) {
+      return newProvider;
+    } else if (typeof provider === "object" && provider.provide === key) {
+      return newProvider;
+    }
+    return provider;
+  });
+  if (upsert && !exists) {
+    mappedProviders.push(newProvider);
+  }
+  return mappedProviders;
+}
+__name(override, "override");
+function findProviders(providers, name) {
+  const results = [];
+  for (const provider of providers) {
+    if (Array.isArray(provider)) {
+      results.push(...findProviders(provider, name));
+    } else if (findProvider(provider, name)) {
+      results.push(provider);
+    }
+  }
+  return results;
+}
+__name(findProviders, "findProviders");
+function findProvider(providers, name) {
+  if (!Array.isArray(providers)) {
+    if (typeof providers === "object" && "provide" in providers) {
+      const provider = providers;
+      const providerName = typeof provider.provide === "function" ? provider.provide.name : provider.provide;
+      if (name instanceof RegExp) {
+        if (name.test(providerName)) return providers;
+      } else {
+        if (providerName === name) return providers;
+      }
+    }
+    return null;
+  }
+  for (const provider of providers) {
+    if (Array.isArray(provider)) {
+      const found = findProvider(provider, name);
+      if (found) return found;
+      continue;
+    }
+    if (typeof provider === "object" && "provide" in provider) {
+      const providerName = typeof provider.provide === "function" ? provider.provide.name : provider.provide;
+      if (name instanceof RegExp) {
+        if (name.test(providerName)) return provider;
+      } else {
+        if (providerName === name) return provider;
+      }
+    }
+  }
+  return null;
+}
+__name(findProvider, "findProvider");
+
+// src/merge-config.ts
+function processProvider(mergedConfig, baseConfig, provider) {
+  if (Array.isArray(provider)) {
+    for (const nestedProvider of provider) {
+      processProvider(mergedConfig, baseConfig, nestedProvider);
+    }
+    return;
+  }
+  const existingProvider = findProvider(baseConfig.providers, provider.provide);
+  if (existingProvider) {
+    mergedConfig.providers = override(mergedConfig.providers, provider);
+  } else {
+    mergedConfig.providers.push(provider);
+  }
+}
+__name(processProvider, "processProvider");
+function mergeConfig(baseConfig, config) {
+  const mergedConfig = {
+    ...baseConfig,
+    ...config,
+    providers: [
+      ...baseConfig.providers
+    ]
+    // Start with a copy of base providers
+  };
+  for (const provider of config.providers) {
+    processProvider(mergedConfig, baseConfig, provider);
+  }
+  return mergedConfig;
+}
+__name(mergeConfig, "mergeConfig");
+
+// src/provider.ts
+function extractProvideOptions(source) {
+  if (!source) {
+    return void 0;
+  }
+  const { multi, name } = source;
+  if (multi === void 0 && name === void 0) {
+    return void 0;
+  }
+  return {
+    multi,
+    name
+  };
+}
+__name(extractProvideOptions, "extractProvideOptions");
+function getDeps(provider) {
+  if (typeof provider === "function") {
+    return provider.deps ?? [];
+  }
+  return provider.deps ?? [];
+}
+__name(getDeps, "getDeps");
+function sortProviders(providers) {
+  const tokenName = /* @__PURE__ */ __name((t) => typeof t === "function" ? t.name : t, "tokenName");
+  const map = /* @__PURE__ */ new Map();
+  for (const p of providers) {
+    const token = tokenName(typeof p === "function" ? p : p.provide);
+    const list = map.get(token);
+    if (list) {
+      list.push(p);
+    } else {
+      map.set(token, [
+        p
+      ]);
+    }
+  }
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const visit = /* @__PURE__ */ __name((token) => {
+    const name = tokenName(token);
+    if (visited.has(name)) return;
+    if (stack.has(name)) {
+      throw new Error(`Circular dependency detected for provider ${name}`);
+    }
+    stack.add(name);
+    const providersForToken = map.get(name);
+    if (providersForToken) {
+      for (const provider of providersForToken) {
+        for (const dep of getDeps(provider)) {
+          visit(dep);
+        }
+        result.push(provider);
+      }
+      visited.add(name);
+    }
+    stack.delete(name);
+  }, "visit");
+  for (const p of providers) {
+    const token = typeof p === "function" ? p : p.provide;
+    visit(token);
+  }
+  return result;
+}
+__name(sortProviders, "sortProviders");
+async function injector(context, providers) {
+  providers = providers.flat();
+  providers = sortProviders(providers);
+  for (const provider of providers) {
+    let token;
+    let instance;
+    let options;
+    if (typeof provider === "function") {
+      token = provider;
+      instance = new provider(context);
+      const diOptions = extractProvideOptions(provider.diOptions ?? provider.di);
+      options = diOptions;
+    } else {
+      token = provider.provide;
+      options = extractProvideOptions(provider);
+      const provideUserClass = provider.useClass;
+      const isClass = typeof provideUserClass === "function";
+      if (isClass) {
+        instance = new provideUserClass(context);
+      } else if ("useValue" in provider) {
+        instance = provider.useValue;
+      } else if ("useFactory" in provider) {
+        instance = provider.useFactory?.(context);
+        if (instance instanceof Promise) {
+          instance = await instance;
+        }
+      } else if ("useExisting" in provider) {
+        instance = inject$1(context, provider.useExisting);
+      }
+    }
+    provide(context, token, instance, options);
+  }
+}
+__name(injector, "injector");
+
+// src/context.ts
+var Context = class {
+  static {
+    __name(this, "Context");
+  }
+  /** Internal storage for injected values */
+  values = {};
+  /**
+   * Sets a value in the context
+   * @param key - Unique identifier for the value
+   * @param value - Value to store
+   */
+  set(key, value) {
+    this.values[key] = value;
+  }
+  /**
+   * Retrieves a value from the context
+   * @param key - Unique identifier for the value
+   * @returns The stored value or undefined if not found
+   */
+  get(key) {
+    return this.values[key];
+  }
+};
+
+let context$1 = null;
+function inject(service, _context) {
+  const c = _context ?? context$1;
+  if (!c) throw new Error("Context is not set. use setInject() to set the context");
+  return inject$1(c, service);
+}
+function setInject(_context) {
+  context$1 = _context;
+}
+function clearInject() {
+  context$1 = null;
+}
+
+const context = new Context();
+context["side"] = "server";
+
+const MAP_UPDATE_TOKEN_HEADER = "x-rpgjs-map-update-token";
+const MAP_UPDATE_TOKEN_ENV = "RPGJS_MAP_UPDATE_TOKEN";
+function getRuntimeProcess() {
+  return globalThis.process;
+}
+function readEnvVariable(name) {
+  const value = getRuntimeProcess()?.env?.[name];
+  return typeof value === "string" ? value : void 0;
+}
+function getWorkingDirectory() {
+  const cwd = getRuntimeProcess()?.cwd;
+  if (typeof cwd !== "function") {
+    return void 0;
+  }
+  try {
+    return cwd();
+  } catch {
+    return void 0;
+  }
+}
+function normalizeRoomMapId(roomId) {
+  return roomId.startsWith("map-") ? roomId.slice(4) : roomId;
+}
+function toBasePathPrefix(basePath) {
+  const trimmed = basePath.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function extractFileLikeMapDefinition(maps, mapId) {
+  for (const mapDef of maps) {
+    if (typeof mapDef === "object" && mapDef) {
+      const candidateId = typeof mapDef.id === "string" ? mapDef.id.replace(/^map-/, "") : "";
+      if (candidateId === mapId) {
+        return mapDef;
+      }
+      continue;
+    }
+    if (typeof mapDef === "string") {
+      const fileName = mapDef.split("/").pop()?.replace(/\.tmx$/i, "");
+      if (fileName === mapId) {
+        return { id: mapId, file: mapDef };
+      }
+    }
+  }
+  return null;
+}
+async function fetchTextByUrl(url) {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      return null;
+    }
+    return await response.text();
+  } catch {
+    return null;
+  }
+}
+async function readTextByFilePath(pathLike) {
+  try {
+    const { readFile } = await import('node:fs/promises');
+    const { isAbsolute, join } = await import('node:path');
+    const cwd = getWorkingDirectory();
+    const candidates = isAbsolute(pathLike) || !cwd ? [pathLike] : [pathLike, join(cwd, pathLike)];
+    for (const candidate of candidates) {
+      try {
+        return await readFile(candidate, "utf8");
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function getTiledBasePaths(paths) {
+  const values = [
+    ...paths || [],
+    readEnvVariable("RPGJS_TILED_BASE_PATH"),
+    "map",
+    "data",
+    "assets/data",
+    "assets/map"
+  ].filter((value) => !!value);
+  return Array.from(new Set(values));
+}
+function resolveMapUpdateToken(explicitToken) {
+  return explicitToken ?? readEnvVariable(MAP_UPDATE_TOKEN_ENV) ?? "";
+}
+function createMapUpdateHeaders(token, init) {
+  const headers = new Headers(init);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/json");
+  }
+  const resolvedToken = resolveMapUpdateToken(token);
+  if (resolvedToken) {
+    headers.set(MAP_UPDATE_TOKEN_HEADER, resolvedToken);
+  }
+  return headers;
+}
+function readMapUpdateToken(headers) {
+  const directToken = headers.get(MAP_UPDATE_TOKEN_HEADER);
+  if (directToken) {
+    return directToken;
+  }
+  const authorization = headers.get("authorization");
+  if (!authorization) {
+    return "";
+  }
+  const [scheme, value] = authorization.split(/\s+/, 2);
+  if (scheme?.toLowerCase() !== "bearer" || !value) {
+    return "";
+  }
+  return value.trim();
+}
+function isMapUpdateAuthorized(headers, expectedToken) {
+  const requiredToken = resolveMapUpdateToken(expectedToken);
+  if (!requiredToken) {
+    return true;
+  }
+  return readMapUpdateToken(headers) === requiredToken;
+}
+async function resolveMapDocument(mapId, mapDefinition, options) {
+  if (typeof mapDefinition?.data === "string" && mapDefinition.data.includes("<map")) {
+    return { xml: mapDefinition.data };
+  }
+  if (typeof mapDefinition?.file === "string") {
+    const file = mapDefinition.file.trim();
+    if (file.includes("<map")) {
+      return { xml: file };
+    }
+    if (/^https?:\/\//i.test(file)) {
+      const xml = await fetchTextByUrl(file);
+      if (xml) {
+        return { xml, sourceUrl: file };
+      }
+    }
+    if (file.startsWith("/") && options.host) {
+      const sourceUrl = `http://${options.host}${file}`;
+      const xml = await fetchTextByUrl(sourceUrl);
+      if (xml) {
+        return { xml, sourceUrl };
+      }
+    }
+    const xmlFromFile = await readTextByFilePath(file);
+    if (xmlFromFile) {
+      return { xml: xmlFromFile };
+    }
+  }
+  if (options.host) {
+    for (const basePath of getTiledBasePaths(options.tiledBasePaths)) {
+      const prefix = toBasePathPrefix(basePath);
+      const sourceUrl = `http://${options.host}${prefix}/${mapId}.tmx`;
+      const xml = await fetchTextByUrl(sourceUrl);
+      if (xml) {
+        return { xml, sourceUrl };
+      }
+    }
+  }
+  return { xml: "" };
+}
+async function enrichMapWithParsedTiledData(payload, options = {}) {
+  if (payload?.parsedMap || typeof payload?.id !== "string") {
+    return;
+  }
+  const maps = Array.isArray(payload.__maps) ? payload.__maps : [];
+  const mapDefinition = extractFileLikeMapDefinition(maps, payload.id);
+  const mapDoc = await resolveMapDocument(payload.id, mapDefinition, options);
+  if (!mapDoc.xml) {
+    return;
+  }
+  try {
+    const tiledModuleName = "@canvasengine/tiled";
+    const tiledModule = await import(
+      /* @vite-ignore */
+      tiledModuleName
+    );
+    const TiledParser = tiledModule?.TiledParser;
+    if (!TiledParser) {
+      return;
+    }
+    const mapParser = new TiledParser(mapDoc.xml);
+    const parsedMap = mapParser.parseMap();
+    const tilesets = Array.isArray(parsedMap?.tilesets) ? parsedMap.tilesets : [];
+    const mergedTilesets = [];
+    for (const tileset of tilesets) {
+      if (!tileset?.source) {
+        mergedTilesets.push(tileset);
+        continue;
+      }
+      let tilesetUrl;
+      if (mapDoc.sourceUrl) {
+        try {
+          tilesetUrl = new URL(tileset.source, mapDoc.sourceUrl).toString();
+        } catch {
+          tilesetUrl = void 0;
+        }
+      } else if (options.host) {
+        const prefix = toBasePathPrefix(getTiledBasePaths(options.tiledBasePaths)[0] || "map");
+        const candidatePath = tileset.source.startsWith("/") ? tileset.source : `${prefix}/${tileset.source}`.replace(/\/{2,}/g, "/");
+        tilesetUrl = `http://${options.host}${candidatePath.startsWith("/") ? candidatePath : `/${candidatePath}`}`;
+      }
+      const tilesetRaw = tilesetUrl ? await fetchTextByUrl(tilesetUrl) : await readTextByFilePath(tileset.source);
+      if (!tilesetRaw) {
+        mergedTilesets.push(tileset);
+        continue;
+      }
+      try {
+        const tilesetParser = new TiledParser(tilesetRaw);
+        const parsedTileset = tilesetParser.parseTileset();
+        mergedTilesets.push({
+          ...tileset,
+          ...parsedTileset
+        });
+      } catch {
+        mergedTilesets.push(tileset);
+      }
+    }
+    parsedMap.tilesets = mergedTilesets;
+    payload.data = mapDoc.xml;
+    payload.parsedMap = parsedMap;
+    if (typeof parsedMap?.width === "number" && typeof parsedMap?.tilewidth === "number") {
+      payload.width = parsedMap.width * parsedMap.tilewidth;
+    }
+    if (typeof parsedMap?.height === "number" && typeof parsedMap?.tileheight === "number") {
+      payload.height = parsedMap.height * parsedMap.tileheight;
+    }
+  } catch {
+    return;
+  }
+}
+async function updateMap(roomId, rpgServer, options = {}) {
+  if (!roomId.startsWith("map-")) {
+    return;
+  }
+  try {
+    const mapId = normalizeRoomMapId(roomId);
+    const serverMaps = Array.isArray(rpgServer.maps) ? rpgServer.maps : [];
+    const defaultMapPayload = {
+      id: mapId,
+      width: 0,
+      height: 0,
+      events: [],
+      __maps: serverMaps
+    };
+    await enrichMapWithParsedTiledData(defaultMapPayload, options);
+    delete defaultMapPayload.__maps;
+    const headers = createMapUpdateHeaders(options.mapUpdateToken, options.headers);
+    await rpgServer.onRequest?.({
+      url: `http://localhost/parties/main/${roomId}/map/update`,
+      method: "POST",
+      headers,
+      json: async () => defaultMapPayload,
+      text: async () => JSON.stringify(defaultMapPayload)
+    });
+    console.log(`Initialized map for room ${roomId} via POST /map/update`);
+  } catch (error) {
+    console.warn(`Failed initializing map for room ${roomId}:`, error);
+  }
+}
+
+function provideServerModules(modules) {
+  return provideModules(modules, "server", (modules2, context) => {
+    const mainModuleServer = findModules(context, "Server");
+    modules2 = [...mainModuleServer, ...modules2];
+    modules2 = modules2.map((module) => {
+      if (typeof module === "function") {
+        const instance = new module();
+        const moduleObj = {};
+        for (const key in instance) {
+          moduleObj[key] = instance[key];
+        }
+        module = moduleObj;
+      }
+      if ("server" in module) {
+        module = module.server;
+      }
+      if (module.player?.props) {
+        module = {
+          ...module,
+          playerProps: {
+            load: (player) => {
+              player.setSync(module.player.props);
+            }
+          }
+        };
+      }
+      if (module.maps && Array.isArray(module.maps)) {
+        const maps = [...module.maps];
+        module = {
+          ...module,
+          maps: {
+            load: (engine) => {
+              maps.forEach((map) => {
+                let mapInstance;
+                if (typeof map === "function") {
+                  const MapClass = map;
+                  mapInstance = {
+                    id: MapClass.prototype?.id ?? MapClass.id,
+                    file: MapClass.prototype?.file ?? MapClass.file,
+                    type: MapClass.type,
+                    name: MapClass.prototype?.name,
+                    sounds: MapClass.prototype?.sounds,
+                    weather: MapClass.prototype?.weather,
+                    lowMemory: MapClass.prototype?.lowMemory,
+                    stopAllSoundsBeforeJoin: MapClass.prototype?.stopAllSoundsBeforeJoin,
+                    events: MapClass.prototype?._events,
+                    syncSchema: MapClass.prototype?.$schema,
+                    onLoad: MapClass.prototype?.onLoad,
+                    onJoin: MapClass.prototype?.onJoin,
+                    onLeave: MapClass.prototype?.onLeave
+                  };
+                } else {
+                  mapInstance = map;
+                }
+                engine.maps.push(mapInstance);
+              });
+            }
+          }
+        };
+      }
+      if (module.worldMaps && Array.isArray(module.worldMaps)) {
+        const worldMaps = [...module.worldMaps];
+        module = {
+          ...module,
+          worldMaps: {
+            load: (engine) => {
+              worldMaps.forEach((worldMap) => {
+                engine.createDynamicWorldMaps(worldMap);
+              });
+            }
+          }
+        };
+      }
+      if (module.database) {
+        const database = module.database;
+        module = {
+          ...module,
+          databaseHooks: {
+            load: async (engine) => {
+              const data = typeof database === "function" ? await database(engine) : database;
+              if (!data || typeof data !== "object") {
+                return;
+              }
+              for (const key in data) {
+                engine.addInDatabase(key, data[key]);
+              }
+            }
+          }
+        };
+      }
+      return module;
+    });
+    return modules2;
+  });
+}
+
+export { updateMap as $, MAP_UPDATE_TOKEN_ENV as A, BehaviorSubject as B, users as C, DELETE_TOKEN as D, setInject as E, injector as F, RpgModule as G, context$1 as H, Item as I, clearInject as J, provideServerModules as K, ArraySubject as L, ModulesToken as M, ObjectSubject as N, Observable as O, effect as P, isArraySubject as Q, RpgCommonPlayer as R, SafeSubscriber as S, isComputed as T, isObjectSubject as U, Vector2 as V, isSignal as W, linkedSignal as X, untracked as Y, resolveMapUpdateToken as Z, __spreadArray as _, Subject as a, createMapUpdateHeaders as a0, readMapUpdateToken as a1, __read as b, createErrorClass as c, createStatesSnapshotDeep as d, signal as e, id as f, generateShortUUID as g, sync as h, innerFrom as i, getByPath as j, createStatesSnapshot as k, load as l, Direction as m, inject as n, operate as o, persist as p, computed as q, Skill as r, syncClass as s, type as t, combineLatest as u, inject$1 as v, context as w, finalize as x, isMapUpdateAuthorized as y, MAP_UPDATE_TOKEN_HEADER as z };
+//# sourceMappingURL=module-CuaepWlN.js.map