@colyseus/schema 3.0.0-alpha.0 → 3.0.0-alpha.10

package/build/umd/index.js

@@ -4,8 +4,8 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.schema = {}));
 })(this, (function (exports) { 'use strict';
 
-    var SWITCH_TO_STRUCTURE = 255; // (decoding collides with DELETE_AND_ADD + fieldIndex = 63)
-    var TYPE_ID = 213;
+    const SWITCH_TO_STRUCTURE = 255; // (decoding collides with DELETE_AND_ADD + fieldIndex = 63)
+    const TYPE_ID = 213;
     /**
      * Encoding Schema field operations.
      */
@@ -31,95 +31,40 @@
         OPERATION[OPERATION["DELETE_BY_REFID"] = 33] = "DELETE_BY_REFID";
     })(exports.OPERATION || (exports.OPERATION = {}));
 
-    /******************************************************************************
-    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 */
-
-    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 __decorate(decorators, target, key, desc) {
-        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-        return c > 3 && r && Object.defineProperty(target, key, r), r;
-    }
-
-    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));
-    }
-
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-        var e = new Error(message);
-        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
-    var _a$1;
-    var _b;
-    (_a$1 = (_b = Symbol).metadata) !== null && _a$1 !== void 0 ? _a$1 : (_b.metadata = Symbol.for("Symbol.metadata"));
+    Symbol.metadata ??= Symbol.for("Symbol.metadata");
 
-    var $track = Symbol("$track");
-    var $encoder = Symbol("$encoder");
-    var $decoder = Symbol("$decoder");
-    var $filter = Symbol("$filter");
-    var $getByIndex = Symbol("$getByIndex");
-    var $deleteByIndex = Symbol("$deleteByIndex");
+    const $track = Symbol("$track");
+    const $encoder = Symbol("$encoder");
+    const $decoder = Symbol("$decoder");
+    const $filter = Symbol("$filter");
+    const $getByIndex = Symbol("$getByIndex");
+    const $deleteByIndex = Symbol("$deleteByIndex");
     /**
      * Used to hold ChangeTree instances whitin the structures
      */
-    var $changes = Symbol('$changes');
+    const $changes = Symbol('$changes');
     /**
      * Used to keep track of the type of the child elements of a collection
      * (MapSchema, ArraySchema, etc.)
      */
-    var $childType = Symbol('$childType');
+    const $childType = Symbol('$childType');
     /**
      * Special ChangeTree property to identify new instances
      * (Once they're encoded, they're not new anymore)
      */
-    var $isNew = Symbol("$isNew");
+    const $isNew = Symbol("$isNew");
     /**
      * Optional "discard" method for custom types (ArraySchema)
      * (Discards changes for next serialization)
      */
-    var $onEncodeEnd = Symbol('$onEncodeEnd');
+    const $onEncodeEnd = Symbol('$onEncodeEnd');
     /**
      * When decoding, this method is called after the instance is fully decoded
      */
-    var $onDecodeEnd = Symbol("$onDecodeEnd");
+    const $onDecodeEnd = Symbol("$onDecodeEnd");
 
-    var registeredTypes = {};
-    var identifiers = new Map();
+    const registeredTypes = {};
+    const identifiers = new Map();
     function registerType(identifier, definition) {
         identifiers.set(definition.constructor, identifier);
         registeredTypes[identifier] = definition;
@@ -128,18 +73,18 @@
         return registeredTypes[identifier];
     }
 
-    var Metadata = {
-        addField: function (metadata, index, field, type, descriptor) {
+    const Metadata = {
+        addField(metadata, index, field, type, descriptor) {
             if (index > 64) {
-                throw new Error("Can't define field '".concat(field, "'.\nSchema instances may only have up to 64 fields."));
+                throw new Error(`Can't define field '${field}'.\nSchema instances may only have up to 64 fields.`);
             }
             metadata[field] = Object.assign(metadata[field] || {}, // avoid overwriting previous field metadata (@owned / @deprecated)
             {
                 type: (Array.isArray(type))
                     ? { array: type[0] }
                     : type,
-                index: index,
-                descriptor: descriptor,
+                index,
+                descriptor,
             });
             // map -1 as last field index
             Object.defineProperty(metadata, -1, {
@@ -154,9 +99,9 @@
                 configurable: true,
             });
         },
-        setTag: function (metadata, fieldName, tag) {
+        setTag(metadata, fieldName, tag) {
             // add 'tag' to the field
-            var field = metadata[fieldName];
+            const field = metadata[fieldName];
             field.tag = tag;
             if (!metadata[-2]) {
                 // -2: all field indexes with "view" tag
@@ -178,47 +123,45 @@
             }
             metadata[-3][tag].push(field.index);
         },
-        setFields: function (target, fields) {
-            var _a;
-            var _b, _c;
-            var metadata = ((_a = (_b = target.prototype.constructor)[_c = Symbol.metadata]) !== null && _a !== void 0 ? _a : (_b[_c] = {}));
+        setFields(target, fields) {
+            const metadata = (target.prototype.constructor[Symbol.metadata] ??= {});
             // target[$track] = function (changeTree, index: number, operation: OPERATION = OPERATION.ADD) {
             //     changeTree.change(index, operation, encodeSchemaOperation);
             // };
             // target[$encoder] = encodeSchemaOperation;
             // target[$decoder] = decodeSchemaOperation;
             // if (!target.prototype.toJSON) { target.prototype.toJSON = Schema.prototype.toJSON; }
-            var index = 0;
-            for (var field in fields) {
-                var type = fields[field];
+            let index = 0;
+            for (const field in fields) {
+                const type = fields[field];
                 // FIXME: this code is duplicated from @type() annotation
-                var complexTypeKlass = (Array.isArray(type))
+                const complexTypeKlass = (Array.isArray(type))
                     ? getType("array")
                     : (typeof (Object.keys(type)[0]) === "string") && getType(Object.keys(type)[0]);
-                Metadata.addField(metadata, index, field, type, getPropertyDescriptor("_".concat(field), index, type, complexTypeKlass, metadata, field));
+                Metadata.addField(metadata, index, field, type, getPropertyDescriptor(`_${field}`, index, type, complexTypeKlass, metadata, field));
                 index++;
             }
         },
-        isDeprecated: function (metadata, field) {
+        isDeprecated(metadata, field) {
             return metadata[field].deprecated === true;
         },
-        isValidInstance: function (klass) {
+        isValidInstance(klass) {
             return (klass.constructor[Symbol.metadata] &&
                 Object.prototype.hasOwnProperty.call(klass.constructor[Symbol.metadata], -1));
         },
-        getFields: function (klass) {
-            var metadata = klass[Symbol.metadata];
-            var fields = {};
-            for (var i = 0; i <= metadata[-1]; i++) {
+        getFields(klass) {
+            const metadata = klass[Symbol.metadata];
+            const fields = {};
+            for (let i = 0; i <= metadata[-1]; i++) {
                 fields[metadata[i]] = metadata[metadata[i]].type;
             }
             return fields;
         }
     };
 
-    var _a;
-    var Root = /** @class */ (function () {
-        function Root() {
+    var _a$5;
+    class Root {
+        constructor() {
             this.nextUniqueId = 0;
             this.refCount = new WeakMap();
             // all changes
@@ -227,18 +170,16 @@
             // pending changes to be encoded
             this.changes = new Map();
             this.filteredChanges = new Map();
-            this.views = [];
         }
-        Root.prototype.getNextUniqueId = function () {
+        getNextUniqueId() {
             return this.nextUniqueId++;
-        };
-        Root.prototype.add = function (changeTree) {
-            var refCount = this.refCount.get(changeTree) || 0;
+        }
+        add(changeTree) {
+            const refCount = this.refCount.get(changeTree) || 0;
             this.refCount.set(changeTree, refCount + 1);
-        };
-        Root.prototype.remove = function (changeTree) {
-            var _this = this;
-            var refCount = this.refCount.get(changeTree);
+        }
+        remove(changeTree) {
+            const refCount = this.refCount.get(changeTree);
             if (refCount <= 1) {
                 this.allChanges.delete(changeTree);
                 this.changes.delete(changeTree);
@@ -251,27 +192,26 @@
             else {
                 this.refCount.set(changeTree, refCount - 1);
             }
-            changeTree.forEachChild(function (child, _) {
-                return _this.remove(child);
-            });
-        };
-        Root.prototype.clear = function () {
+            changeTree.forEachChild((child, _) => this.remove(child));
+        }
+        clear() {
             this.changes.clear();
-        };
-        return Root;
-    }());
-    var ChangeTree = /** @class */ (function () {
-        function ChangeTree(ref) {
+        }
+    }
+    class ChangeTree {
+        static { _a$5 = $isNew; }
+        ;
+        constructor(ref) {
             this.indexes = {}; // TODO: remove this, only used by MapSchema/SetSchema/CollectionSchema (`encodeKeyValueOperation`)
             this.currentOperationIndex = 0;
             this.allChanges = new Map();
             this.allFilteredChanges = new Map();
             this.changes = new Map();
             this.filteredChanges = new Map();
-            this[_a] = true;
+            this[_a$5] = true;
             this.ref = ref;
         }
-        ChangeTree.prototype.setRoot = function (root) {
+        setRoot(root) {
             this.root = root;
             this.root.add(this);
             //
@@ -295,7 +235,7 @@
             if (!this.isFiltered) {
                 this.root.allChanges.set(this, this.allChanges);
             }
-            this.forEachChild(function (changeTree, _) {
+            this.forEachChild((changeTree, _) => {
                 changeTree.setRoot(root);
             });
             // this.allChanges.forEach((_, index) => {
@@ -304,9 +244,8 @@
             //         childRef[$changes].setRoot(root);
             //     }
             // });
-        };
-        ChangeTree.prototype.setParent = function (parent, root, parentIndex) {
-            var _this = this;
+        }
+        setParent(parent, root, parentIndex) {
             this.parent = parent;
             this.parentIndex = parentIndex;
             // avoid setting parents with empty `root`
@@ -316,8 +255,8 @@
             root.add(this);
             // skip if parent is already set
             if (root === this.root) {
-                this.forEachChild(function (changeTree, atIndex) {
-                    changeTree.setParent(_this.ref, root, atIndex);
+                this.forEachChild((changeTree, atIndex) => {
+                    changeTree.setParent(this.ref, root, atIndex);
                 });
                 return;
             }
@@ -325,29 +264,26 @@
             this.checkIsFiltered(parent, parentIndex);
             if (!this.isFiltered) {
                 this.root.changes.set(this, this.changes);
+                this.root.allChanges.set(this, this.allChanges);
             }
             if (this.isFiltered || this.isPartiallyFiltered) {
                 this.root.filteredChanges.set(this, this.filteredChanges);
                 this.root.allFilteredChanges.set(this, this.filteredChanges);
             }
-            else {
-                this.root.allChanges.set(this, this.allChanges);
-            }
             this.ensureRefId();
-            this.forEachChild(function (changeTree, atIndex) {
-                changeTree.setParent(_this.ref, root, atIndex);
+            this.forEachChild((changeTree, atIndex) => {
+                changeTree.setParent(this.ref, root, atIndex);
             });
-        };
-        ChangeTree.prototype.forEachChild = function (callback) {
-            var _this = this;
+        }
+        forEachChild(callback) {
             //
             // assign same parent on child structures
             //
             if (Metadata.isValidInstance(this.ref)) {
-                var metadata = this.ref['constructor'][Symbol.metadata];
+                const metadata = this.ref['constructor'][Symbol.metadata];
                 // FIXME: need to iterate over parent metadata instead.
-                for (var field in metadata) {
-                    var value = this.ref[field];
+                for (const field in metadata) {
+                    const value = this.ref[field];
                     if (value && value[$changes]) {
                         callback(value[$changes], metadata[field].index);
                     }
@@ -355,29 +291,26 @@
             }
             else if (typeof (this.ref) === "object") {
                 // MapSchema / ArraySchema, etc.
-                this.ref.forEach(function (value, key) {
+                this.ref.forEach((value, key) => {
                     if (Metadata.isValidInstance(value)) {
-                        callback(value[$changes], _this.ref[$changes].indexes[key]);
+                        callback(value[$changes], this.ref[$changes].indexes[key]);
                     }
                 });
             }
-        };
-        ChangeTree.prototype.operation = function (op) {
-            var _b;
+        }
+        operation(op) {
             this.changes.set(--this.currentOperationIndex, op);
-            (_b = this.root) === null || _b === void 0 ? void 0 : _b.changes.set(this, this.changes);
-        };
-        ChangeTree.prototype.change = function (index, operation) {
-            var _b, _c;
-            if (operation === void 0) { operation = exports.OPERATION.ADD; }
-            var metadata = this.ref['constructor'][Symbol.metadata];
-            var isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
-            var changeSet = (isFiltered)
+            this.root?.changes.set(this, this.changes);
+        }
+        change(index, operation = exports.OPERATION.ADD) {
+            const metadata = this.ref['constructor'][Symbol.metadata];
+            const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
+            const changeSet = (isFiltered)
                 ? this.filteredChanges
                 : this.changes;
-            var previousOperation = changeSet.get(index);
+            const previousOperation = changeSet.get(index);
             if (!previousOperation || previousOperation === exports.OPERATION.DELETE) {
-                var op = (!previousOperation)
+                const op = (!previousOperation)
                     ? operation
                     : (previousOperation === exports.OPERATION.DELETE)
                         ? exports.OPERATION.DELETE_AND_ADD
@@ -389,32 +322,30 @@
             //
             if (isFiltered) {
                 this.allFilteredChanges.set(index, exports.OPERATION.ADD);
-                (_b = this.root) === null || _b === void 0 ? void 0 : _b.filteredChanges.set(this, this.filteredChanges);
+                this.root?.filteredChanges.set(this, this.filteredChanges);
             }
             else {
                 this.allChanges.set(index, exports.OPERATION.ADD);
-                (_c = this.root) === null || _c === void 0 ? void 0 : _c.changes.set(this, this.changes);
+                this.root?.changes.set(this, this.changes);
             }
-        };
-        ChangeTree.prototype.shiftChangeIndexes = function (shiftIndex) {
+        }
+        shiftChangeIndexes(shiftIndex) {
             //
             // Used only during:
             //
             // - ArraySchema#unshift()
             //
-            var changeSet = (this.isFiltered)
+            const changeSet = (this.isFiltered)
                 ? this.filteredChanges
                 : this.changes;
-            var changeSetEntries = Array.from(changeSet.entries());
+            const changeSetEntries = Array.from(changeSet.entries());
             changeSet.clear();
             // Re-insert each entry with the shifted index
-            for (var _i = 0, changeSetEntries_1 = changeSetEntries; _i < changeSetEntries_1.length; _i++) {
-                var _b = changeSetEntries_1[_i], index = _b[0], op = _b[1];
+            for (const [index, op] of changeSetEntries) {
                 changeSet.set(index + shiftIndex, op);
             }
-        };
-        ChangeTree.prototype.shiftAllChangeIndexes = function (shiftIndex, startIndex) {
-            if (startIndex === void 0) { startIndex = 0; }
+        }
+        shiftAllChangeIndexes(shiftIndex, startIndex = 0) {
             //
             // Used only during:
             //
@@ -427,37 +358,32 @@
             else {
                 this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
             }
-        };
-        ChangeTree.prototype._shiftAllChangeIndexes = function (shiftIndex, startIndex, allChangeSet) {
-            if (startIndex === void 0) { startIndex = 0; }
-            Array.from(allChangeSet.entries()).forEach(function (_b) {
-                var index = _b[0], op = _b[1];
-                // console.log('shiftAllChangeIndexes', index >= startIndex, { index, op, shiftIndex, startIndex })
+        }
+        _shiftAllChangeIndexes(shiftIndex, startIndex = 0, allChangeSet) {
+            Array.from(allChangeSet.entries()).forEach(([index, op]) => {
                 if (index >= startIndex) {
                     allChangeSet.delete(index);
                     allChangeSet.set(index + shiftIndex, op);
                 }
             });
-        };
-        ChangeTree.prototype.indexedOperation = function (index, operation, allChangesIndex) {
-            var _b, _c;
-            if (allChangesIndex === void 0) { allChangesIndex = index; }
-            var metadata = this.ref['constructor'][Symbol.metadata];
-            var isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
+        }
+        indexedOperation(index, operation, allChangesIndex = index) {
+            const metadata = this.ref['constructor'][Symbol.metadata];
+            const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
             if (isFiltered) {
                 this.allFilteredChanges.set(allChangesIndex, exports.OPERATION.ADD);
                 this.filteredChanges.set(index, operation);
-                (_b = this.root) === null || _b === void 0 ? void 0 : _b.filteredChanges.set(this, this.filteredChanges);
+                this.root?.filteredChanges.set(this, this.filteredChanges);
             }
             else {
                 this.allChanges.set(allChangesIndex, exports.OPERATION.ADD);
                 this.changes.set(index, operation);
-                (_c = this.root) === null || _c === void 0 ? void 0 : _c.changes.set(this, this.changes);
+                this.root?.changes.set(this, this.changes);
             }
-        };
-        ChangeTree.prototype.getType = function (index) {
+        }
+        getType(index) {
             if (Metadata.isValidInstance(this.ref)) {
-                var metadata = this.ref['constructor'][Symbol.metadata];
+                const metadata = this.ref['constructor'][Symbol.metadata];
                 return metadata[metadata[index]].type;
             }
             else {
@@ -469,41 +395,37 @@
                 //
                 return this.ref[$childType];
             }
-        };
-        ChangeTree.prototype.getChange = function (index) {
-            var _b;
+        }
+        getChange(index) {
             // TODO: optimize this. avoid checking against multiple instances
-            return (_b = this.changes.get(index)) !== null && _b !== void 0 ? _b : this.filteredChanges.get(index);
-        };
+            return this.changes.get(index) ?? this.filteredChanges.get(index);
+        }
         //
         // used during `.encode()`
         //
-        ChangeTree.prototype.getValue = function (index, isEncodeAll) {
-            if (isEncodeAll === void 0) { isEncodeAll = false; }
+        getValue(index, isEncodeAll = false) {
             //
             // `isEncodeAll` param is only used by ArraySchema
             //
             return this.ref[$getByIndex](index, isEncodeAll);
-        };
-        ChangeTree.prototype.delete = function (index, operation, allChangesIndex) {
-            var _b, _c, _d;
-            if (allChangesIndex === void 0) { allChangesIndex = index; }
+        }
+        delete(index, operation, allChangesIndex = index) {
             if (index === undefined) {
                 try {
-                    throw new Error("@colyseus/schema ".concat(this.ref.constructor.name, ": trying to delete non-existing index '").concat(index, "'"));
+                    throw new Error(`@colyseus/schema ${this.ref.constructor.name}: trying to delete non-existing index '${index}'`);
                 }
                 catch (e) {
                     console.warn(e);
                 }
                 return;
             }
-            var metadata = this.ref['constructor'][Symbol.metadata];
-            var isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
-            var changeSet = (isFiltered)
+            const metadata = this.ref['constructor'][Symbol.metadata];
+            const isFiltered = this.isFiltered || (metadata && metadata[metadata[index]].tag !== undefined);
+            const changeSet = (isFiltered)
                 ? this.filteredChanges
                 : this.changes;
-            var previousValue = this.getValue(index);
-            changeSet.set(index, operation !== null && operation !== void 0 ? operation : exports.OPERATION.DELETE);
+            const previousValue = this.getValue(index);
+            changeSet.set(index, operation ?? exports.OPERATION.DELETE);
             // remove `root` reference
             if (previousValue && previousValue[$changes]) {
                 previousValue[$changes].root = undefined;
@@ -517,37 +439,33 @@
                 //
                 // (the property descriptors should NOT be used at decoding time. only at encoding time.)
                 //
-                (_b = this.root) === null || _b === void 0 ? void 0 : _b.remove(previousValue[$changes]);
+                this.root?.remove(previousValue[$changes]);
             }
             //
             // FIXME: this is looking a bit ugly (and repeated from `.change()`)
             //
             if (isFiltered) {
-                (_c = this.root) === null || _c === void 0 ? void 0 : _c.filteredChanges.set(this, this.filteredChanges);
+                this.root?.filteredChanges.set(this, this.filteredChanges);
                 this.allFilteredChanges.delete(allChangesIndex);
             }
             else {
-                (_d = this.root) === null || _d === void 0 ? void 0 : _d.changes.set(this, this.changes);
+                this.root?.changes.set(this, this.changes);
                 this.allChanges.delete(allChangesIndex);
             }
-        };
-        ChangeTree.prototype.endEncode = function () {
-            var _b, _c;
+        }
+        endEncode() {
             this.changes.clear();
-            (_c = (_b = this.ref)[$onEncodeEnd]) === null || _c === void 0 ? void 0 : _c.call(_b);
+            this.ref[$onEncodeEnd]?.();
             // Not a new instance anymore
             delete this[$isNew];
-        };
-        ChangeTree.prototype.discard = function (discardAll) {
-            var _this = this;
-            var _b, _c;
-            if (discardAll === void 0) { discardAll = false; }
+        }
+        discard(discardAll = false) {
             //
             // > MapSchema:
             //      Remove cached key to ensure ADD operations is unsed instead of
             //      REPLACE in case same key is used on next patches.
             //
-            (_c = (_b = this.ref)[$onEncodeEnd]) === null || _c === void 0 ? void 0 : _c.call(_b);
+            this.ref[$onEncodeEnd]?.();
             this.changes.clear();
             this.filteredChanges.clear();
             // reset operation index
@@ -556,46 +474,40 @@
                 this.allChanges.clear();
                 this.allFilteredChanges.clear();
                 // remove children references
-                this.forEachChild(function (changeTree, _) { var _b; return (_b = _this.root) === null || _b === void 0 ? void 0 : _b.remove(changeTree); });
+                this.forEachChild((changeTree, _) => this.root?.remove(changeTree));
             }
-        };
+        }
         /**
          * Recursively discard all changes from this, and child structures.
          */
-        ChangeTree.prototype.discardAll = function () {
-            var _this = this;
-            this.changes.forEach(function (_, fieldIndex) {
-                var value = _this.getValue(fieldIndex);
+        discardAll() {
+            this.changes.forEach((_, fieldIndex) => {
+                const value = this.getValue(fieldIndex);
                 if (value && value[$changes]) {
                     value[$changes].discardAll();
                 }
             });
             this.discard();
-        };
-        ChangeTree.prototype.ensureRefId = function () {
+        }
+        ensureRefId() {
             // skip if refId is already set.
             if (this.refId !== undefined) {
                 return;
             }
             this.refId = this.root.getNextUniqueId();
-        };
-        Object.defineProperty(ChangeTree.prototype, "changed", {
-            get: function () {
-                return this.changes.size > 0;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        ChangeTree.prototype.checkIsFiltered = function (parent, parentIndex) {
-            var _b, _c, _d;
+        }
+        get changed() {
+            return this.changes.size > 0;
+        }
+        checkIsFiltered(parent, parentIndex) {
             // Detect if current structure has "filters" declared
-            this.isPartiallyFiltered = (_c = (_b = this.ref['constructor']) === null || _b === void 0 ? void 0 : _b[Symbol.metadata]) === null || _c === void 0 ? void 0 : _c[-2];
+            this.isPartiallyFiltered = (this.ref['constructor']?.[Symbol.metadata]?.[-2] !== undefined);
             // TODO: support "partially filtered", where the instance is visible, but only a field is not.
             // Detect if parent has "filters" declared
             while (parent && !this.isFiltered) {
-                var metadata = parent['constructor'][Symbol.metadata];
-                var fieldName = metadata === null || metadata === void 0 ? void 0 : metadata[parentIndex];
-                var isParentOwned = ((_d = metadata === null || metadata === void 0 ? void 0 : metadata[fieldName]) === null || _d === void 0 ? void 0 : _d.tag) !== undefined;
+                const metadata = parent['constructor'][Symbol.metadata];
+                const fieldName = metadata?.[parentIndex];
+                const isParentOwned = metadata?.[fieldName]?.tag !== undefined;
                 this.isFiltered = isParentOwned || parent[$changes].isFiltered; // metadata?.[-2]
                 parent = parent[$changes].parent;
             }
@@ -607,18 +519,16 @@
             //
             if (this.isFiltered && this.changes.size > 0) {
                 // swap changes reference
-                var changes = this.changes;
+                const changes = this.changes;
                 this.changes = this.filteredChanges;
                 this.filteredChanges = changes;
                 // swap "all changes" reference
-                var allFilteredChanges = this.allFilteredChanges;
+                const allFilteredChanges = this.allFilteredChanges;
                 this.allFilteredChanges = this.allChanges;
                 this.allChanges = allFilteredChanges;
             }
-        };
-        return ChangeTree;
-    }());
-    _a = $isNew;
+        }
+    }
 
     /**
      * Copyright (c) 2018 Endel Dreyer
@@ -646,12 +556,35 @@
      * msgpack implementation highly based on notepack.io
      * https://github.com/darrachequesne/notepack
      */
-    var textEncoder;
+    let textEncoder;
     // @ts-ignore
     try {
         textEncoder = new TextEncoder();
     }
     catch (e) { }
+    const hasBufferByteLength = (typeof Buffer !== 'undefined' && Buffer.byteLength);
+    const utf8Length = (hasBufferByteLength)
+        ? Buffer.byteLength // node
+        : function (str, _) {
+            var c = 0, length = 0;
+            for (var i = 0, l = str.length; i < l; i++) {
+                c = str.charCodeAt(i);
+                if (c < 0x80) {
+                    length += 1;
+                }
+                else if (c < 0x800) {
+                    length += 2;
+                }
+                else if (c < 0xd800 || c >= 0xe000) {
+                    length += 3;
+                }
+                else {
+                    i++;
+                    length += 4;
+                }
+            }
+            return length;
+        };
     function utf8Write(view, str, it) {
         var c = 0;
         for (var i = 0, l = str.length; i < l; i++) {
@@ -699,24 +632,24 @@
         bytes[it.offset++] = (value >> 24) & 255;
     }
     function uint32$1(bytes, value, it) {
-        var b4 = value >> 24;
-        var b3 = value >> 16;
-        var b2 = value >> 8;
-        var b1 = value;
+        const b4 = value >> 24;
+        const b3 = value >> 16;
+        const b2 = value >> 8;
+        const b1 = value;
         bytes[it.offset++] = b1 & 255;
         bytes[it.offset++] = b2 & 255;
         bytes[it.offset++] = b3 & 255;
         bytes[it.offset++] = b4 & 255;
     }
     function int64$1(bytes, value, it) {
-        var high = Math.floor(value / Math.pow(2, 32));
-        var low = value >>> 0;
+        const high = Math.floor(value / Math.pow(2, 32));
+        const low = value >>> 0;
         uint32$1(bytes, low, it);
         uint32$1(bytes, high, it);
     }
     function uint64$1(bytes, value, it) {
-        var high = (value / Math.pow(2, 32)) >> 0;
-        var low = value >>> 0;
+        const high = (value / Math.pow(2, 32)) >> 0;
+        const low = value >>> 0;
         uint32$1(bytes, low, it);
         uint32$1(bytes, high, it);
     }
@@ -726,9 +659,9 @@
     function float64$1(bytes, value, it) {
         writeFloat64(bytes, value, it);
     }
-    var _int32$1 = new Int32Array(2);
-    var _float32$1 = new Float32Array(_int32$1.buffer);
-    var _float64$1 = new Float64Array(_int32$1.buffer);
+    const _int32$1 = new Int32Array(2);
+    const _float32$1 = new Float32Array(_int32$1.buffer);
+    const _float64$1 = new Float64Array(_int32$1.buffer);
     function writeFloat32(bytes, value, it) {
         _float32$1[0] = value;
         int32$1(bytes, _int32$1[0], it);
@@ -746,9 +679,8 @@
         if (!value) {
             value = "";
         }
-        // let length = utf8Length(value);
-        var length = Buffer.byteLength(value, "utf8");
-        var size = 0;
+        let length = utf8Length(value, "utf8");
+        let size = 0;
         // fixstr
         if (length < 0x20) {
             bytes[it.offset++] = length | 0xa0;
@@ -858,6 +790,7 @@
 
     var encode = /*#__PURE__*/Object.freeze({
         __proto__: null,
+        utf8Length: utf8Length,
         utf8Write: utf8Write,
         int8: int8$1,
         uint8: uint8$1,
@@ -876,16 +809,11 @@
         number: number$1
     });
 
-    var EncodeSchemaError = /** @class */ (function (_super) {
-        __extends(EncodeSchemaError, _super);
-        function EncodeSchemaError() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        return EncodeSchemaError;
-    }(Error));
+    class EncodeSchemaError extends Error {
+    }
     function assertType(value, type, klass, field) {
-        var typeofTarget;
-        var allowNull = false;
+        let typeofTarget;
+        let allowNull = false;
         switch (type) {
             case "number":
             case "int8":
@@ -900,7 +828,7 @@
             case "float64":
                 typeofTarget = "number";
                 if (isNaN(value)) {
-                    console.log("trying to encode \"NaN\" in ".concat(klass.constructor.name, "#").concat(field));
+                    console.log(`trying to encode "NaN" in ${klass.constructor.name}#${field}`);
                 }
                 break;
             case "string":
@@ -912,25 +840,25 @@
                 return;
         }
         if (typeof (value) !== typeofTarget && (!allowNull || (allowNull && value !== null))) {
-            var foundValue = "'".concat(JSON.stringify(value), "'").concat((value && value.constructor && " (".concat(value.constructor.name, ")")) || '');
-            throw new EncodeSchemaError("a '".concat(typeofTarget, "' was expected, but ").concat(foundValue, " was provided in ").concat(klass.constructor.name, "#").concat(field));
+            let foundValue = `'${JSON.stringify(value)}'${(value && value.constructor && ` (${value.constructor.name})`) || ''}`;
+            throw new EncodeSchemaError(`a '${typeofTarget}' was expected, but ${foundValue} was provided in ${klass.constructor.name}#${field}`);
         }
     }
     function assertInstanceType(value, type, klass, field) {
         if (!(value instanceof type)) {
-            throw new EncodeSchemaError("a '".concat(type.name, "' was expected, but '").concat(value && value.constructor.name, "' was provided in ").concat(klass.constructor.name, "#").concat(field));
+            throw new EncodeSchemaError(`a '${type.name}' was expected, but '${value && value.constructor.name}' was provided in ${klass.constructor.name}#${field}`);
         }
     }
 
     function encodePrimitiveType(type, bytes, value, klass, field, it) {
         assertType(value, type, klass, field);
-        var encodeFunc = encode[type];
+        const encodeFunc = encode[type];
         if (encodeFunc) {
             encodeFunc(bytes, value, it);
             // encodeFunc(bytes, value);
         }
         else {
-            throw new EncodeSchemaError("a '".concat(type, "' was expected, but ").concat(value, " was provided in ").concat(klass.constructor.name, "#").concat(field));
+            throw new EncodeSchemaError(`a '${type}' was expected, but ${value} was provided in ${klass.constructor.name}#${field}`);
         }
     }
     function encodeValue(encoder, bytes, ref, type, value, field, operation, it) {
@@ -957,7 +885,7 @@
             //
             // Custom type (MapSchema, ArraySchema, etc)
             //
-            var definition = getType(Object.keys(type)[0]);
+            const definition = getType(Object.keys(type)[0]);
             //
             // ensure a ArraySchema has been provided
             //
@@ -973,12 +901,12 @@
      * Used for Schema instances.
      * @private
      */
-    var encodeSchemaOperation = function (encoder, bytes, changeTree, index, operation, it) {
-        var ref = changeTree.ref;
-        var metadata = ref['constructor'][Symbol.metadata];
-        var field = metadata[index];
-        var type = metadata[field].type;
-        var value = ref[field];
+    const encodeSchemaOperation = function (encoder, bytes, changeTree, index, operation, it) {
+        const ref = changeTree.ref;
+        const metadata = ref['constructor'][Symbol.metadata];
+        const field = metadata[index];
+        const type = metadata[field].type;
+        const value = ref[field];
         // "compress" field index + operation
         bytes[it.offset++] = (index | operation) & 255;
         // Do not encode value for DELETE operations
@@ -992,8 +920,8 @@
      * Used for collections (MapSchema, CollectionSchema, SetSchema)
      * @private
      */
-    var encodeKeyValueOperation = function (encoder, bytes, changeTree, field, operation, it) {
-        var ref = changeTree.ref;
+    const encodeKeyValueOperation = function (encoder, bytes, changeTree, field, operation, it) {
+        const ref = changeTree.ref;
         // encode operation
         bytes[it.offset++] = operation & 255;
         // custom operations
@@ -1014,12 +942,12 @@
                 //
                 // MapSchema dynamic key
                 //
-                var dynamicIndex = changeTree.ref['$indexes'].get(field);
+                const dynamicIndex = changeTree.ref['$indexes'].get(field);
                 string$1(bytes, dynamicIndex, it);
             }
         }
-        var type = changeTree.getType(field);
-        var value = changeTree.getValue(field);
+        const type = changeTree.getType(field);
+        const value = changeTree.getValue(field);
         // TODO: inline this function call small performance gain
         encodeValue(encoder, bytes, ref, type, value, field, operation, it);
     };
@@ -1027,15 +955,15 @@
      * Used for collections (MapSchema, ArraySchema, etc.)
      * @private
      */
-    var encodeArray = function (encoder, bytes, changeTree, field, operation, it, isEncodeAll, hasView) {
-        var ref = changeTree.ref;
+    const encodeArray = function (encoder, bytes, changeTree, field, operation, it, isEncodeAll, hasView) {
+        const ref = changeTree.ref;
         if (hasView &&
             operation === exports.OPERATION.DELETE &&
             typeof (changeTree.getType(field)) !== "string") {
             // encode delete by refId (array of schemas)
             bytes[it.offset++] = exports.OPERATION.DELETE_BY_REFID;
-            var value_1 = ref['tmpItems'][field];
-            var refId = value_1[$changes].refId;
+            const value = ref['tmpItems'][field];
+            const refId = value[$changes].refId;
             number$1(bytes, refId, it);
             return;
         }
@@ -1051,8 +979,8 @@
         if (operation === exports.OPERATION.DELETE) {
             return;
         }
-        var type = changeTree.getType(field);
-        var value = changeTree.getValue(field, isEncodeAll);
+        const type = changeTree.getType(field);
+        const value = changeTree.getValue(field, isEncodeAll);
         // console.log("encodeArray -> ", {
         //     ref: changeTree.ref.constructor.name,
         //     field,
@@ -1086,9 +1014,9 @@
      * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
      * SOFTWARE
      */
-    function utf8Read(bytes, offset, length) {
+    function utf8Read(bytes, it, length) {
         var string = '', chr = 0;
-        for (var i = offset, end = offset + length; i < end; i++) {
+        for (var i = it.offset, end = it.offset + length; i < end; i++) {
             var byte = bytes[i];
             if ((byte & 0x80) === 0x00) {
                 string += String.fromCharCode(byte);
@@ -1123,6 +1051,7 @@
             // (do not throw error to avoid server/client from crashing due to hack attemps)
             // throw new Error('Invalid byte ' + byte.toString(16));
         }
+        it.offset += length;
         return string;
     }
     function int8(bytes, it) {
@@ -1150,18 +1079,18 @@
         return readFloat64(bytes, it);
     }
     function int64(bytes, it) {
-        var low = uint32(bytes, it);
-        var high = int32(bytes, it) * Math.pow(2, 32);
+        const low = uint32(bytes, it);
+        const high = int32(bytes, it) * Math.pow(2, 32);
         return high + low;
     }
     function uint64(bytes, it) {
-        var low = uint32(bytes, it);
-        var high = uint32(bytes, it) * Math.pow(2, 32);
+        const low = uint32(bytes, it);
+        const high = uint32(bytes, it) * Math.pow(2, 32);
         return high + low;
     }
-    var _int32 = new Int32Array(2);
-    var _float32 = new Float32Array(_int32.buffer);
-    var _float64 = new Float64Array(_int32.buffer);
+    const _int32 = new Int32Array(2);
+    const _float32 = new Float32Array(_int32.buffer);
+    const _float64 = new Float64Array(_int32.buffer);
     function readFloat32(bytes, it) {
         _int32[0] = int32(bytes, it);
         return _float32[0];
@@ -1175,8 +1104,8 @@
         return uint8(bytes, it) > 0;
     }
     function string(bytes, it) {
-        var prefix = bytes[it.offset++];
-        var length;
+        const prefix = bytes[it.offset++];
+        let length;
         if (prefix < 0xc0) {
             // fixstr
             length = prefix & 0x1f;
@@ -1190,12 +1119,10 @@
         else if (prefix === 0xdb) {
             length = uint32(bytes, it);
         }
-        var value = utf8Read(bytes, it.offset, length);
-        it.offset += length;
-        return value;
+        return utf8Read(bytes, it, length);
     }
     function stringCheck(bytes, it) {
-        var prefix = bytes[it.offset];
+        const prefix = bytes[it.offset];
         return (
         // fixstr
         (prefix < 0xc0 && prefix > 0xa0) ||
@@ -1207,7 +1134,7 @@
             prefix === 0xdb);
     }
     function number(bytes, it) {
-        var prefix = bytes[it.offset++];
+        const prefix = bytes[it.offset++];
         if (prefix < 0x80) {
             // positive fixint
             return prefix;
@@ -1258,7 +1185,7 @@
         }
     }
     function numberCheck(bytes, it) {
-        var prefix = bytes[it.offset];
+        const prefix = bytes[it.offset];
         // positive fixint - 0x00 - 0x7f
         // float 32        - 0xca
         // float 64        - 0xcb
@@ -1296,6 +1223,7 @@
 
     var decode = /*#__PURE__*/Object.freeze({
         __proto__: null,
+        utf8Read: utf8Read,
         int8: int8,
         uint8: uint8,
         int16: int16,
@@ -1317,14 +1245,14 @@
         switchStructureCheck: switchStructureCheck
     });
 
-    var DEFINITION_MISMATCH = -1;
+    const DEFINITION_MISMATCH = -1;
     function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges) {
-        var $root = decoder.$root;
-        var previousValue = ref[$getByIndex](index);
-        var value;
+        const $root = decoder.root;
+        const previousValue = ref[$getByIndex](index);
+        let value;
         if ((operation & exports.OPERATION.DELETE) === exports.OPERATION.DELETE) {
             // Flag `refId` for garbage collection.
-            var previousRefId = $root.refIds.get(previousValue);
+            const previousRefId = $root.refIds.get(previousValue);
             if (previousRefId !== undefined) {
                 $root.removeRef(previousRefId);
             }
@@ -1351,10 +1279,10 @@
         }
         if (operation === exports.OPERATION.DELETE) ;
         else if (Schema.is(type)) {
-            var refId = number(bytes, it);
+            const refId = number(bytes, it);
             value = $root.refs.get(refId);
             if (previousValue) {
-                var previousRefId = $root.refIds.get(previousValue);
+                const previousRefId = $root.refIds.get(previousValue);
                 if (previousRefId &&
                     refId !== previousRefId &&
                     // FIXME: we may need to check for REPLACE operation as well
@@ -1363,7 +1291,7 @@
                 }
             }
             if ((operation & exports.OPERATION.ADD) === exports.OPERATION.ADD) {
-                var childType = decoder.getInstanceType(bytes, it, type);
+                const childType = decoder.getInstanceType(bytes, it, type);
                 if (!value) {
                     value = decoder.createInstanceOfType(childType);
                 }
@@ -1377,28 +1305,28 @@
             value = decode[type](bytes, it);
         }
         else {
-            var typeDef = getType(Object.keys(type)[0]);
-            var refId = number(bytes, it);
-            var valueRef = ($root.refs.has(refId))
+            const typeDef = getType(Object.keys(type)[0]);
+            const refId = number(bytes, it);
+            const valueRef = ($root.refs.has(refId))
                 ? previousValue || $root.refs.get(refId)
                 : new typeDef.constructor();
             value = valueRef.clone(true);
             value[$childType] = Object.values(type)[0]; // cache childType for ArraySchema and MapSchema
             if (previousValue) {
-                var previousRefId = $root.refIds.get(previousValue);
+                let previousRefId = $root.refIds.get(previousValue);
                 if (previousRefId !== undefined && refId !== previousRefId) {
                     $root.removeRef(previousRefId);
                     //
                     // enqueue onRemove if structure has been replaced.
                     //
-                    var entries = previousValue.entries();
-                    var iter = void 0;
+                    const entries = previousValue.entries();
+                    let iter;
                     while ((iter = entries.next()) && !iter.done) {
-                        var _a = iter.value, key = _a[0], value_1 = _a[1];
+                        const [key, value] = iter.value;
                         // if value is a schema, remove its reference
                         // FIXME: not sure if this is necessary, add more tests to confirm
-                        if (typeof (value_1) === "object") {
-                            previousRefId = $root.refIds.get(value_1);
+                        if (typeof (value) === "object") {
+                            previousRefId = $root.refIds.get(value);
                             $root.removeRef(previousRefId);
                         }
                         allChanges.push({
@@ -1407,45 +1335,45 @@
                             op: exports.OPERATION.DELETE,
                             field: key,
                             value: undefined,
-                            previousValue: value_1,
+                            previousValue: value,
                         });
                     }
                 }
             }
             $root.addRef(refId, value, (valueRef !== previousValue));
         }
-        return { value: value, previousValue: previousValue };
+        return { value, previousValue };
     }
-    var decodeSchemaOperation = function (decoder, bytes, it, ref, allChanges) {
-        var first_byte = bytes[it.offset++];
-        var metadata = ref['constructor'][Symbol.metadata];
+    const decodeSchemaOperation = function (decoder, bytes, it, ref, allChanges) {
+        const first_byte = bytes[it.offset++];
+        const metadata = ref['constructor'][Symbol.metadata];
         // "compressed" index + operation
-        var operation = (first_byte >> 6) << 6;
-        var index = first_byte % (operation || 255);
+        const operation = (first_byte >> 6) << 6;
+        const index = first_byte % (operation || 255);
         // skip early if field is not defined
-        var field = metadata[index];
+        const field = metadata[index];
         if (field === undefined) {
             return DEFINITION_MISMATCH;
         }
-        var _a = decodeValue(decoder, operation, ref, index, metadata[field].type, bytes, it, allChanges), value = _a.value, previousValue = _a.previousValue;
+        const { value, previousValue } = decodeValue(decoder, operation, ref, index, metadata[field].type, bytes, it, allChanges);
         if (value !== null && value !== undefined) {
             ref[field] = value;
         }
         // add change
         if (previousValue !== value) {
             allChanges.push({
-                ref: ref,
+                ref,
                 refId: decoder.currentRefId,
                 op: operation,
                 field: field,
-                value: value,
-                previousValue: previousValue,
+                value,
+                previousValue,
             });
         }
     };
-    var decodeKeyValueOperation = function (decoder, bytes, it, ref, allChanges) {
+    const decodeKeyValueOperation = function (decoder, bytes, it, ref, allChanges) {
         // "uncompressed" index + operation (array/map items)
-        var operation = bytes[it.offset++];
+        const operation = bytes[it.offset++];
         if (operation === exports.OPERATION.CLEAR) {
             //
             // When decoding:
@@ -1456,9 +1384,9 @@
             ref.clear();
             return;
         }
-        var index = number(bytes, it);
-        var type = ref[$childType];
-        var dynamicIndex;
+        const index = number(bytes, it);
+        const type = ref[$childType];
+        let dynamicIndex;
         if ((operation & exports.OPERATION.ADD) === exports.OPERATION.ADD) { // ADD or DELETE_AND_ADD
             if (typeof (ref['set']) === "function") {
                 dynamicIndex = string(bytes, it); // MapSchema
@@ -1472,7 +1400,7 @@
             // get dynamic index from "ref"
             dynamicIndex = ref['getIndex'](index);
         }
-        var _a = decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges), value = _a.value, previousValue = _a.previousValue;
+        const { value, previousValue } = decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges);
         if (value !== null && value !== undefined) {
             if (typeof (ref['set']) === "function") {
                 // MapSchema
@@ -1484,28 +1412,28 @@
             }
             else if (typeof (ref['add']) === "function") {
                 // CollectionSchema && SetSchema
-                var index_1 = ref.add(value);
-                if (typeof (index_1) === "number") {
-                    ref['setIndex'](index_1, index_1);
+                const index = ref.add(value);
+                if (typeof (index) === "number") {
+                    ref['setIndex'](index, index);
                 }
             }
         }
         // add change
         if (previousValue !== value) {
             allChanges.push({
-                ref: ref,
+                ref,
                 refId: decoder.currentRefId,
                 op: operation,
                 field: "", // FIXME: remove this
-                dynamicIndex: dynamicIndex,
-                value: value,
-                previousValue: previousValue,
+                dynamicIndex,
+                value,
+                previousValue,
             });
         }
     };
-    var decodeArray = function (decoder, bytes, it, ref, allChanges) {
+    const decodeArray = function (decoder, bytes, it, ref, allChanges) {
         // "uncompressed" index + operation (array/map items)
-        var operation = bytes[it.offset++];
+        const operation = bytes[it.offset++];
         if (operation === exports.OPERATION.CLEAR) {
             //
             // When decoding:
@@ -1518,25 +1446,25 @@
         }
         else if (operation === exports.OPERATION.DELETE_BY_REFID) {
             // TODO: refactor here, try to follow same flow as below
-            var refId = number(bytes, it);
-            var previousValue_1 = decoder.$root.refs.get(refId);
-            var index_2 = ref.findIndex(function (value) { return value === previousValue_1; });
-            ref[$deleteByIndex](index_2);
+            const refId = number(bytes, it);
+            const previousValue = decoder.root.refs.get(refId);
+            const index = ref.findIndex((value) => value === previousValue);
+            ref[$deleteByIndex](index);
             allChanges.push({
-                ref: ref,
+                ref,
                 refId: decoder.currentRefId,
                 op: exports.OPERATION.DELETE,
                 field: "", // FIXME: remove this
-                dynamicIndex: index_2,
+                dynamicIndex: index,
                 value: undefined,
-                previousValue: previousValue_1,
+                previousValue,
             });
             return;
         }
-        var index = number(bytes, it);
-        var type = ref[$childType];
-        var dynamicIndex = index;
-        var _a = decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges), value = _a.value, previousValue = _a.previousValue;
+        const index = number(bytes, it);
+        const type = ref[$childType];
+        let dynamicIndex = index;
+        const { value, previousValue } = decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges);
         if (value !== null && value !== undefined &&
             value !== previousValue // avoid setting same value twice (if index === 0 it will result in a "unshift" for ArraySchema)
         ) {
@@ -1546,20 +1474,21 @@
         // add change
         if (previousValue !== value) {
             allChanges.push({
-                ref: ref,
+                ref,
                 refId: decoder.currentRefId,
                 op: operation,
                 field: "", // FIXME: remove this
-                dynamicIndex: dynamicIndex,
-                value: value,
-                previousValue: previousValue,
+                dynamicIndex,
+                value,
+                previousValue,
             });
         }
     };
 
-    var DEFAULT_SORT = function (a, b) {
-        var A = a.toString();
-        var B = b.toString();
+    var _a$4, _b$4;
+    const DEFAULT_SORT = (a, b) => {
+        const A = a.toString();
+        const B = b.toString();
         if (A < B)
             return -1;
         else if (A > B)
@@ -1567,13 +1496,33 @@
         else
             return 0;
     };
-    var ArraySchema = /** @class */ (function () {
-        function ArraySchema() {
-            var items = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                items[_i] = arguments[_i];
-            }
-            var _this = this;
+    class ArraySchema {
+        static { this[_a$4] = encodeArray; }
+        static { this[_b$4] = decodeArray; }
+        /**
+         * Determine if a property must be filtered.
+         * - If returns false, the property is NOT going to be encoded.
+         * - If returns true, the property is going to be encoded.
+         *
+         * Encoding with "filters" happens in two steps:
+         * - First, the encoder iterates over all "not owned" properties and encodes them.
+         * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
+         */
+        static [(_a$4 = $encoder, _b$4 = $decoder, $filter)](ref, index, view) {
+            // console.log("ArraSchema[$filter] VIEW??", !view)
+            return (!view ||
+                typeof (ref[$childType]) === "string" ||
+                // view.items.has(ref[$getByIndex](index)[$changes])
+                view.items.has(ref['tmpItems'][index]?.[$changes]));
+        }
+        static is(type) {
+            return (
+            // type format: ["string"]
+            Array.isArray(type) ||
+                // type format: { array: "string" }
+                (type['array'] !== undefined));
+        }
+        constructor(...items) {
             this.items = [];
             this.tmpItems = [];
             this.deletedIndexes = {};
@@ -1583,18 +1532,18 @@
                 writable: true,
                 configurable: true,
             });
-            var proxy = new Proxy(this, {
-                get: function (obj, prop) {
+            const proxy = new Proxy(this, {
+                get: (obj, prop) => {
                     if (typeof (prop) !== "symbol" &&
                         !isNaN(prop) // https://stackoverflow.com/a/175787/892698
                     ) {
-                        return _this.items[prop];
+                        return this.items[prop];
                     }
                     else {
                         return Reflect.get(obj, prop);
                     }
                 },
-                set: function (obj, key, setValue) {
+                set: (obj, key, setValue) => {
                     if (typeof (key) !== "symbol" && !isNaN(key)) {
                         if (setValue === undefined || setValue === null) {
                             obj.$deleteAt(key);
@@ -1603,26 +1552,26 @@
                             if (setValue[$changes]) {
                                 if (obj.items[key] !== undefined) {
                                     if (setValue[$changes][$isNew]) {
-                                        _this[$changes].indexedOperation(Number(key), exports.OPERATION.MOVE_AND_ADD);
+                                        this[$changes].indexedOperation(Number(key), exports.OPERATION.MOVE_AND_ADD);
                                     }
                                     else {
                                         if ((obj[$changes].getChange(Number(key)) & exports.OPERATION.DELETE) === exports.OPERATION.DELETE) {
-                                            _this[$changes].indexedOperation(Number(key), exports.OPERATION.DELETE_AND_MOVE);
+                                            this[$changes].indexedOperation(Number(key), exports.OPERATION.DELETE_AND_MOVE);
                                         }
                                         else {
-                                            _this[$changes].indexedOperation(Number(key), exports.OPERATION.MOVE);
+                                            this[$changes].indexedOperation(Number(key), exports.OPERATION.MOVE);
                                         }
                                     }
                                 }
                                 else if (setValue[$changes][$isNew]) {
-                                    _this[$changes].indexedOperation(Number(key), exports.OPERATION.ADD);
+                                    this[$changes].indexedOperation(Number(key), exports.OPERATION.ADD);
                                 }
                             }
                             else {
                                 obj.$changeAt(Number(key), setValue);
                             }
-                            _this.items[key] = setValue;
-                            _this.tmpItems[key] = setValue;
+                            this.items[key] = setValue;
+                            this.tmpItems[key] = setValue;
                         }
                         return true;
                     }
@@ -1630,7 +1579,7 @@
                         return Reflect.set(obj, key, setValue);
                     }
                 },
-                deleteProperty: function (obj, prop) {
+                deleteProperty: (obj, prop) => {
                     if (typeof (prop) === "number") {
                         obj.$deleteAt(prop);
                     }
@@ -1639,9 +1588,9 @@
                     }
                     return true;
                 },
-                has: function (obj, key) {
+                has: (obj, key) => {
                     if (typeof (key) !== "symbol" && !isNaN(Number(key))) {
-                        return Reflect.has(_this.items, key);
+                        return Reflect.has(this.items, key);
                     }
                     return Reflect.has(obj, key);
                 }
@@ -1650,82 +1599,48 @@
             this.push.apply(this, items);
             return proxy;
         }
-        /**
-         * Determine if a property must be filtered.
-         * - If returns false, the property is NOT going to be encoded.
-         * - If returns true, the property is going to be encoded.
-         *
-         * Encoding with "filters" happens in two steps:
-         * - First, the encoder iterates over all "not owned" properties and encodes them.
-         * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
-         */
-        ArraySchema[(_a = $encoder, _b = $decoder, $filter)] = function (ref, index, view) {
-            var _c;
-            // console.log("ArraSchema[$filter] VIEW??", !view)
-            return (!view ||
-                typeof (ref[$childType]) === "string" ||
-                // view.items.has(ref[$getByIndex](index)[$changes])
-                view.items.has((_c = ref['tmpItems'][index]) === null || _c === void 0 ? void 0 : _c[$changes]));
-        };
-        ArraySchema.is = function (type) {
-            return (
-            // type format: ["string"]
-            Array.isArray(type) ||
-                // type format: { array: "string" }
-                (type['array'] !== undefined));
-        };
-        Object.defineProperty(ArraySchema.prototype, "length", {
-            get: function () {
-                return this.items.length;
-            },
-            set: function (newLength) {
-                if (newLength === 0) {
-                    this.clear();
-                }
-                else if (newLength < this.items.length) {
-                    this.splice(newLength, this.length - newLength);
-                }
-                else {
-                    console.warn("ArraySchema: can't set .length to a higher value than its length.");
-                }
-            },
-            enumerable: false,
-            configurable: true
-        });
-        ArraySchema.prototype.push = function () {
-            var _this = this;
-            var values = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                values[_i] = arguments[_i];
-            }
-            var length = this.tmpItems.length;
-            values.forEach(function (value, i) {
-                var _c;
+        set length(newLength) {
+            if (newLength === 0) {
+                this.clear();
+            }
+            else if (newLength < this.items.length) {
+                this.splice(newLength, this.length - newLength);
+            }
+            else {
+                console.warn("ArraySchema: can't set .length to a higher value than its length.");
+            }
+        }
+        get length() {
+            return this.items.length;
+        }
+        push(...values) {
+            let length = this.tmpItems.length;
+            values.forEach((value, i) => {
                 // skip null values
                 if (value === undefined || value === null) {
                     return;
                 }
-                var changeTree = _this[$changes];
-                changeTree.indexedOperation(length, exports.OPERATION.ADD, _this.items.length);
+                const changeTree = this[$changes];
+                changeTree.indexedOperation(length, exports.OPERATION.ADD, this.items.length);
                 // changeTree.indexes[length] = length;
-                _this.items.push(value);
-                _this.tmpItems.push(value);
+                this.items.push(value);
+                this.tmpItems.push(value);
                 //
                 // set value's parent after the value is set
                 // (to avoid encoding "refId" operations before parent's "ADD" operation)
                 //
-                (_c = value[$changes]) === null || _c === void 0 ? void 0 : _c.setParent(_this, changeTree.root, length);
+                value[$changes]?.setParent(this, changeTree.root, length);
                 length++;
             });
             return length;
-        };
+        }
         /**
          * Removes the last element from an array and returns it.
          */
-        ArraySchema.prototype.pop = function () {
-            var index = -1;
+        pop() {
+            let index = -1;
             // find last non-undefined index
-            for (var i = this.tmpItems.length - 1; i >= 0; i--) {
+            for (let i = this.tmpItems.length - 1; i >= 0; i--) {
                 // if (this.tmpItems[i] !== undefined) {
                 if (this.deletedIndexes[i] !== true) {
                     index = i;
@@ -1739,16 +1654,15 @@
             // this.tmpItems[index] = undefined;
             this.deletedIndexes[index] = true;
             return this.items.pop();
-        };
-        ArraySchema.prototype.at = function (index) {
+        }
+        at(index) {
             // Allow negative indexing from the end
             if (index < 0)
                 index += this.length;
             return this.items[index];
-        };
+        }
         // encoding only
-        ArraySchema.prototype.$changeAt = function (index, value) {
-            var _c, _d, _e, _f;
+        $changeAt(index, value) {
             if (value === undefined || value === null) {
                 console.error("ArraySchema items cannot be null nor undefined; Use `deleteAt(index)` instead.");
                 return;
@@ -1757,21 +1671,21 @@
             if (this.items[index] === value) {
                 return;
             }
-            var changeTree = this[$changes];
-            var operation = (_e = (_d = (_c = changeTree.indexes) === null || _c === void 0 ? void 0 : _c[index]) === null || _d === void 0 ? void 0 : _d.op) !== null && _e !== void 0 ? _e : exports.OPERATION.ADD;
+            const changeTree = this[$changes];
+            const operation = changeTree.indexes?.[index]?.op ?? exports.OPERATION.ADD;
             changeTree.change(index, operation);
             //
             // set value's parent after the value is set
             // (to avoid encoding "refId" operations before parent's "ADD" operation)
             //
-            (_f = value[$changes]) === null || _f === void 0 ? void 0 : _f.setParent(this, changeTree.root, index);
-        };
+            value[$changes]?.setParent(this, changeTree.root, index);
+        }
         // encoding only
-        ArraySchema.prototype.$deleteAt = function (index, operation) {
+        $deleteAt(index, operation) {
             this[$changes].delete(index, operation);
-        };
+        }
         // decoding only
-        ArraySchema.prototype.$setAt = function (index, value, operation) {
+        $setAt(index, value, operation) {
             if (index === 0 &&
                 operation === exports.OPERATION.ADD &&
                 this.items[index] !== undefined) {
@@ -1785,17 +1699,16 @@
             else {
                 this.items[index] = value;
             }
-        };
-        ArraySchema.prototype.clear = function () {
+        }
+        clear() {
             // skip if already clear
             if (this.items.length === 0) {
                 return;
             }
             // discard previous operations.
-            var changeTree = this[$changes];
+            const changeTree = this[$changes];
             // discard children
-            changeTree.forEachChild(function (changeTree, _) {
-                var _c, _d, _e;
+            changeTree.forEachChild((changeTree, _) => {
                 changeTree.discard(true);
                 //
                 // TODO: add tests with instance sharing + .clear()
@@ -1803,70 +1716,64 @@
                 //
                 // TODO: do not use [$changes] at decoding time.
                 //
-                (_c = changeTree.root) === null || _c === void 0 ? void 0 : _c.changes.delete(changeTree);
-                (_d = changeTree.root) === null || _d === void 0 ? void 0 : _d.allChanges.delete(changeTree);
-                (_e = changeTree.root) === null || _e === void 0 ? void 0 : _e.allFilteredChanges.delete(changeTree);
+                changeTree.root?.changes.delete(changeTree);
+                changeTree.root?.allChanges.delete(changeTree);
+                changeTree.root?.allFilteredChanges.delete(changeTree);
             });
             changeTree.discard(true);
             changeTree.operation(exports.OPERATION.CLEAR);
             this.items.length = 0;
             this.tmpItems.length = 0;
-        };
+        }
         /**
          * Combines two or more arrays.
          * @param items Additional items to add to the end of array1.
          */
         // @ts-ignore
-        ArraySchema.prototype.concat = function () {
-            var _c;
-            var items = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                items[_i] = arguments[_i];
-            }
-            return new (ArraySchema.bind.apply(ArraySchema, __spreadArray([void 0], (_c = this.items).concat.apply(_c, items), false)))();
-        };
+        concat(...items) {
+            return new ArraySchema(...this.items.concat(...items));
+        }
         /**
          * Adds all the elements of an array separated by the specified separator string.
          * @param separator A string used to separate one element of an array from the next in the resulting String. If omitted, the array elements are separated with a comma.
          */
-        ArraySchema.prototype.join = function (separator) {
+        join(separator) {
             return this.items.join(separator);
-        };
+        }
         /**
          * Reverses the elements in an Array.
          */
         // @ts-ignore
-        ArraySchema.prototype.reverse = function () {
+        reverse() {
             this[$changes].operation(exports.OPERATION.REVERSE);
             this.items.reverse();
             this.tmpItems.reverse();
             return this;
-        };
+        }
         /**
          * Removes the first element from an array and returns it.
          */
-        ArraySchema.prototype.shift = function () {
-            var _this = this;
+        shift() {
             if (this.items.length === 0) {
                 return undefined;
             }
             // const index = Number(Object.keys(changeTree.indexes)[0]);
-            var index = this.tmpItems.findIndex(function (item, i) { return item === _this.items[0]; });
-            var changeTree = this[$changes];
+            const index = this.tmpItems.findIndex((item, i) => item === this.items[0]);
+            const changeTree = this[$changes];
             changeTree.delete(index);
             changeTree.shiftAllChangeIndexes(-1, index);
             return this.items.shift();
-        };
+        }
         /**
          * Returns a section of an array.
          * @param start The beginning of the specified portion of the array.
          * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'.
          */
-        ArraySchema.prototype.slice = function (start, end) {
-            var sliced = new ArraySchema();
-            sliced.push.apply(sliced, this.items.slice(start, end));
+        slice(start, end) {
+            const sliced = new ArraySchema();
+            sliced.push(...this.items.slice(start, end));
             return sliced;
-        };
+        }
         /**
          * Sorts an array.
          * @param compareFn Function used to determine the order of the elements. It is expected to return
@@ -1876,53 +1783,45 @@
          * [11,2,22,1].sort((a, b) => a - b)
          * ```
          */
-        ArraySchema.prototype.sort = function (compareFn) {
-            if (compareFn === void 0) { compareFn = DEFAULT_SORT; }
-            var changeTree = this[$changes];
-            var sortedItems = this.items.sort(compareFn);
+        sort(compareFn = DEFAULT_SORT) {
+            const changeTree = this[$changes];
+            const sortedItems = this.items.sort(compareFn);
             // wouldn't OPERATION.MOVE make more sense here?
-            sortedItems.forEach(function (_, i) { return changeTree.change(i, exports.OPERATION.REPLACE); });
+            sortedItems.forEach((_, i) => changeTree.change(i, exports.OPERATION.REPLACE));
             this.tmpItems.sort(compareFn);
             return this;
-        };
+        }
         /**
          * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
          * @param start The zero-based location in the array from which to start removing elements.
          * @param deleteCount The number of elements to remove.
          * @param insertItems Elements to insert into the array in place of the deleted elements.
          */
-        ArraySchema.prototype.splice = function (start, deleteCount) {
-            var _c;
-            var _d;
-            if (deleteCount === void 0) { deleteCount = this.items.length - start; }
-            var insertItems = [];
-            for (var _i = 2; _i < arguments.length; _i++) {
-                insertItems[_i - 2] = arguments[_i];
-            }
-            var changeTree = this[$changes];
-            var tmpItemsLength = this.tmpItems.length;
-            var insertCount = insertItems.length;
+        splice(start, deleteCount = this.items.length - start, ...insertItems) {
+            const changeTree = this[$changes];
+            const tmpItemsLength = this.tmpItems.length;
+            const insertCount = insertItems.length;
             // build up-to-date list of indexes, excluding removed values.
-            var indexes = [];
-            for (var i = 0; i < tmpItemsLength; i++) {
+            const indexes = [];
+            for (let i = 0; i < tmpItemsLength; i++) {
                 // if (this.tmpItems[i] !== undefined) {
                 if (this.deletedIndexes[i] !== true) {
                     indexes.push(i);
                 }
             }
             // delete operations at correct index
-            for (var i = start; i < start + deleteCount; i++) {
-                var index = indexes[i];
+            for (let i = start; i < start + deleteCount; i++) {
+                const index = indexes[i];
                 changeTree.delete(index);
                 // this.tmpItems[index] = undefined;
                 this.deletedIndexes[index] = true;
             }
             // force insert operations
-            for (var i = 0; i < insertCount; i++) {
-                var addIndex = indexes[start] + i;
+            for (let i = 0; i < insertCount; i++) {
+                const addIndex = indexes[start] + i;
                 changeTree.indexedOperation(addIndex, exports.OPERATION.ADD);
                 // set value's parent/root
-                (_d = insertItems[i][$changes]) === null || _d === void 0 ? void 0 : _d.setParent(this, changeTree.root, addIndex);
+                insertItems[i][$changes]?.setParent(this, changeTree.root, addIndex);
             }
             //
             // delete exceeding indexes from "allChanges"
@@ -1931,19 +1830,14 @@
             if (deleteCount > insertCount) {
                 changeTree.shiftAllChangeIndexes(-(deleteCount - insertCount), indexes[start + insertCount]);
             }
-            return (_c = this.items).splice.apply(_c, __spreadArray([start, deleteCount], insertItems, false));
-        };
+            return this.items.splice(start, deleteCount, ...insertItems);
+        }
         /**
          * Inserts new elements at the start of an array.
          * @param items  Elements to insert at the start of the Array.
          */
-        ArraySchema.prototype.unshift = function () {
-            var _c, _d;
-            var items = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                items[_i] = arguments[_i];
-            }
-            var changeTree = this[$changes];
+        unshift(...items) {
+            const changeTree = this[$changes];
             // shift indexes
             changeTree.shiftChangeIndexes(items.length);
             // new index
@@ -1954,29 +1848,28 @@
                 changeTree.allChanges.set(this.items.length, exports.OPERATION.ADD);
             }
             // FIXME: should we use OPERATION.MOVE here instead?
-            items.forEach(function (_, index) {
+            items.forEach((_, index) => {
                 changeTree.change(index, exports.OPERATION.ADD);
             });
-            (_c = this.tmpItems).unshift.apply(_c, items);
-            return (_d = this.items).unshift.apply(_d, items);
-        };
+            this.tmpItems.unshift(...items);
+            return this.items.unshift(...items);
+        }
         /**
          * Returns the index of the first occurrence of a value in an array.
          * @param searchElement The value to locate in the array.
          * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
          */
-        ArraySchema.prototype.indexOf = function (searchElement, fromIndex) {
+        indexOf(searchElement, fromIndex) {
             return this.items.indexOf(searchElement, fromIndex);
-        };
+        }
         /**
          * Returns the index of the last occurrence of a specified value in an array.
          * @param searchElement The value to locate in the array.
          * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at the last index in the array.
          */
-        ArraySchema.prototype.lastIndexOf = function (searchElement, fromIndex) {
-            if (fromIndex === void 0) { fromIndex = this.length - 1; }
+        lastIndexOf(searchElement, fromIndex = this.length - 1) {
             return this.items.lastIndexOf(searchElement, fromIndex);
-        };
+        }
         /**
          * Determines whether all the members of an array satisfy the specified test.
          * @param callbackfn A function that accepts up to three arguments. The every method calls
@@ -1985,9 +1878,9 @@
          * @param thisArg An object to which the this keyword can refer in the callbackfn function.
          * If thisArg is omitted, undefined is used as the this value.
          */
-        ArraySchema.prototype.every = function (callbackfn, thisArg) {
+        every(callbackfn, thisArg) {
             return this.items.every(callbackfn, thisArg);
-        };
+        }
         /**
          * Determines whether the specified callback function returns true for any element of an array.
          * @param callbackfn A function that accepts up to three arguments. The some method calls
@@ -1996,44 +1889,44 @@
          * @param thisArg An object to which the this keyword can refer in the callbackfn function.
          * If thisArg is omitted, undefined is used as the this value.
          */
-        ArraySchema.prototype.some = function (callbackfn, thisArg) {
+        some(callbackfn, thisArg) {
             return this.items.some(callbackfn, thisArg);
-        };
+        }
         /**
          * Performs the specified action for each element in an array.
          * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
          * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
          */
-        ArraySchema.prototype.forEach = function (callbackfn, thisArg) {
+        forEach(callbackfn, thisArg) {
             return this.items.forEach(callbackfn, thisArg);
-        };
+        }
         /**
          * Calls a defined callback function on each element of an array, and returns an array that contains the results.
          * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
          * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
          */
-        ArraySchema.prototype.map = function (callbackfn, thisArg) {
+        map(callbackfn, thisArg) {
             return this.items.map(callbackfn, thisArg);
-        };
-        ArraySchema.prototype.filter = function (callbackfn, thisArg) {
+        }
+        filter(callbackfn, thisArg) {
             return this.items.filter(callbackfn, thisArg);
-        };
+        }
         /**
          * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
          * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
          * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
          */
-        ArraySchema.prototype.reduce = function (callbackfn, initialValue) {
+        reduce(callbackfn, initialValue) {
             return this.items.reduce(callbackfn, initialValue);
-        };
+        }
         /**
          * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
          * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
          * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
          */
-        ArraySchema.prototype.reduceRight = function (callbackfn, initialValue) {
+        reduceRight(callbackfn, initialValue) {
             return this.items.reduceRight(callbackfn, initialValue);
-        };
+        }
         /**
          * Returns the value of the first element in the array where predicate is true, and undefined
          * otherwise.
@@ -2043,9 +1936,9 @@
          * @param thisArg If provided, it will be used as the this value for each invocation of
          * predicate. If it is not provided, undefined is used instead.
          */
-        ArraySchema.prototype.find = function (predicate, thisArg) {
+        find(predicate, thisArg) {
             return this.items.find(predicate, thisArg);
-        };
+        }
         /**
          * Returns the index of the first element in the array where predicate is true, and -1
          * otherwise.
@@ -2055,9 +1948,9 @@
          * @param thisArg If provided, it will be used as the this value for each invocation of
          * predicate. If it is not provided, undefined is used instead.
          */
-        ArraySchema.prototype.findIndex = function (predicate, thisArg) {
+        findIndex(predicate, thisArg) {
             return this.items.findIndex(predicate, thisArg);
-        };
+        }
         /**
          * Returns the this object after filling the section identified by start and end with value
          * @param value value to fill array section with
@@ -2066,12 +1959,12 @@
          * @param end index to stop filling the array at. If end is negative, it is treated as
          * length+end.
          */
-        ArraySchema.prototype.fill = function (value, start, end) {
+        fill(value, start, end) {
             //
             // TODO
             //
             throw new Error("ArraySchema#fill() not implemented");
-        };
+        }
         /**
          * Returns the this object after copying a section of the array identified by start and end
          * to the same array starting at position target
@@ -2081,55 +1974,52 @@
          * is treated as length+end.
          * @param end If not specified, length of the this object is used as its default value.
          */
-        ArraySchema.prototype.copyWithin = function (target, start, end) {
+        copyWithin(target, start, end) {
             //
             // TODO
             //
             throw new Error("ArraySchema#copyWithin() not implemented");
-        };
+        }
         /**
          * Returns a string representation of an array.
          */
-        ArraySchema.prototype.toString = function () {
+        toString() {
             return this.items.toString();
-        };
+        }
         /**
          * Returns a string representation of an array. The elements are converted to string using their toLocalString methods.
          */
-        ArraySchema.prototype.toLocaleString = function () {
+        toLocaleString() {
             return this.items.toLocaleString();
-        };
+        }
+        ;
         /** Iterator */
-        ArraySchema.prototype[Symbol.iterator] = function () {
+        [Symbol.iterator]() {
             return this.items[Symbol.iterator]();
-        };
-        Object.defineProperty(ArraySchema, Symbol.species, {
-            get: function () {
-                return ArraySchema;
-            },
-            enumerable: false,
-            configurable: true
-        });
+        }
+        static get [Symbol.species]() {
+            return ArraySchema;
+        }
         /**
          * Returns an iterable of key, value pairs for every entry in the array
          */
-        ArraySchema.prototype.entries = function () { return this.items.entries(); };
+        entries() { return this.items.entries(); }
         /**
          * Returns an iterable of keys in the array
          */
-        ArraySchema.prototype.keys = function () { return this.items.keys(); };
+        keys() { return this.items.keys(); }
         /**
          * Returns an iterable of values in the array
          */
-        ArraySchema.prototype.values = function () { return this.items.values(); };
+        values() { return this.items.values(); }
         /**
          * Determines whether an array includes a certain element, returning true or false as appropriate.
          * @param searchElement The element to search for.
          * @param fromIndex The position in this array at which to begin searching for searchElement.
          */
-        ArraySchema.prototype.includes = function (searchElement, fromIndex) {
+        includes(searchElement, fromIndex) {
             return this.items.includes(searchElement, fromIndex);
-        };
+        }
         //
         // ES2022
         //
@@ -2144,10 +2034,10 @@
          * thisArg is omitted, undefined is used as the this value.
          */
         // @ts-ignore
-        ArraySchema.prototype.flatMap = function (callback, thisArg) {
+        flatMap(callback, thisArg) {
             // @ts-ignore
             throw new Error("ArraySchema#flatMap() is not supported.");
-        };
+        }
         /**
          * Returns a new array with all sub-array elements concatenated into it recursively up to the
          * specified depth.
@@ -2155,44 +2045,43 @@
          * @param depth The maximum recursion depth
          */
         // @ts-ignore
-        ArraySchema.prototype.flat = function (depth) {
+        flat(depth) {
             throw new Error("ArraySchema#flat() is not supported.");
-        };
-        ArraySchema.prototype.findLast = function () {
+        }
+        findLast() {
             // @ts-ignore
             return this.items.findLast.apply(this.items, arguments);
-        };
-        ArraySchema.prototype.findLastIndex = function () {
+        }
+        findLastIndex(...args) {
             // @ts-ignore
             return this.items.findLastIndex.apply(this.items, arguments);
-        };
+        }
         //
         // ES2023
         //
-        ArraySchema.prototype.with = function (index, value) {
-            var copy = this.items.slice();
+        with(index, value) {
+            const copy = this.items.slice();
             copy[index] = value;
-            return new (ArraySchema.bind.apply(ArraySchema, __spreadArray([void 0], copy, false)))();
-        };
-        ArraySchema.prototype.toReversed = function () {
+            return new ArraySchema(...copy);
+        }
+        toReversed() {
             return this.items.slice().reverse();
-        };
-        ArraySchema.prototype.toSorted = function (compareFn) {
+        }
+        toSorted(compareFn) {
             return this.items.slice().sort(compareFn);
-        };
+        }
         // @ts-ignore
-        ArraySchema.prototype.toSpliced = function (start, deleteCount) {
+        toSpliced(start, deleteCount, ...items) {
             // @ts-ignore
             return this.items.toSpliced.apply(copy, arguments);
-        };
-        ArraySchema.prototype[($getByIndex)] = function (index, isEncodeAll) {
+        }
+        [($getByIndex)](index, isEncodeAll = false) {
             //
             // TODO: avoid unecessary `this.tmpItems` check during decoding.
             //
             //    ENCODING uses `this.tmpItems` (or `this.items` if `isEncodeAll` is true)
             //    DECODING uses `this.items`
             //
-            if (isEncodeAll === void 0) { isEncodeAll = false; }
             return (isEncodeAll)
                 ? this.items[index]
                 : this.deletedIndexes[index]
@@ -2201,63 +2090,79 @@
             // return (isEncodeAll)
             //     ? this.items[index]
             //     : this.tmpItems[index] ?? this.items[index];
-        };
-        ArraySchema.prototype[$deleteByIndex] = function (index) {
+        }
+        [$deleteByIndex](index) {
             this.items[index] = undefined;
-        };
-        ArraySchema.prototype[$onEncodeEnd] = function () {
+        }
+        [$onEncodeEnd]() {
             this.tmpItems = this.items.slice();
             this.deletedIndexes = {};
-        };
-        ArraySchema.prototype[$onDecodeEnd] = function () {
-            this.items = this.items.filter(function (item) { return item !== undefined; });
-        };
-        ArraySchema.prototype.toArray = function () {
+        }
+        [$onDecodeEnd]() {
+            this.items = this.items.filter((item) => item !== undefined);
+        }
+        toArray() {
             return this.items.slice(0);
-        };
-        ArraySchema.prototype.toJSON = function () {
-            return this.toArray().map(function (value) {
+        }
+        toJSON() {
+            return this.toArray().map((value) => {
                 return (typeof (value['toJSON']) === "function")
                     ? value['toJSON']()
                     : value;
             });
-        };
+        }
         //
         // Decoding utilities
         //
-        ArraySchema.prototype.clone = function (isDecoding) {
-            var cloned;
+        clone(isDecoding) {
+            let cloned;
             if (isDecoding) {
                 cloned = new ArraySchema();
-                cloned.push.apply(cloned, this.items);
+                cloned.push(...this.items);
             }
             else {
-                cloned = new (ArraySchema.bind.apply(ArraySchema, __spreadArray([void 0], this.map(function (item) { return ((item[$changes])
+                cloned = new ArraySchema(...this.map(item => ((item[$changes])
                     ? item.clone()
-                    : item); }), false)))();
+                    : item)));
             }
             return cloned;
-        };
-        var _a, _b;
-        ArraySchema[_a] = encodeArray;
-        ArraySchema[_b] = decodeArray;
-        return ArraySchema;
-    }());
+        }
+        ;
+    }
     registerType("array", { constructor: ArraySchema });
 
-    var MapSchema = /** @class */ (function () {
-        function MapSchema(initialValues) {
-            var _this = this;
-            this.$items = new Map();
+    var _a$3, _b$3;
+    class MapSchema {
+        static { this[_a$3] = encodeKeyValueOperation; }
+        static { this[_b$3] = decodeKeyValueOperation; }
+        /**
+         * Determine if a property must be filtered.
+         * - If returns false, the property is NOT going to be encoded.
+         * - If returns true, the property is going to be encoded.
+         *
+         * Encoding with "filters" happens in two steps:
+         * - First, the encoder iterates over all "not owned" properties and encodes them.
+         * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
+         */
+        static [(_a$3 = $encoder, _b$3 = $decoder, $filter)](ref, index, view) {
+            return (!view ||
+                typeof (ref[$childType]) === "string" ||
+                view.items.has(ref[$getByIndex](index)[$changes]));
+        }
+        static is(type) {
+            return type['map'] !== undefined;
+        }
+        constructor(initialValues) {
+            this.$items = new Map();
             this.$indexes = new Map();
             this[$changes] = new ChangeTree(this);
             if (initialValues) {
                 if (initialValues instanceof Map ||
                     initialValues instanceof MapSchema) {
-                    initialValues.forEach(function (v, k) { return _this.set(k, v); });
+                    initialValues.forEach((v, k) => this.set(k, v));
                 }
                 else {
-                    for (var k in initialValues) {
+                    for (const k in initialValues) {
                         this.set(k, initialValues[k]);
                     }
                 }
@@ -2269,53 +2174,27 @@
                 configurable: true,
             });
         }
-        /**
-         * Determine if a property must be filtered.
-         * - If returns false, the property is NOT going to be encoded.
-         * - If returns true, the property is going to be encoded.
-         *
-         * Encoding with "filters" happens in two steps:
-         * - First, the encoder iterates over all "not owned" properties and encodes them.
-         * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
-         */
-        MapSchema[(_a = $encoder, _b = $decoder, $filter)] = function (ref, index, view) {
-            return (!view ||
-                typeof (ref[$childType]) === "string" ||
-                view.items.has(ref[$getByIndex](index)[$changes]));
-        };
-        MapSchema.is = function (type) {
-            return type['map'] !== undefined;
-        };
         /** Iterator */
-        MapSchema.prototype[Symbol.iterator] = function () { return this.$items[Symbol.iterator](); };
-        Object.defineProperty(MapSchema.prototype, Symbol.toStringTag, {
-            get: function () { return this.$items[Symbol.toStringTag]; },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(MapSchema, Symbol.species, {
-            get: function () { return MapSchema; },
-            enumerable: false,
-            configurable: true
-        });
-        MapSchema.prototype.set = function (key, value) {
-            var _c;
+        [Symbol.iterator]() { return this.$items[Symbol.iterator](); }
+        get [Symbol.toStringTag]() { return this.$items[Symbol.toStringTag]; }
+        static get [Symbol.species]() { return MapSchema; }
+        set(key, value) {
             if (value === undefined || value === null) {
-                throw new Error("MapSchema#set('".concat(key, "', ").concat(value, "): trying to set ").concat(value, " value on '").concat(key, "'."));
+                throw new Error(`MapSchema#set('${key}', ${value}): trying to set ${value} value on '${key}'.`);
             }
             // Force "key" as string
             // See: https://github.com/colyseus/colyseus/issues/561#issuecomment-1646733468
             key = key.toString();
-            var changeTree = this[$changes];
+            const changeTree = this[$changes];
             // get "index" for this value.
-            var isReplace = typeof (changeTree.indexes[key]) !== "undefined";
-            var index = (isReplace)
+            const isReplace = typeof (changeTree.indexes[key]) !== "undefined";
+            const index = (isReplace)
                 ? changeTree.indexes[key]
-                : (_c = changeTree.indexes[-1]) !== null && _c !== void 0 ? _c : 0;
-            var operation = (isReplace)
+                : changeTree.indexes[-1] ?? 0;
+            let operation = (isReplace)
                 ? exports.OPERATION.REPLACE
                 : exports.OPERATION.ADD;
-            var isRef = (value[$changes]) !== undefined;
+            const isRef = (value[$changes]) !== undefined;
             //
             // (encoding)
             // set a unique id to relate directly with this key/value.
@@ -2344,17 +2223,17 @@
                 value[$changes].setParent(this, changeTree.root, index);
             }
             return this;
-        };
-        MapSchema.prototype.get = function (key) {
+        }
+        get(key) {
             return this.$items.get(key);
-        };
-        MapSchema.prototype.delete = function (key) {
-            var index = this[$changes].indexes[key];
+        }
+        delete(key) {
+            const index = this[$changes].indexes[key];
             this[$changes].delete(index);
             return this.$items.delete(key);
-        };
-        MapSchema.prototype.clear = function () {
-            var changeTree = this[$changes];
+        }
+        clear() {
+            const changeTree = this[$changes];
             // discard previous operations.
             changeTree.discard(true);
             changeTree.indexes = {};
@@ -2363,69 +2242,64 @@
             // clear items
             this.$items.clear();
             changeTree.operation(exports.OPERATION.CLEAR);
-        };
-        MapSchema.prototype.has = function (key) {
+        }
+        has(key) {
             return this.$items.has(key);
-        };
-        MapSchema.prototype.forEach = function (callbackfn) {
+        }
+        forEach(callbackfn) {
             this.$items.forEach(callbackfn);
-        };
-        MapSchema.prototype.entries = function () {
+        }
+        entries() {
             return this.$items.entries();
-        };
-        MapSchema.prototype.keys = function () {
+        }
+        keys() {
             return this.$items.keys();
-        };
-        MapSchema.prototype.values = function () {
+        }
+        values() {
             return this.$items.values();
-        };
-        Object.defineProperty(MapSchema.prototype, "size", {
-            get: function () {
-                return this.$items.size;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        MapSchema.prototype.setIndex = function (index, key) {
+        }
+        get size() {
+            return this.$items.size;
+        }
+        setIndex(index, key) {
             this.$indexes.set(index, key);
-        };
-        MapSchema.prototype.getIndex = function (index) {
+        }
+        getIndex(index) {
             return this.$indexes.get(index);
-        };
-        MapSchema.prototype[$getByIndex] = function (index) {
+        }
+        [$getByIndex](index) {
             return this.$items.get(this.$indexes.get(index));
-        };
-        MapSchema.prototype[$deleteByIndex] = function (index) {
-            var key = this.$indexes.get(index);
+        }
+        [$deleteByIndex](index) {
+            const key = this.$indexes.get(index);
             this.$items.delete(key);
             this.$indexes.delete(index);
-        };
-        MapSchema.prototype[$onEncodeEnd] = function () {
-            var changeTree = this[$changes];
-            var changes = changeTree.changes.entries();
-            for (var _i = 0, changes_1 = changes; _i < changes_1.length; _i++) {
-                var _c = changes_1[_i], fieldIndex = _c[0], operation = _c[1];
+        }
+        [$onEncodeEnd]() {
+            const changeTree = this[$changes];
+            const changes = changeTree.changes.entries();
+            for (const [fieldIndex, operation] of changes) {
                 if (operation === exports.OPERATION.DELETE) {
-                    var index = this[$getByIndex](fieldIndex);
+                    const index = this[$getByIndex](fieldIndex);
                     delete changeTree.indexes[index];
                 }
             }
-        };
-        MapSchema.prototype.toJSON = function () {
-            var map = {};
-            this.forEach(function (value, key) {
+        }
+        toJSON() {
+            const map = {};
+            this.forEach((value, key) => {
                 map[key] = (typeof (value['toJSON']) === "function")
                     ? value['toJSON']()
                     : value;
             });
             return map;
-        };
+        }
         //
         // Decoding utilities
         //
         // @ts-ignore
-        MapSchema.prototype.clone = function (isDecoding) {
-            var cloned;
+        clone(isDecoding) {
+            let cloned;
             if (isDecoding) {
                 // client-side
                 cloned = Object.assign(new MapSchema(), this);
@@ -2433,7 +2307,7 @@
             else {
                 // server-side
                 cloned = new MapSchema();
-                this.forEach(function (value, key) {
+                this.forEach((value, key) => {
                     if (value[$changes]) {
                         cloned.set(key, value['clone']());
                     }
@@ -2443,43 +2317,43 @@
                 });
             }
             return cloned;
-        };
-        var _a, _b;
-        MapSchema[_a] = encodeKeyValueOperation;
-        MapSchema[_b] = decodeKeyValueOperation;
-        return MapSchema;
-    }());
+        }
+    }
     registerType("map", { constructor: MapSchema });
 
-    var DEFAULT_VIEW_TAG = -1;
-    var TypeContext = /** @class */ (function () {
-        function TypeContext(rootClass) {
-            this.types = {};
-            this.schemas = new Map();
-            this.hasFilters = false;
-            if (rootClass) {
-                this.discoverTypes(rootClass);
-            }
-        }
-        TypeContext.register = function (target) {
-            var parent = Object.getPrototypeOf(target);
+    const DEFAULT_VIEW_TAG = -1;
+    class TypeContext {
+        /**
+         * For inheritance support
+         * Keeps track of which classes extends which. (parent -> children)
+         */
+        static { this.inheritedTypes = new Map(); }
+        static register(target) {
+            const parent = Object.getPrototypeOf(target);
             if (parent !== Schema) {
-                var inherits = TypeContext.inheritedTypes.get(parent);
+                let inherits = TypeContext.inheritedTypes.get(parent);
                 if (!inherits) {
                     inherits = new Set();
                     TypeContext.inheritedTypes.set(parent, inherits);
                 }
                 inherits.add(target);
             }
-        };
-        TypeContext.prototype.has = function (schema) {
+        }
+        constructor(rootClass) {
+            this.types = {};
+            this.schemas = new Map();
+            this.hasFilters = false;
+            if (rootClass) {
+                this.discoverTypes(rootClass);
+            }
+        }
+        has(schema) {
             return this.schemas.has(schema);
-        };
-        TypeContext.prototype.get = function (typeid) {
+        }
+        get(typeid) {
             return this.types[typeid];
-        };
-        TypeContext.prototype.add = function (schema, typeid) {
-            if (typeid === void 0) { typeid = this.schemas.size; }
+        }
+        add(schema, typeid = this.schemas.size) {
             // skip if already registered
             if (this.schemas.has(schema)) {
                 return false;
@@ -2487,62 +2361,54 @@
             this.types[typeid] = schema;
             this.schemas.set(schema, typeid);
             return true;
-        };
-        TypeContext.prototype.getTypeId = function (klass) {
+        }
+        getTypeId(klass) {
             return this.schemas.get(klass);
-        };
-        TypeContext.prototype.discoverTypes = function (klass) {
-            var _this = this;
-            var _a;
+        }
+        discoverTypes(klass) {
             if (!this.add(klass)) {
                 return;
             }
             // add classes inherited from this base class
-            (_a = TypeContext.inheritedTypes.get(klass)) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {
-                _this.discoverTypes(child);
+            TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
+                this.discoverTypes(child);
             });
             // skip if no fields are defined for this class.
             if (klass[Symbol.metadata] === undefined) {
                 klass[Symbol.metadata] = {};
             }
             // const metadata = Metadata.getFor(klass);
-            var metadata = klass[Symbol.metadata];
+            const metadata = klass[Symbol.metadata];
             // if any schema/field has filters, mark "context" as having filters.
             if (metadata[-2]) {
                 this.hasFilters = true;
             }
-            for (var field in metadata) {
-                var fieldType = metadata[field].type;
+            for (const field in metadata) {
+                const fieldType = metadata[field].type;
                 if (typeof (fieldType) === "string") {
                     continue;
                 }
                 if (Array.isArray(fieldType)) {
-                    var type_1 = fieldType[0];
-                    if (type_1 === "string") {
+                    const type = fieldType[0];
+                    if (type === "string") {
                         continue;
                     }
-                    this.discoverTypes(type_1);
+                    this.discoverTypes(type);
                 }
                 else if (typeof (fieldType) === "function") {
                     this.discoverTypes(fieldType);
                 }
                 else {
-                    var type_2 = Object.values(fieldType)[0];
+                    const type = Object.values(fieldType)[0];
                     // skip primitive types
-                    if (typeof (type_2) === "string") {
+                    if (typeof (type) === "string") {
                         continue;
                     }
-                    this.discoverTypes(type_2);
+                    this.discoverTypes(type);
                 }
             }
-        };
-        /**
-         * For inheritance support
-         * Keeps track of which classes extends which. (parent -> children)
-         */
-        TypeContext.inheritedTypes = new Map();
-        return TypeContext;
-    }());
+        }
+    }
     /**
      * [See documentation](https://docs.colyseus.io/state/schema/)
      *
@@ -2685,24 +2551,21 @@
     //         };
     //     }
     // }
-    function view(tag) {
-        if (tag === void 0) { tag = DEFAULT_VIEW_TAG; }
+    function view(tag = DEFAULT_VIEW_TAG) {
         return function (target, fieldName) {
-            var _a, _b, _c;
-            var _d;
-            var constructor = target.constructor;
-            var parentClass = Object.getPrototypeOf(constructor);
-            var parentMetadata = parentClass[Symbol.metadata];
-            var metadata = ((_a = constructor[_d = Symbol.metadata]) !== null && _a !== void 0 ? _a : (constructor[_d] = Object.assign({}, constructor[Symbol.metadata], parentMetadata !== null && parentMetadata !== void 0 ? parentMetadata : Object.create(null))));
+            const constructor = target.constructor;
+            const parentClass = Object.getPrototypeOf(constructor);
+            const parentMetadata = parentClass[Symbol.metadata];
+            const metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
             if (!metadata[fieldName]) {
                 //
                 // detect index for this field, considering inheritance
                 //
                 metadata[fieldName] = {
                     type: undefined,
-                    index: ((_c = (_b = metadata[-1] // current structure already has fields defined
-                    ) !== null && _b !== void 0 ? _b : (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
-                    ) !== null && _c !== void 0 ? _c : -1) + 1 // no fields defined
+                    index: (metadata[-1] // current structure already has fields defined
+                        ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+                        ?? -1) + 1 // no fields defined
                 };
             }
             Metadata.setTag(metadata, fieldName, tag);
@@ -2710,18 +2573,16 @@
     }
     function type(type, options) {
         return function (target, field) {
-            var _a, _b, _c;
-            var _d;
-            var constructor = target.constructor;
+            const constructor = target.constructor;
             if (!type) {
-                throw new Error("".concat(constructor.name, ": @type() reference provided for \"").concat(field, "\" is undefined. Make sure you don't have any circular dependencies."));
+                throw new Error(`${constructor.name}: @type() reference provided for "${field}" is undefined. Make sure you don't have any circular dependencies.`);
             }
             // for inheritance support
             TypeContext.register(constructor);
-            var parentClass = Object.getPrototypeOf(constructor);
-            var parentMetadata = parentClass[Symbol.metadata];
-            var metadata = ((_a = constructor[_d = Symbol.metadata]) !== null && _a !== void 0 ? _a : (constructor[_d] = Object.assign({}, constructor[Symbol.metadata], parentMetadata !== null && parentMetadata !== void 0 ? parentMetadata : Object.create(null))));
-            var fieldIndex;
+            const parentClass = Object.getPrototypeOf(constructor);
+            const parentMetadata = parentClass[Symbol.metadata];
+            const metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
+            let fieldIndex;
             /**
              * skip if descriptor already exists for this field (`@deprecated()`)
              */
@@ -2734,11 +2595,11 @@
                     // trying to define same property multiple times across inheritance.
                     // https://github.com/colyseus/colyseus-unity3d/issues/131#issuecomment-814308572
                     try {
-                        throw new Error("@colyseus/schema: Duplicate '".concat(field, "' definition on '").concat(constructor.name, "'.\nCheck @type() annotation"));
+                        throw new Error(`@colyseus/schema: Duplicate '${field}' definition on '${constructor.name}'.\nCheck @type() annotation`);
                     }
                     catch (e) {
-                        var definitionAtLine = e.stack.split("\n")[4].trim();
-                        throw new Error("".concat(e.message, " ").concat(definitionAtLine));
+                        const definitionAtLine = e.stack.split("\n")[4].trim();
+                        throw new Error(`${e.message} ${definitionAtLine}`);
                     }
                 }
                 else {
@@ -2749,9 +2610,9 @@
                 //
                 // detect index for this field, considering inheritance
                 //
-                fieldIndex = (_c = (_b = metadata[-1] // current structure already has fields defined
-                ) !== null && _b !== void 0 ? _b : (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
-                ) !== null && _c !== void 0 ? _c : -1; // no fields defined
+                fieldIndex = metadata[-1] // current structure already has fields defined
+                    ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+                    ?? -1; // no fields defined
                 fieldIndex++;
             }
             if (options && options.manual) {
@@ -2763,13 +2624,13 @@
                 });
             }
             else {
-                var complexTypeKlass = (Array.isArray(type))
+                const complexTypeKlass = (Array.isArray(type))
                     ? getType("array")
                     : (typeof (Object.keys(type)[0]) === "string") && getType(Object.keys(type)[0]);
-                var childType = (complexTypeKlass)
+                const childType = (complexTypeKlass)
                     ? Object.values(type)[0]
                     : type;
-                Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor("_".concat(field), fieldIndex, childType, complexTypeKlass, metadata, field));
+                Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass, metadata, field));
             }
         };
     }
@@ -2777,8 +2638,7 @@
         return {
             get: function () { return this[fieldCached]; },
             set: function (value) {
-                var _a;
-                var previousValue = this[fieldCached] || undefined;
+                const previousValue = this[fieldCached] || undefined;
                 // skip if value is the same as cached.
                 if (value === previousValue) {
                     return;
@@ -2788,7 +2648,7 @@
                     if (complexTypeKlass) {
                         // automaticallty transform Array into ArraySchema
                         if (complexTypeKlass.constructor === ArraySchema && !(value instanceof ArraySchema)) {
-                            value = new (ArraySchema.bind.apply(ArraySchema, __spreadArray([void 0], value, false)))();
+                            value = new ArraySchema(...value);
                         }
                         // automaticallty transform Map into MapSchema
                         if (complexTypeKlass.constructor === MapSchema && !(value instanceof MapSchema)) {
@@ -2801,7 +2661,7 @@
                     // TODO: if there are other references to this instance, we should not remove it from root.
                     //
                     if (previousValue !== undefined && previousValue[$changes]) {
-                        (_a = this[$changes].root) === null || _a === void 0 ? void 0 : _a.remove(previousValue[$changes]);
+                        this[$changes].root?.remove(previousValue[$changes]);
                     }
                     // flag the change for encoding.
                     this.constructor[$track](this[$changes], fieldIndex, exports.OPERATION.ADD);
@@ -2829,33 +2689,30 @@
      * `@deprecated()` flag a field as deprecated.
      * The previous `@type()` annotation should remain along with this one.
      */
-    function deprecated(throws) {
-        if (throws === void 0) { throws = true; }
+    function deprecated(throws = true) {
         return function (klass, field) {
-            var _a, _b, _c;
-            var _d;
             //
             // FIXME: the following block of code is repeated across `@type()`, `@deprecated()` and `@unreliable()` decorators.
             //
-            var constructor = klass.constructor;
-            var parentClass = Object.getPrototypeOf(constructor);
-            var parentMetadata = parentClass[Symbol.metadata];
-            var metadata = ((_a = constructor[_d = Symbol.metadata]) !== null && _a !== void 0 ? _a : (constructor[_d] = Object.assign({}, constructor[Symbol.metadata], parentMetadata !== null && parentMetadata !== void 0 ? parentMetadata : Object.create(null))));
+            const constructor = klass.constructor;
+            const parentClass = Object.getPrototypeOf(constructor);
+            const parentMetadata = parentClass[Symbol.metadata];
+            const metadata = (constructor[Symbol.metadata] ??= Object.assign({}, constructor[Symbol.metadata], parentMetadata ?? Object.create(null)));
             if (!metadata[field]) {
                 //
                 // detect index for this field, considering inheritance
                 //
                 metadata[field] = {
                     type: undefined,
-                    index: ((_c = (_b = metadata[-1] // current structure already has fields defined
-                    ) !== null && _b !== void 0 ? _b : (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
-                    ) !== null && _c !== void 0 ? _c : -1) + 1 // no fields defined
+                    index: (metadata[-1] // current structure already has fields defined
+                        ?? (parentMetadata && parentMetadata[-1]) // parent structure has fields defined
+                        ?? -1) + 1 // no fields defined
                 };
             }
             metadata[field].deprecated = true;
             if (throws) {
                 metadata[field].descriptor = {
-                    get: function () { throw new Error("".concat(field, " is deprecated.")); },
+                    get: function () { throw new Error(`${field} is deprecated.`); },
                     set: function (value) { },
                     enumerable: false,
                     configurable: true
@@ -2870,27 +2727,25 @@
         };
     }
     function defineTypes(target, fields, options) {
-        for (var field in fields) {
+        for (let field in fields) {
             type(fields[field], options)(target.prototype, field);
         }
         return target;
     }
 
     function getIndent(level) {
-        return (new Array(level).fill(0)).map(function (_, i) {
-            return (i === level - 1) ? "\u2514\u2500 " : "   ";
-        }).join("");
+        return (new Array(level).fill(0)).map((_, i) => (i === level - 1) ? `└─ ` : `   `).join("");
     }
     function dumpChanges(schema) {
-        var $root = schema[$changes].root;
-        var dump = {
+        const $root = schema[$changes].root;
+        const dump = {
             ops: {},
             refs: []
         };
-        $root.changes.forEach(function (operations, changeTree) {
-            dump.refs.push("refId#".concat(changeTree.refId));
-            operations.forEach(function (op, index) {
-                var opName = exports.OPERATION[op];
+        $root.changes.forEach((operations, changeTree) => {
+            dump.refs.push(`refId#${changeTree.refId}`);
+            operations.forEach((op, index) => {
+                const opName = exports.OPERATION[op];
                 if (!dump.ops[opName]) {
                     dump.ops[opName] = 0;
                 }
@@ -2905,7 +2760,7 @@
             return number;
         }
         // Find the position of the most significant bit
-        var msbPosition = 0;
+        let msbPosition = 0;
         while (number > 0) {
             number >>= 1;
             msbPosition++;
@@ -2914,40 +2769,29 @@
         return 1 << msbPosition;
     }
 
+    var _a$2, _b$2;
     /**
      * Schema encoder / decoder
      */
-    var Schema = /** @class */ (function () {
-        // allow inherited classes to have a constructor
-        function Schema() {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            Schema.initialize(this);
-            //
-            // Assign initial values
-            //
-            if (args[0]) {
-                this.assign(args[0]);
-            }
-        }
+    class Schema {
+        static { this[_a$2] = encodeSchemaOperation; }
+        static { this[_b$2] = decodeSchemaOperation; }
         /**
          * Assign the property descriptors required to track changes on this instance.
          * @param instance
          */
-        Schema.initialize = function (instance) {
+        static initialize(instance) {
             Object.defineProperty(instance, $changes, {
                 value: new ChangeTree(instance),
                 enumerable: false,
                 writable: true
             });
-            var metadata = instance.constructor[Symbol.metadata];
+            const metadata = instance.constructor[Symbol.metadata];
             // Define property descriptors
-            for (var field in metadata) {
+            for (const field in metadata) {
                 if (metadata[field].descriptor) {
                     // for encoder
-                    Object.defineProperty(instance, "_".concat(field), {
+                    Object.defineProperty(instance, `_${field}`, {
                         value: undefined,
                         writable: true,
                         enumerable: false,
@@ -2971,19 +2815,18 @@
                 //     instance[field] = args[0][field];
                 // }
             }
-        };
-        Schema.is = function (type) {
+        }
+        static is(type) {
             return typeof (type[Symbol.metadata]) === "object";
             // const metadata = type[Symbol.metadata];
             // return metadata && Object.prototype.hasOwnProperty.call(metadata, -1);
-        };
+        }
         /**
          * Track property changes
          */
-        Schema[(_a = $encoder, _b = $decoder, $track)] = function (changeTree, index, operation) {
-            if (operation === void 0) { operation = exports.OPERATION.ADD; }
+        static [(_a$2 = $encoder, _b$2 = $decoder, $track)](changeTree, index, operation = exports.OPERATION.ADD) {
             changeTree.change(index, operation);
-        };
+        }
         /**
          * Determine if a property must be filtered.
          * - If returns false, the property is NOT going to be encoded.
@@ -2993,10 +2836,9 @@
          * - First, the encoder iterates over all "not owned" properties and encodes them.
          * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
          */
-        Schema[$filter] = function (ref, index, view) {
-            var _c;
-            var metadata = ref.constructor[Symbol.metadata];
-            var tag = metadata[metadata[index]].tag;
+        static [$filter](ref, index, view) {
+            const metadata = ref.constructor[Symbol.metadata];
+            const tag = metadata[metadata[index]].tag;
             if (view === undefined) {
                 // shared pass/encode: encode if doesn't have a tag
                 return tag === undefined;
@@ -3011,34 +2853,43 @@
             }
             else {
                 // view pass: custom tag
-                var tags = (_c = view.tags) === null || _c === void 0 ? void 0 : _c.get(ref[$changes]);
+                const tags = view.tags?.get(ref[$changes]);
                 return tags && tags.has(tag);
             }
-        };
-        Schema.prototype.assign = function (props) {
+        }
+        // allow inherited classes to have a constructor
+        constructor(...args) {
+            Schema.initialize(this);
+            //
+            // Assign initial values
+            //
+            if (args[0]) {
+                this.assign(args[0]);
+            }
+        }
+        assign(props) {
             Object.assign(this, props);
             return this;
-        };
+        }
         /**
          * (Server-side): Flag a property to be encoded for the next patch.
          * @param instance Schema instance
          * @param property string representing the property name, or number representing the index of the property.
          * @param operation OPERATION to perform (detected automatically)
          */
-        Schema.prototype.setDirty = function (property, operation) {
+        setDirty(property, operation) {
             this[$changes].change(this.constructor[Symbol.metadata][property].index, operation);
-        };
-        Schema.prototype.clone = function () {
-            var _c;
-            var cloned = new (this.constructor);
-            var metadata = this.constructor[Symbol.metadata];
+        }
+        clone() {
+            const cloned = new (this.constructor);
+            const metadata = this.constructor[Symbol.metadata];
             //
             // TODO: clone all properties, not only annotated ones
             //
             // for (const field in this) {
-            for (var field in metadata) {
+            for (const field in metadata) {
                 if (typeof (this[field]) === "object" &&
-                    typeof ((_c = this[field]) === null || _c === void 0 ? void 0 : _c.clone) === "function") {
+                    typeof (this[field]?.clone) === "function") {
                     // deep clone
                     cloned[field] = this[field].clone();
                 }
@@ -3048,12 +2899,12 @@
                 }
             }
             return cloned;
-        };
-        Schema.prototype.toJSON = function () {
-            var metadata = this.constructor[Symbol.metadata];
-            var obj = {};
-            for (var fieldName in metadata) {
-                var field = metadata[fieldName];
+        }
+        toJSON() {
+            const metadata = this.constructor[Symbol.metadata];
+            const obj = {};
+            for (const fieldName in metadata) {
+                const field = metadata[fieldName];
                 if (!field.deprecated && this[fieldName] !== null && typeof (this[fieldName]) !== "undefined") {
                     obj[fieldName] = (typeof (this[fieldName]['toJSON']) === "function")
                         ? this[fieldName]['toJSON']()
@@ -3061,30 +2912,25 @@
                 }
             }
             return obj;
-        };
-        Schema.prototype.discardAllChanges = function () {
+        }
+        discardAllChanges() {
             this[$changes].discardAll();
-        };
-        Schema.prototype[$getByIndex] = function (index) {
+        }
+        [$getByIndex](index) {
             return this[this.constructor[Symbol.metadata][index]];
-        };
-        Schema.prototype[$deleteByIndex] = function (index) {
+        }
+        [$deleteByIndex](index) {
             this[this.constructor[Symbol.metadata][index]] = undefined;
-        };
-        Schema.debugRefIds = function (instance, jsonContents, level) {
-            var _this = this;
-            if (jsonContents === void 0) { jsonContents = true; }
-            if (level === void 0) { level = 0; }
-            var ref = instance;
-            var changeTree = ref[$changes];
-            var contents = (jsonContents) ? " - ".concat(JSON.stringify(ref.toJSON())) : "";
-            var output = "";
-            output += "".concat(getIndent(level)).concat(ref.constructor.name, " (").concat(ref[$changes].refId, ")").concat(contents, "\n");
-            changeTree.forEachChild(function (childChangeTree) {
-                return output += _this.debugRefIds(childChangeTree.ref, jsonContents, level + 1);
-            });
+        }
+        static debugRefIds(instance, jsonContents = true, level = 0) {
+            const ref = instance;
+            const changeTree = ref[$changes];
+            const contents = (jsonContents) ? ` - ${JSON.stringify(ref.toJSON())}` : "";
+            let output = "";
+            output += `${getIndent(level)}${ref.constructor.name} (${ref[$changes].refId})${contents}\n`;
+            changeTree.forEachChild((childChangeTree) => output += this.debugRefIds(childChangeTree.ref, jsonContents, level + 1));
             return output;
-        };
+        }
         /**
          * Return a string representation of the changes on a Schema instance.
          * The list of changes is cleared after each encode.
@@ -3093,46 +2939,39 @@
          * @param isEncodeAll Return "full encode" instead of current change set.
          * @returns
          */
-        Schema.debugChanges = function (instance, isEncodeAll) {
-            var _c, _d;
-            if (isEncodeAll === void 0) { isEncodeAll = false; }
-            var changeTree = instance[$changes];
-            var changeSet = (isEncodeAll) ? changeTree.allChanges : changeTree.changes;
-            var changeSetName = (isEncodeAll) ? "allChanges" : "changes";
-            var output = "".concat(instance.constructor.name, " (").concat(changeTree.refId, ") -> .").concat(changeSetName, ":\n");
+        static debugChanges(instance, isEncodeAll = false) {
+            const changeTree = instance[$changes];
+            const changeSet = (isEncodeAll) ? changeTree.allChanges : changeTree.changes;
+            const changeSetName = (isEncodeAll) ? "allChanges" : "changes";
+            let output = `${instance.constructor.name} (${changeTree.refId}) -> .${changeSetName}:\n`;
             function dumpChangeSet(changeSet) {
                 Array.from(changeSet)
-                    .sort(function (a, b) { return a[0] - b[0]; })
-                    .forEach(function (_c) {
-                    var index = _c[0], operation = _c[1];
-                    return output += "- [".concat(index, "]: ").concat(exports.OPERATION[operation], " (").concat(JSON.stringify(changeTree.getValue(index, isEncodeAll)), ")\n");
-                });
+                    .sort((a, b) => a[0] - b[0])
+                    .forEach(([index, operation]) => output += `- [${index}]: ${exports.OPERATION[operation]} (${JSON.stringify(changeTree.getValue(index, isEncodeAll))})\n`);
             }
             dumpChangeSet(changeSet);
             // display filtered changes
-            if (!isEncodeAll && ((_c = changeTree.filteredChanges) === null || _c === void 0 ? void 0 : _c.size) > 0) {
-                output += "".concat(instance.constructor.name, " (").concat(changeTree.refId, ") -> .filteredChanges:\n");
+            if (!isEncodeAll && changeTree.filteredChanges?.size > 0) {
+                output += `${instance.constructor.name} (${changeTree.refId}) -> .filteredChanges:\n`;
                 dumpChangeSet(changeTree.filteredChanges);
             }
             // display filtered changes
-            if (isEncodeAll && ((_d = changeTree.allFilteredChanges) === null || _d === void 0 ? void 0 : _d.size) > 0) {
-                output += "".concat(instance.constructor.name, " (").concat(changeTree.refId, ") -> .allFilteredChanges:\n");
+            if (isEncodeAll && changeTree.allFilteredChanges?.size > 0) {
+                output += `${instance.constructor.name} (${changeTree.refId}) -> .allFilteredChanges:\n`;
                 dumpChangeSet(changeTree.allFilteredChanges);
             }
             return output;
-        };
-        Schema.debugChangesDeep = function (ref) {
-            var _c, _d;
-            var output = "";
-            var rootChangeTree = ref[$changes];
-            var changeTrees = new Map();
-            var totalInstances = 0;
-            var totalOperations = 0;
-            for (var _i = 0, _e = (rootChangeTree.root.changes.entries()); _i < _e.length; _i++) {
-                var _f = _e[_i], changeTree = _f[0], changes = _f[1];
-                var includeChangeTree = false;
-                var parentChangeTrees = [];
-                var parentChangeTree = (_c = changeTree.parent) === null || _c === void 0 ? void 0 : _c[$changes];
+        }
+        static debugChangesDeep(ref) {
+            let output = "";
+            const rootChangeTree = ref[$changes];
+            const changeTrees = new Map();
+            let totalInstances = 0;
+            let totalOperations = 0;
+            for (const [changeTree, changes] of (rootChangeTree.root.changes.entries())) {
+                let includeChangeTree = false;
+                let parentChangeTrees = [];
+                let parentChangeTree = changeTree.parent?.[$changes];
                 if (changeTree === rootChangeTree) {
                     includeChangeTree = true;
                 }
@@ -3143,7 +2982,7 @@
                             includeChangeTree = true;
                             break;
                         }
-                        parentChangeTree = (_d = parentChangeTree.parent) === null || _d === void 0 ? void 0 : _d[$changes];
+                        parentChangeTree = parentChangeTree.parent?.[$changes];
                     }
                 }
                 if (includeChangeTree) {
@@ -3153,55 +2992,36 @@
                 }
             }
             output += "---\n";
-            output += "root refId: ".concat(rootChangeTree.refId, "\n");
-            output += "Total instances: ".concat(totalInstances, "\n");
-            output += "Total changes: ".concat(totalOperations, "\n");
+            output += `root refId: ${rootChangeTree.refId}\n`;
+            output += `Total instances: ${totalInstances}\n`;
+            output += `Total changes: ${totalOperations}\n`;
             output += "---\n";
             // based on root.changes, display a tree of changes that has the "ref" instance as parent
-            var visitedParents = new WeakSet();
-            for (var _g = 0, _h = changeTrees.entries(); _g < _h.length; _g++) {
-                var _j = _h[_g], changeTree = _j[0], parentChangeTrees = _j[1];
-                parentChangeTrees.forEach(function (parentChangeTree, level) {
+            const visitedParents = new WeakSet();
+            for (const [changeTree, parentChangeTrees] of changeTrees.entries()) {
+                parentChangeTrees.forEach((parentChangeTree, level) => {
                     if (!visitedParents.has(parentChangeTree)) {
-                        output += "".concat(getIndent(level)).concat(parentChangeTree.ref.constructor.name, " (refId: ").concat(parentChangeTree.refId, ")\n");
+                        output += `${getIndent(level)}${parentChangeTree.ref.constructor.name} (refId: ${parentChangeTree.refId})\n`;
                         visitedParents.add(parentChangeTree);
                     }
                 });
-                var changes = changeTree.changes;
-                var level = parentChangeTrees.length;
-                var indent = getIndent(level);
-                var parentIndex = (level > 0) ? "(".concat(changeTree.parentIndex, ") ") : "";
-                output += "".concat(indent).concat(parentIndex).concat(changeTree.ref.constructor.name, " (refId: ").concat(changeTree.refId, ") - changes: ").concat(changes.size, "\n");
-                for (var _k = 0, changes_1 = changes; _k < changes_1.length; _k++) {
-                    var _l = changes_1[_k], index = _l[0], operation = _l[1];
-                    output += "".concat(getIndent(level + 1)).concat(exports.OPERATION[operation], ": ").concat(index, "\n");
+                const changes = changeTree.changes;
+                const level = parentChangeTrees.length;
+                const indent = getIndent(level);
+                const parentIndex = (level > 0) ? `(${changeTree.parentIndex}) ` : "";
+                output += `${indent}${parentIndex}${changeTree.ref.constructor.name} (refId: ${changeTree.refId}) - changes: ${changes.size}\n`;
+                for (const [index, operation] of changes) {
+                    output += `${getIndent(level + 1)}${exports.OPERATION[operation]}: ${index}\n`;
                 }
             }
-            return "".concat(output);
-        };
-        var _a, _b;
-        Schema[_a] = encodeSchemaOperation;
-        Schema[_b] = decodeSchemaOperation;
-        return Schema;
-    }());
-
-    var CollectionSchema = /** @class */ (function () {
-        function CollectionSchema(initialValues) {
-            var _this = this;
-            this.$items = new Map();
-            this.$indexes = new Map();
-            this.$refId = 0;
-            this[$changes] = new ChangeTree(this);
-            if (initialValues) {
-                initialValues.forEach(function (v) { return _this.add(v); });
-            }
-            Object.defineProperty(this, $childType, {
-                value: undefined,
-                enumerable: false,
-                writable: true,
-                configurable: true,
-            });
+            return `${output}`;
         }
+    }
+
+    var _a$1, _b$1;
+    class CollectionSchema {
+        static { this[_a$1] = encodeKeyValueOperation; }
+        static { this[_b$1] = decodeKeyValueOperation; }
         /**
          * Determine if a property must be filtered.
          * - If returns false, the property is NOT going to be encoded.
@@ -3211,18 +3031,33 @@
          * - First, the encoder iterates over all "not owned" properties and encodes them.
          * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
          */
-        CollectionSchema[(_a = $encoder, _b = $decoder, $filter)] = function (ref, index, view) {
+        static [(_a$1 = $encoder, _b$1 = $decoder, $filter)](ref, index, view) {
             return (!view ||
                 typeof (ref[$childType]) === "string" ||
                 view.items.has(ref[$getByIndex](index)[$changes]));
-        };
-        CollectionSchema.is = function (type) {
+        }
+        static is(type) {
             return type['collection'] !== undefined;
-        };
-        CollectionSchema.prototype.add = function (value) {
+        }
+        constructor(initialValues) {
+            this.$items = new Map();
+            this.$indexes = new Map();
+            this.$refId = 0;
+            this[$changes] = new ChangeTree(this);
+            if (initialValues) {
+                initialValues.forEach((v) => this.add(v));
+            }
+            Object.defineProperty(this, $childType, {
+                value: undefined,
+                enumerable: false,
+                writable: true,
+                configurable: true,
+            });
+        }
+        add(value) {
             // set "index" for reference.
-            var index = this.$refId++;
-            var isRef = (value[$changes]) !== undefined;
+            const index = this.$refId++;
+            const isRef = (value[$changes]) !== undefined;
             if (isRef) {
                 value[$changes].setParent(this, this[$changes].root, index);
             }
@@ -3231,18 +3066,18 @@
             this.$items.set(index, value);
             this[$changes].change(index);
             return index;
-        };
-        CollectionSchema.prototype.at = function (index) {
-            var key = Array.from(this.$items.keys())[index];
+        }
+        at(index) {
+            const key = Array.from(this.$items.keys())[index];
             return this.$items.get(key);
-        };
-        CollectionSchema.prototype.entries = function () {
+        }
+        entries() {
             return this.$items.entries();
-        };
-        CollectionSchema.prototype.delete = function (item) {
-            var entries = this.$items.entries();
-            var index;
-            var entry;
+        }
+        delete(item) {
+            const entries = this.$items.entries();
+            let index;
+            let entry;
             while (entry = entries.next()) {
                 if (entry.done) {
                     break;
@@ -3258,9 +3093,9 @@
             this[$changes].delete(index);
             this.$indexes.delete(index);
             return this.$items.delete(index);
-        };
-        CollectionSchema.prototype.clear = function () {
-            var changeTree = this[$changes];
+        }
+        clear() {
+            const changeTree = this[$changes];
             // discard previous operations.
             changeTree.discard(true);
             changeTree.indexes = {};
@@ -3269,59 +3104,54 @@
             // clear items
             this.$items.clear();
             changeTree.operation(exports.OPERATION.CLEAR);
-        };
-        CollectionSchema.prototype.has = function (value) {
-            return Array.from(this.$items.values()).some(function (v) { return v === value; });
-        };
-        CollectionSchema.prototype.forEach = function (callbackfn) {
-            var _this = this;
-            this.$items.forEach(function (value, key, _) { return callbackfn(value, key, _this); });
-        };
-        CollectionSchema.prototype.values = function () {
+        }
+        has(value) {
+            return Array.from(this.$items.values()).some((v) => v === value);
+        }
+        forEach(callbackfn) {
+            this.$items.forEach((value, key, _) => callbackfn(value, key, this));
+        }
+        values() {
             return this.$items.values();
-        };
-        Object.defineProperty(CollectionSchema.prototype, "size", {
-            get: function () {
-                return this.$items.size;
-            },
-            enumerable: false,
-            configurable: true
-        });
+        }
+        get size() {
+            return this.$items.size;
+        }
         /** Iterator */
-        CollectionSchema.prototype[Symbol.iterator] = function () {
+        [Symbol.iterator]() {
             return this.$items.values();
-        };
-        CollectionSchema.prototype.setIndex = function (index, key) {
+        }
+        setIndex(index, key) {
             this.$indexes.set(index, key);
-        };
-        CollectionSchema.prototype.getIndex = function (index) {
+        }
+        getIndex(index) {
             return this.$indexes.get(index);
-        };
-        CollectionSchema.prototype[$getByIndex] = function (index) {
+        }
+        [$getByIndex](index) {
             return this.$items.get(this.$indexes.get(index));
-        };
-        CollectionSchema.prototype[$deleteByIndex] = function (index) {
-            var key = this.$indexes.get(index);
+        }
+        [$deleteByIndex](index) {
+            const key = this.$indexes.get(index);
             this.$items.delete(key);
             this.$indexes.delete(index);
-        };
-        CollectionSchema.prototype.toArray = function () {
+        }
+        toArray() {
             return Array.from(this.$items.values());
-        };
-        CollectionSchema.prototype.toJSON = function () {
-            var values = [];
-            this.forEach(function (value, key) {
+        }
+        toJSON() {
+            const values = [];
+            this.forEach((value, key) => {
                 values.push((typeof (value['toJSON']) === "function")
                     ? value['toJSON']()
                     : value);
             });
             return values;
-        };
+        }
         //
         // Decoding utilities
         //
-        CollectionSchema.prototype.clone = function (isDecoding) {
-            var cloned;
+        clone(isDecoding) {
+            let cloned;
             if (isDecoding) {
                 // client-side
                 cloned = Object.assign(new CollectionSchema(), this);
@@ -3329,7 +3159,7 @@
             else {
                 // server-side
                 cloned = new CollectionSchema();
-                this.forEach(function (value) {
+                this.forEach((value) => {
                     if (value[$changes]) {
                         cloned.add(value['clone']());
                     }
@@ -3339,31 +3169,14 @@
                 });
             }
             return cloned;
-        };
-        var _a, _b;
-        CollectionSchema[_a] = encodeKeyValueOperation;
-        CollectionSchema[_b] = decodeKeyValueOperation;
-        return CollectionSchema;
-    }());
+        }
+    }
     registerType("collection", { constructor: CollectionSchema, });
 
-    var SetSchema = /** @class */ (function () {
-        function SetSchema(initialValues) {
-            var _this = this;
-            this.$items = new Map();
-            this.$indexes = new Map();
-            this.$refId = 0;
-            this[$changes] = new ChangeTree(this);
-            if (initialValues) {
-                initialValues.forEach(function (v) { return _this.add(v); });
-            }
-            Object.defineProperty(this, $childType, {
-                value: undefined,
-                enumerable: false,
-                writable: true,
-                configurable: true,
-            });
-        }
+    var _a, _b;
+    class SetSchema {
+        static { this[_a] = encodeKeyValueOperation; }
+        static { this[_b] = decodeKeyValueOperation; }
         /**
          * Determine if a property must be filtered.
          * - If returns false, the property is NOT going to be encoded.
@@ -3373,39 +3186,53 @@
          * - First, the encoder iterates over all "not owned" properties and encodes them.
          * - Then, the encoder iterates over all "owned" properties per instance and encodes them.
          */
-        SetSchema[(_a = $encoder, _b = $decoder, $filter)] = function (ref, index, view) {
+        static [(_a = $encoder, _b = $decoder, $filter)](ref, index, view) {
             return (!view ||
                 typeof (ref[$childType]) === "string" ||
                 view.items.has(ref[$getByIndex](index)[$changes]));
-        };
-        SetSchema.is = function (type) {
+        }
+        static is(type) {
             return type['set'] !== undefined;
-        };
-        SetSchema.prototype.add = function (value) {
-            var _c, _d;
+        }
+        constructor(initialValues) {
+            this.$items = new Map();
+            this.$indexes = new Map();
+            this.$refId = 0;
+            this[$changes] = new ChangeTree(this);
+            if (initialValues) {
+                initialValues.forEach((v) => this.add(v));
+            }
+            Object.defineProperty(this, $childType, {
+                value: undefined,
+                enumerable: false,
+                writable: true,
+                configurable: true,
+            });
+        }
+        add(value) {
             // immediatelly return false if value already added.
             if (this.has(value)) {
                 return false;
             }
             // set "index" for reference.
-            var index = this.$refId++;
+            const index = this.$refId++;
             if ((value[$changes]) !== undefined) {
                 value[$changes].setParent(this, this[$changes].root, index);
             }
-            var operation = (_d = (_c = this[$changes].indexes[index]) === null || _c === void 0 ? void 0 : _c.op) !== null && _d !== void 0 ? _d : exports.OPERATION.ADD;
+            const operation = this[$changes].indexes[index]?.op ?? exports.OPERATION.ADD;
             this[$changes].indexes[index] = index;
             this.$indexes.set(index, index);
             this.$items.set(index, value);
             this[$changes].change(index, operation);
             return index;
-        };
-        SetSchema.prototype.entries = function () {
+        }
+        entries() {
             return this.$items.entries();
-        };
-        SetSchema.prototype.delete = function (item) {
-            var entries = this.$items.entries();
-            var index;
-            var entry;
+        }
+        delete(item) {
+            const entries = this.$items.entries();
+            let index;
+            let entry;
             while (entry = entries.next()) {
                 if (entry.done) {
                     break;
@@ -3421,9 +3248,9 @@
             this[$changes].delete(index);
             this.$indexes.delete(index);
             return this.$items.delete(index);
-        };
-        SetSchema.prototype.clear = function () {
-            var changeTree = this[$changes];
+        }
+        clear() {
+            const changeTree = this[$changes];
             // discard previous operations.
             changeTree.discard(true);
             changeTree.indexes = {};
@@ -3432,11 +3259,11 @@
             // clear items
             this.$items.clear();
             changeTree.operation(exports.OPERATION.CLEAR);
-        };
-        SetSchema.prototype.has = function (value) {
-            var values = this.$items.values();
-            var has = false;
-            var entry;
+        }
+        has(value) {
+            const values = this.$items.values();
+            let has = false;
+            let entry;
             while (entry = values.next()) {
                 if (entry.done) {
                     break;
@@ -3447,56 +3274,51 @@
                 }
             }
             return has;
-        };
-        SetSchema.prototype.forEach = function (callbackfn) {
-            var _this = this;
-            this.$items.forEach(function (value, key, _) { return callbackfn(value, key, _this); });
-        };
-        SetSchema.prototype.values = function () {
+        }
+        forEach(callbackfn) {
+            this.$items.forEach((value, key, _) => callbackfn(value, key, this));
+        }
+        values() {
             return this.$items.values();
-        };
-        Object.defineProperty(SetSchema.prototype, "size", {
-            get: function () {
-                return this.$items.size;
-            },
-            enumerable: false,
-            configurable: true
-        });
+        }
+        get size() {
+            return this.$items.size;
+        }
         /** Iterator */
-        SetSchema.prototype[Symbol.iterator] = function () {
+        [Symbol.iterator]() {
             return this.$items.values();
-        };
-        SetSchema.prototype.setIndex = function (index, key) {
+        }
+        setIndex(index, key) {
             this.$indexes.set(index, key);
-        };
-        SetSchema.prototype.getIndex = function (index) {
+        }
+        getIndex(index) {
             return this.$indexes.get(index);
-        };
-        SetSchema.prototype[$getByIndex] = function (index) {
+        }
+        [$getByIndex](index) {
             return this.$items.get(this.$indexes.get(index));
-        };
-        SetSchema.prototype[$deleteByIndex] = function (index) {
-            var key = this.$indexes.get(index);
+        }
+        [$deleteByIndex](index) {
+            const key = this.$indexes.get(index);
             this.$items.delete(key);
             this.$indexes.delete(index);
-        };
-        SetSchema.prototype.toArray = function () {
+        }
+        toArray() {
             return Array.from(this.$items.values());
-        };
-        SetSchema.prototype.toJSON = function () {
-            var values = [];
-            this.forEach(function (value, key) {
+        }
+        toJSON() {
+            const values = [];
+            this.forEach((value, key) => {
                 values.push((typeof (value['toJSON']) === "function")
                     ? value['toJSON']()
                     : value);
             });
             return values;
-        };
+        }
         //
         // Decoding utilities
         //
-        SetSchema.prototype.clone = function (isDecoding) {
-            var cloned;
+        clone(isDecoding) {
+            let cloned;
             if (isDecoding) {
                 // client-side
                 cloned = Object.assign(new SetSchema(), this);
@@ -3504,7 +3326,7 @@
             else {
                 // server-side
                 cloned = new SetSchema();
-                this.forEach(function (value) {
+                this.forEach((value) => {
                     if (value[$changes]) {
                         cloned.add(value['clone']());
                     }
@@ -3514,16 +3336,40 @@
                 });
             }
             return cloned;
-        };
-        var _a, _b;
-        SetSchema[_a] = encodeKeyValueOperation;
-        SetSchema[_b] = decodeKeyValueOperation;
-        return SetSchema;
-    }());
+        }
+    }
     registerType("set", { constructor: SetSchema });
 
-    var Encoder = /** @class */ (function () {
-        function Encoder(root) {
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    class Encoder {
+        static { this.BUFFER_SIZE = 8 * 1024; } // 8KB
+        constructor(root) {
             this.sharedBuffer = Buffer.allocUnsafeSlow(Encoder.BUFFER_SIZE);
             this.setRoot(root);
             //
@@ -3536,26 +3382,22 @@
             //     console.log("type:", id, schema.name, Object.keys(schema[Symbol.metadata]));
             // });
         }
-        Encoder.prototype.setRoot = function (state) {
-            this.$root = new Root();
+        setRoot(state) {
+            this.root = new Root();
             this.state = state;
-            state[$changes].setRoot(this.$root);
-        };
-        Encoder.prototype.encode = function (it, view, bytes, changeTrees) {
-            if (it === void 0) { it = { offset: 0 }; }
-            if (bytes === void 0) { bytes = this.sharedBuffer; }
-            if (changeTrees === void 0) { changeTrees = this.$root.changes; }
-            var initialOffset = it.offset; // cache current offset in case we need to resize the buffer
-            var isEncodeAll = this.$root.allChanges === changeTrees;
-            var hasView = (view !== undefined);
-            var rootChangeTree = this.state[$changes];
-            var changeTreesIterator = changeTrees.entries();
-            for (var _i = 0, changeTreesIterator_1 = changeTreesIterator; _i < changeTreesIterator_1.length; _i++) {
-                var _a = changeTreesIterator_1[_i], changeTree = _a[0], changes = _a[1];
-                var ref = changeTree.ref;
-                var ctor = ref['constructor'];
-                var encoder = ctor[$encoder];
-                var filter = ctor[$filter];
+            state[$changes].setRoot(this.root);
+        }
+        encode(it = { offset: 0 }, view, buffer = this.sharedBuffer, changeTrees = this.root.changes) {
+            const initialOffset = it.offset; // cache current offset in case we need to resize the buffer
+            const isEncodeAll = this.root.allChanges === changeTrees;
+            const hasView = (view !== undefined);
+            const rootChangeTree = this.state[$changes];
+            const changeTreesIterator = changeTrees.entries();
+            for (const [changeTree, changes] of changeTreesIterator) {
+                const ref = changeTree.ref;
+                const ctor = ref['constructor'];
+                const encoder = ctor[$encoder];
+                const filter = ctor[$filter];
                 if (hasView) {
                     if (!view.items.has(changeTree)) {
                         view.invisible.add(changeTree);
@@ -3567,12 +3409,11 @@
                 }
                 // skip root `refId` if it's the first change tree
                 if (it.offset !== initialOffset || changeTree !== rootChangeTree) {
-                    bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
-                    number$1(bytes, changeTree.refId, it);
+                    buffer[it.offset++] = SWITCH_TO_STRUCTURE & 255;
+                    number$1(buffer, changeTree.refId, it);
                 }
-                var changesIterator = changes.entries();
-                for (var _b = 0, changesIterator_1 = changesIterator; _b < changesIterator_1.length; _b++) {
-                    var _c = changesIterator_1[_b], fieldIndex = _c[0], operation = _c[1];
+                const changesIterator = changes.entries();
+                for (const [fieldIndex, operation] of changesIterator) {
                     //
                     // first pass (encodeAll), identify "filtered" operations without encoding them
                     // they will be encoded per client, based on their view.
@@ -3591,17 +3432,21 @@
                     //     fieldIndex,
                     //     operation: OPERATION[operation],
                     // });
-                    encoder(this, bytes, changeTree, fieldIndex, operation, it, isEncodeAll, hasView);
+                    encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView);
                 }
             }
-            if (it.offset > bytes.byteLength) {
-                var newSize = getNextPowerOf2(this.sharedBuffer.byteLength * 2);
-                console.warn("@colyseus/schema encode buffer overflow. Current buffer size: " + bytes.byteLength + ", encoding offset: " + it.offset + ", new size: " + newSize);
+            if (it.offset > buffer.byteLength) {
+                const newSize = getNextPowerOf2(buffer.byteLength * 2);
+                console.warn("@colyseus/schema encode buffer overflow. Current buffer size: " + buffer.byteLength + ", encoding offset: " + it.offset + ", new size: " + newSize);
                 //
                 // resize buffer and re-encode (TODO: can we avoid re-encoding here?)
                 //
-                this.sharedBuffer = Buffer.allocUnsafeSlow(newSize);
-                return this.encode({ offset: initialOffset }, view);
+                buffer = Buffer.allocUnsafeSlow(newSize);
+                // assign resized buffer to local sharedBuffer
+                if (buffer === this.sharedBuffer) {
+                    this.sharedBuffer = buffer;
+                }
+                return this.encode({ offset: initialOffset }, view, buffer);
             }
             else {
                 //
@@ -3613,62 +3458,56 @@
                     //
                     this.onEndEncode(changeTrees);
                 }
-                // return bytes;
-                return bytes.slice(0, it.offset);
+                return buffer.subarray(0, it.offset);
             }
-        };
-        Encoder.prototype.encodeAll = function (it) {
-            // console.log(`encodeAll(), this.$root.allChanges (${this.$root.allChanges.size})`);
-            if (it === void 0) { it = { offset: 0 }; }
-            // Array.from(this.$root.allChanges.entries()).map((item) => {
-            //     console.log("->", item[0].refId, item[0].ref.toJSON());
+        }
+        encodeAll(it = { offset: 0 }, buffer = this.sharedBuffer) {
+            // console.log(`encodeAll(), this.root.allChanges (${this.root.allChanges.size})`);
+            // Array.from(this.root.allChanges.entries()).map((item) => {
+            //     console.log("->", { ref: item[0].ref.constructor.name, refId: item[0].refId, changes: item[1].size });
             // });
-            return this.encode(it, undefined, this.sharedBuffer, this.$root.allChanges);
-        };
-        Encoder.prototype.encodeAllView = function (view, sharedOffset, it, bytes) {
-            if (bytes === void 0) { bytes = this.sharedBuffer; }
-            var viewOffset = it.offset;
-            // console.log(`encodeAllView(), this.$root.allFilteredChanges (${this.$root.allFilteredChanges.size})`);
+            return this.encode(it, undefined, buffer, this.root.allChanges);
+        }
+        encodeAllView(view, sharedOffset, it, bytes = this.sharedBuffer) {
+            const viewOffset = it.offset;
+            // console.log(`encodeAllView(), this.root.allFilteredChanges (${this.root.allFilteredChanges.size})`);
             // this.debugAllFilteredChanges();
             // try to encode "filtered" changes
-            this.encode(it, view, bytes, this.$root.allFilteredChanges);
+            this.encode(it, view, bytes, this.root.allFilteredChanges);
             return Buffer.concat([
-                bytes.slice(0, sharedOffset),
-                bytes.slice(viewOffset, it.offset)
+                bytes.subarray(0, sharedOffset),
+                bytes.subarray(viewOffset, it.offset)
             ]);
-        };
-        // debugAllFilteredChanges() {
-        //     Array.from(this.$root.allFilteredChanges.entries()).map((item) => {
-        //         console.log("->", { refId: item[0].refId }, item[0].ref.toJSON());
-        //         if (Array.isArray(item[0].ref.toJSON())) {
-        //             item[1].forEach((op, key) => {
-        //                 console.log("  ->", { key, op: OPERATION[op] });
-        //             })
-        //         }
-        //     });
-        // }
-        Encoder.prototype.encodeView = function (view, sharedOffset, it, bytes) {
-            if (bytes === void 0) { bytes = this.sharedBuffer; }
-            var viewOffset = it.offset;
+        }
+        debugAllFilteredChanges() {
+            Array.from(this.root.allFilteredChanges.entries()).map((item) => {
+                console.log("->", { refId: item[0].refId, changes: item[1].size }, item[0].ref.toJSON());
+                if (Array.isArray(item[0].ref.toJSON())) {
+                    item[1].forEach((op, key) => {
+                        console.log("  ->", { key, op: exports.OPERATION[op] });
+                    });
+                }
+            });
+        }
+        encodeView(view, sharedOffset, it, bytes = this.sharedBuffer) {
+            const viewOffset = it.offset;
             // try to encode "filtered" changes
-            this.encode(it, view, bytes, this.$root.filteredChanges);
+            this.encode(it, view, bytes, this.root.filteredChanges);
             // encode visibility changes (add/remove for this view)
-            var viewChangesIterator = view.changes.entries();
-            for (var _i = 0, viewChangesIterator_1 = viewChangesIterator; _i < viewChangesIterator_1.length; _i++) {
-                var _a = viewChangesIterator_1[_i], changeTree = _a[0], changes = _a[1];
+            const viewChangesIterator = view.changes.entries();
+            for (const [changeTree, changes] of viewChangesIterator) {
                 if (changes.size === 0) {
                     // FIXME: avoid having empty changes if no changes were made
                     // console.log("changes.size === 0", changeTree.ref.constructor.name);
                     continue;
                 }
-                var ref = changeTree.ref;
-                var ctor = ref['constructor'];
-                var encoder = ctor[$encoder];
+                const ref = changeTree.ref;
+                const ctor = ref['constructor'];
+                const encoder = ctor[$encoder];
                 bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
                 number$1(bytes, changeTree.refId, it);
-                var changesIterator = changes.entries();
-                for (var _b = 0, changesIterator_2 = changesIterator; _b < changesIterator_2.length; _b++) {
-                    var _c = changesIterator_2[_b], fieldIndex = _c[0], operation = _c[1];
+                const changesIterator = changes.entries();
+                for (const [fieldIndex, operation] of changesIterator) {
                     // isEncodeAll = false
                     // hasView = true
                     encoder(this, bytes, changeTree, fieldIndex, operation, it, false, true);
@@ -3681,66 +3520,59 @@
             // clear "view" changes after encoding
             view.changes.clear();
             return Buffer.concat([
-                bytes.slice(0, sharedOffset),
-                bytes.slice(viewOffset, it.offset)
+                bytes.subarray(0, sharedOffset),
+                bytes.subarray(viewOffset, it.offset)
             ]);
-        };
-        Encoder.prototype.onEndEncode = function (changeTrees) {
-            if (changeTrees === void 0) { changeTrees = this.$root.changes; }
-            var changeTreesIterator = changeTrees.entries();
-            for (var _i = 0, changeTreesIterator_2 = changeTreesIterator; _i < changeTreesIterator_2.length; _i++) {
-                var _a = changeTreesIterator_2[_i], changeTree = _a[0]; _a[1];
+        }
+        onEndEncode(changeTrees = this.root.changes) {
+            const changeTreesIterator = changeTrees.entries();
+            for (const [changeTree, _] of changeTreesIterator) {
                 changeTree.endEncode();
             }
-        };
-        Encoder.prototype.discardChanges = function () {
+        }
+        discardChanges() {
             // discard shared changes
-            if (this.$root.changes.size > 0) {
-                this.onEndEncode(this.$root.changes);
-                this.$root.changes.clear();
+            if (this.root.changes.size > 0) {
+                this.onEndEncode(this.root.changes);
+                this.root.changes.clear();
             }
             // discard filtered changes
-            if (this.$root.filteredChanges.size > 0) {
-                this.onEndEncode(this.$root.filteredChanges);
-                this.$root.filteredChanges.clear();
+            if (this.root.filteredChanges.size > 0) {
+                this.onEndEncode(this.root.filteredChanges);
+                this.root.filteredChanges.clear();
             }
-        };
-        Encoder.prototype.tryEncodeTypeId = function (bytes, baseType, targetType, it) {
-            var baseTypeId = this.context.getTypeId(baseType);
-            var targetTypeId = this.context.getTypeId(targetType);
+        }
+        tryEncodeTypeId(bytes, baseType, targetType, it) {
+            const baseTypeId = this.context.getTypeId(baseType);
+            const targetTypeId = this.context.getTypeId(targetType);
             if (baseTypeId !== targetTypeId) {
                 bytes[it.offset++] = TYPE_ID & 255;
                 number$1(bytes, targetTypeId, it);
             }
-        };
-        Encoder.BUFFER_SIZE = 8 * 1024; // 8KB
-        return Encoder;
-    }());
+        }
+    }
 
     function spliceOne(arr, index) {
         // manually splice an array
         if (index === -1 || index >= arr.length) {
             return false;
         }
-        var len = arr.length - 1;
-        for (var i = index; i < len; i++) {
+        const len = arr.length - 1;
+        for (let i = index; i < len; i++) {
             arr[i] = arr[i + 1];
         }
         arr.length = len;
         return true;
     }
 
-    var DecodingWarning = /** @class */ (function (_super) {
-        __extends(DecodingWarning, _super);
-        function DecodingWarning(message) {
-            var _this = _super.call(this, message) || this;
-            _this.name = "DecodingWarning";
-            return _this;
-        }
-        return DecodingWarning;
-    }(Error));
-    var ReferenceTracker = /** @class */ (function () {
-        function ReferenceTracker() {
+    class DecodingWarning extends Error {
+        constructor(message) {
+            super(message);
+            this.name = "DecodingWarning";
+        }
+    }
+    class ReferenceTracker {
+        constructor() {
             //
             // Relation of refId => Schema structure
             // For direct access of structures during decoding time.
@@ -3752,12 +3584,11 @@
             this.callbacks = {};
             this.nextUniqueId = 0;
         }
-        ReferenceTracker.prototype.getNextUniqueId = function () {
+        getNextUniqueId() {
             return this.nextUniqueId++;
-        };
+        }
         // for decoding
-        ReferenceTracker.prototype.addRef = function (refId, ref, incrementCount) {
-            if (incrementCount === void 0) { incrementCount = true; }
+        addRef(refId, ref, incrementCount = true) {
             this.refs.set(refId, ref);
             this.refIds.set(ref, refId);
             if (incrementCount) {
@@ -3766,10 +3597,10 @@
             if (this.deletedRefs.has(refId)) {
                 this.deletedRefs.delete(refId);
             }
-        };
+        }
         // for decoding
-        ReferenceTracker.prototype.removeRef = function (refId) {
-            var refCount = this.refCounts[refId];
+        removeRef(refId) {
+            const refCount = this.refCounts[refId];
             if (refCount === undefined) {
                 try {
                     throw new DecodingWarning("trying to remove refId that doesn't exist");
@@ -3781,8 +3612,8 @@
             }
             if (refCount === 0) {
                 try {
-                    var ref = this.refs.get(refId);
-                    throw new DecodingWarning("trying to remove refId '".concat(refId, "' with 0 refCount (").concat(ref.constructor.name, ": ").concat(JSON.stringify(ref), ")"));
+                    const ref = this.refs.get(refId);
+                    throw new DecodingWarning(`trying to remove refId '${refId}' with 0 refCount (${ref.constructor.name}: ${JSON.stringify(ref)})`);
                 }
                 catch (e) {
                     console.warn(e);
@@ -3792,55 +3623,53 @@
             if ((this.refCounts[refId] = refCount - 1) <= 0) {
                 this.deletedRefs.add(refId);
             }
-        };
-        ReferenceTracker.prototype.clearRefs = function () {
+        }
+        clearRefs() {
             this.refs.clear();
             this.deletedRefs.clear();
             this.refCounts = {};
-        };
+        }
         // for decoding
-        ReferenceTracker.prototype.garbageCollectDeletedRefs = function () {
-            var _this = this;
-            this.deletedRefs.forEach(function (refId) {
+        garbageCollectDeletedRefs() {
+            this.deletedRefs.forEach((refId) => {
                 //
                 // Skip active references.
                 //
-                if (_this.refCounts[refId] > 0) {
+                if (this.refCounts[refId] > 0) {
                     return;
                 }
-                var ref = _this.refs.get(refId);
+                const ref = this.refs.get(refId);
                 //
                 // Ensure child schema instances have their references removed as well.
                 //
                 if (Metadata.isValidInstance(ref)) {
-                    var metadata = ref['constructor'][Symbol.metadata];
-                    for (var field in metadata) {
-                        var childRefId = typeof (ref[field]) === "object" && _this.refIds.get(ref[field]);
+                    const metadata = ref['constructor'][Symbol.metadata];
+                    for (const field in metadata) {
+                        const childRefId = typeof (ref[field]) === "object" && this.refIds.get(ref[field]);
                         if (childRefId) {
-                            _this.removeRef(childRefId);
+                            this.removeRef(childRefId);
                         }
                     }
                 }
                 else {
                     if (typeof (Object.values(ref[$childType])[0]) === "function") {
                         Array.from(ref.values())
-                            .forEach(function (child) { return _this.removeRef(_this.refIds.get(child)); });
+                            .forEach((child) => this.removeRef(this.refIds.get(child)));
                     }
                 }
-                _this.refs.delete(refId); // remove ref
-                delete _this.refCounts[refId]; // remove ref count
-                delete _this.callbacks[refId]; // remove callbacks
+                this.refs.delete(refId); // remove ref
+                delete this.refCounts[refId]; // remove ref count
+                delete this.callbacks[refId]; // remove callbacks
             });
             // clear deleted refs.
             this.deletedRefs.clear();
-        };
-        ReferenceTracker.prototype.addCallback = function (refId, fieldOrOperation, callback) {
-            var _this = this;
+        }
+        addCallback(refId, fieldOrOperation, callback) {
             if (refId === undefined) {
-                var name = (typeof (fieldOrOperation) === "number")
+                const name = (typeof (fieldOrOperation) === "number")
                     ? exports.OPERATION[fieldOrOperation]
                     : fieldOrOperation;
-                throw new Error("Can't addCallback on '".concat(name, "' (refId is undefined)"));
+                throw new Error(`Can't addCallback on '${name}' (refId is undefined)`);
             }
             if (!this.callbacks[refId]) {
                 this.callbacks[refId] = {};
@@ -3849,20 +3678,18 @@
                 this.callbacks[refId][fieldOrOperation] = [];
             }
             this.callbacks[refId][fieldOrOperation].push(callback);
-            return function () { return _this.removeCallback(refId, fieldOrOperation, callback); };
-        };
-        ReferenceTracker.prototype.removeCallback = function (refId, field, callback) {
-            var _a, _b, _c;
-            var index = (_c = (_b = (_a = this.callbacks) === null || _a === void 0 ? void 0 : _a[refId]) === null || _b === void 0 ? void 0 : _b[field]) === null || _c === void 0 ? void 0 : _c.indexOf(callback);
+            return () => this.removeCallback(refId, fieldOrOperation, callback);
+        }
+        removeCallback(refId, field, callback) {
+            const index = this.callbacks?.[refId]?.[field]?.indexOf(callback);
             if (index !== -1) {
                 spliceOne(this.callbacks[refId][field], index);
             }
-        };
-        return ReferenceTracker;
-    }());
+        }
+    }
 
-    var Decoder = /** @class */ (function () {
-        function Decoder(root, context) {
+    class Decoder {
+        constructor(root, context) {
             this.currentRefId = 0;
             this.setRoot(root);
             this.context = context || new TypeContext(root.constructor);
@@ -3871,19 +3698,16 @@
             //     console.log("type:", id, schema.name, Object.keys(schema[Symbol.metadata]));
             // });
         }
-        Decoder.prototype.setRoot = function (root) {
+        setRoot(root) {
             this.state = root;
-            this.$root = new ReferenceTracker();
-            this.$root.addRef(0, root);
-        };
-        Decoder.prototype.decode = function (bytes, it, ref) {
-            var _a, _b, _c;
-            if (it === void 0) { it = { offset: 0 }; }
-            if (ref === void 0) { ref = this.state; }
-            var allChanges = [];
-            var $root = this.$root;
-            var totalBytes = bytes.byteLength;
-            var decoder = ref['constructor'][$decoder];
+            this.root = new ReferenceTracker();
+            this.root.addRef(0, root);
+        }
+        decode(bytes, it = { offset: 0 }, ref = this.state) {
+            const allChanges = [];
+            const $root = this.root;
+            const totalBytes = bytes.byteLength;
+            let decoder = ref['constructor'][$decoder];
             this.currentRefId = 0;
             while (it.offset < totalBytes) {
                 //
@@ -3892,26 +3716,26 @@
                 if (bytes[it.offset] == SWITCH_TO_STRUCTURE) {
                     it.offset++;
                     this.currentRefId = number(bytes, it);
-                    var nextRef = $root.refs.get(this.currentRefId);
+                    const nextRef = $root.refs.get(this.currentRefId);
                     //
                     // Trying to access a reference that haven't been decoded yet.
                     //
                     if (!nextRef) {
-                        throw new Error("\"refId\" not found: ".concat(this.currentRefId));
+                        throw new Error(`"refId" not found: ${this.currentRefId}`);
                     }
-                    (_a = ref[$onDecodeEnd]) === null || _a === void 0 ? void 0 : _a.call(ref);
+                    ref[$onDecodeEnd]?.();
                     ref = nextRef;
                     decoder = ref['constructor'][$decoder];
                     continue;
                 }
-                var result = decoder(this, bytes, it, ref, allChanges);
+                const result = decoder(this, bytes, it, ref, allChanges);
                 if (result === DEFINITION_MISMATCH) {
                     console.warn("@colyseus/schema: definition mismatch");
                     //
                     // keep skipping next bytes until reaches a known structure
                     // by local decoder.
                     //
-                    var nextIterator = { offset: it.offset };
+                    const nextIterator = { offset: it.offset };
                     while (it.offset < totalBytes) {
                         if (switchStructureCheck(bytes, it)) {
                             nextIterator.offset = it.offset + 1;
@@ -3925,130 +3749,118 @@
                 }
             }
             // FIXME: DRY with SWITCH_TO_STRUCTURE block.
-            (_b = ref[$onDecodeEnd]) === null || _b === void 0 ? void 0 : _b.call(ref);
+            ref[$onDecodeEnd]?.();
             // trigger changes
-            (_c = this.triggerChanges) === null || _c === void 0 ? void 0 : _c.call(this, allChanges);
+            this.triggerChanges?.(allChanges);
             // drop references of unused schemas
             $root.garbageCollectDeletedRefs();
             return allChanges;
-        };
-        Decoder.prototype.getInstanceType = function (bytes, it, defaultType) {
-            var type;
+        }
+        getInstanceType(bytes, it, defaultType) {
+            let type;
             if (bytes[it.offset] === TYPE_ID) {
                 it.offset++;
-                var type_id = number(bytes, it);
+                const type_id = number(bytes, it);
                 type = this.context.get(type_id);
             }
             return type || defaultType;
-        };
-        Decoder.prototype.createInstanceOfType = function (type) {
+        }
+        createInstanceOfType(type) {
             // let instance: Schema = new (type as any)();
             // // assign root on $changes
             // instance[$changes].root = this.root[$changes].root;
             // return instance;
             return new type();
-        };
-        Decoder.prototype.removeChildRefs = function (ref, allChanges) {
-            var _this = this;
-            var changeTree = ref[$changes];
-            var needRemoveRef = typeof (ref[$childType]) !== "string";
-            var refId = changeTree.refId;
-            ref.forEach(function (value, key) {
+        }
+        removeChildRefs(ref, allChanges) {
+            const changeTree = ref[$changes];
+            const needRemoveRef = typeof (ref[$childType]) !== "string";
+            const refId = changeTree.refId;
+            ref.forEach((value, key) => {
                 allChanges.push({
                     ref: value,
-                    refId: refId,
+                    refId,
                     op: exports.OPERATION.DELETE,
                     field: key,
                     value: undefined,
                     previousValue: value
                 });
                 if (needRemoveRef) {
-                    _this.$root.removeRef(_this.$root.refIds.get(value));
+                    this.root.removeRef(this.root.refIds.get(value));
                 }
             });
-        };
-        return Decoder;
-    }());
+        }
+    }
 
     /**
      * Reflection
      */
-    var ReflectionField = /** @class */ (function (_super) {
-        __extends(ReflectionField, _super);
-        function ReflectionField() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        __decorate([
-            type("string")
-        ], ReflectionField.prototype, "name", void 0);
-        __decorate([
-            type("string")
-        ], ReflectionField.prototype, "type", void 0);
-        __decorate([
-            type("number")
-        ], ReflectionField.prototype, "referencedType", void 0);
-        return ReflectionField;
-    }(Schema));
-    var ReflectionType = /** @class */ (function (_super) {
-        __extends(ReflectionType, _super);
-        function ReflectionType() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.fields = new ArraySchema();
-            return _this;
-        }
-        __decorate([
-            type("number")
-        ], ReflectionType.prototype, "id", void 0);
-        __decorate([
-            type("number")
-        ], ReflectionType.prototype, "extendsId", void 0);
-        __decorate([
-            type([ReflectionField])
-        ], ReflectionType.prototype, "fields", void 0);
-        return ReflectionType;
-    }(Schema));
-    var Reflection = /** @class */ (function (_super) {
-        __extends(Reflection, _super);
-        function Reflection() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
-            _this.types = new ArraySchema();
-            return _this;
-        }
-        Reflection.encode = function (instance, context) {
+    class ReflectionField extends Schema {
+    }
+    __decorate([
+        type("string")
+    ], ReflectionField.prototype, "name", void 0);
+    __decorate([
+        type("string")
+    ], ReflectionField.prototype, "type", void 0);
+    __decorate([
+        type("number")
+    ], ReflectionField.prototype, "referencedType", void 0);
+    class ReflectionType extends Schema {
+        constructor() {
+            super(...arguments);
+            this.fields = new ArraySchema();
+        }
+    }
+    __decorate([
+        type("number")
+    ], ReflectionType.prototype, "id", void 0);
+    __decorate([
+        type("number")
+    ], ReflectionType.prototype, "extendsId", void 0);
+    __decorate([
+        type([ReflectionField])
+    ], ReflectionType.prototype, "fields", void 0);
+    class Reflection extends Schema {
+        constructor() {
+            super(...arguments);
+            this.types = new ArraySchema();
+        }
+        static encode(instance, context, it = { offset: 0 }) {
             if (!context) {
                 context = new TypeContext(instance.constructor);
             }
-            var reflection = new Reflection();
-            var encoder = new Encoder(reflection);
-            var buildType = function (currentType, metadata) {
-                for (var fieldName in metadata) {
+            const reflection = new Reflection();
+            const encoder = new Encoder(reflection);
+            const buildType = (currentType, metadata) => {
+                for (const fieldName in metadata) {
                     // skip fields from parent classes
                     if (!Object.prototype.hasOwnProperty.call(metadata, fieldName)) {
                         continue;
                     }
-                    var field = new ReflectionField();
+                    const field = new ReflectionField();
                     field.name = fieldName;
-                    var fieldType = void 0;
-                    var type_1 = metadata[fieldName].type;
-                    if (typeof (type_1) === "string") {
-                        fieldType = type_1;
+                    let fieldType;
+                    const type = metadata[fieldName].type;
+                    if (typeof (type) === "string") {
+                        fieldType = type;
                     }
                     else {
-                        var childTypeSchema = void 0;
+                        let childTypeSchema;
                         //
                         // TODO: refactor below.
                         //
-                        if (Schema.is(type_1)) {
+                        if (Schema.is(type)) {
                             fieldType = "ref";
-                            childTypeSchema = type_1;
+                            childTypeSchema = type;
                         }
                         else {
-                            fieldType = Object.keys(type_1)[0];
-                            if (typeof (type_1[fieldType]) === "string") {
-                                fieldType += ":" + type_1[fieldType]; // array:string
+                            fieldType = Object.keys(type)[0];
+                            if (typeof (type[fieldType]) === "string") {
+                                fieldType += ":" + type[fieldType]; // array:string
                             }
                             else {
-                                childTypeSchema = type_1[fieldType];
+                                childTypeSchema = type[fieldType];
                             }
                         }
                         field.referencedType = (childTypeSchema)
@@ -4060,59 +3872,52 @@
                 }
                 reflection.types.push(currentType);
             };
-            for (var typeid in context.types) {
-                var klass = context.types[typeid];
-                var type_2 = new ReflectionType();
-                type_2.id = Number(typeid);
+            for (let typeid in context.types) {
+                const klass = context.types[typeid];
+                const type = new ReflectionType();
+                type.id = Number(typeid);
                 // support inheritance
-                var inheritFrom = Object.getPrototypeOf(klass);
+                const inheritFrom = Object.getPrototypeOf(klass);
                 if (inheritFrom !== Schema) {
-                    type_2.extendsId = context.schemas.get(inheritFrom);
+                    type.extendsId = context.schemas.get(inheritFrom);
                 }
-                buildType(type_2, klass[Symbol.metadata]);
+                buildType(type, klass[Symbol.metadata]);
             }
-            var it = { offset: 0 };
-            var buf = encoder.encodeAll(it);
+            const buf = encoder.encodeAll(it);
             return Buffer.from(buf, 0, it.offset);
-        };
-        Reflection.decode = function (bytes, it) {
-            var reflection = new Reflection();
-            var reflectionDecoder = new Decoder(reflection);
+        }
+        static decode(bytes, it) {
+            const reflection = new Reflection();
+            const reflectionDecoder = new Decoder(reflection);
             reflectionDecoder.decode(bytes, it);
-            var context = new TypeContext();
-            var schemaTypes = reflection.types.reduce(function (types, reflectionType) {
-                var parentKlass = types[reflectionType.extendsId] || Schema;
-                var schema = /** @class */ (function (_super) {
-                    __extends(_, _super);
-                    function _() {
-                        return _super !== null && _super.apply(this, arguments) || this;
-                    }
-                    return _;
-                }(parentKlass));
+            const context = new TypeContext();
+            const schemaTypes = reflection.types.reduce((types, reflectionType) => {
+                const parentKlass = types[reflectionType.extendsId] || Schema;
+                const schema = class _ extends parentKlass {
+                };
                 // const _metadata = Object.create(_classSuper[Symbol.metadata] ?? null);
-                var _metadata = parentKlass && parentKlass[Symbol.metadata] || Object.create(null);
+                const _metadata = parentKlass && parentKlass[Symbol.metadata] || Object.create(null);
                 Object.defineProperty(schema, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
                 // register for inheritance support
                 TypeContext.register(schema);
-                var typeid = reflectionType.id;
+                const typeid = reflectionType.id;
                 types[typeid] = schema;
                 context.add(schema, typeid);
                 return types;
             }, {});
-            reflection.types.forEach(function (reflectionType) {
-                var schemaType = schemaTypes[reflectionType.id];
-                var metadata = schemaType[Symbol.metadata];
-                var parentKlass = reflection.types[reflectionType.extendsId];
-                var parentFieldIndex = parentKlass && parentKlass.fields.length || 0;
-                reflectionType.fields.forEach(function (field, i) {
-                    var _a;
-                    var fieldIndex = parentFieldIndex + i;
+            reflection.types.forEach((reflectionType) => {
+                const schemaType = schemaTypes[reflectionType.id];
+                const metadata = schemaType[Symbol.metadata];
+                const parentKlass = reflection.types[reflectionType.extendsId];
+                const parentFieldIndex = parentKlass && parentKlass.fields.length || 0;
+                reflectionType.fields.forEach((field, i) => {
+                    const fieldIndex = parentFieldIndex + i;
                     if (field.referencedType !== undefined) {
-                        var fieldType = field.type;
-                        var refType = schemaTypes[field.referencedType];
+                        let fieldType = field.type;
+                        let refType = schemaTypes[field.referencedType];
                         // map or array of primitive type (-1)
                         if (!refType) {
-                            var typeInfo = field.type.split(":");
+                            const typeInfo = field.type.split(":");
                             fieldType = typeInfo[0];
                             refType = typeInfo[1];
                         }
@@ -4122,7 +3927,7 @@
                         }
                         else {
                             // type({ [fieldType]: refType } as DefinitionType)(schemaType.prototype, field.name);
-                            Metadata.addField(metadata, fieldIndex, field.name, (_a = {}, _a[fieldType] = refType, _a));
+                            Metadata.addField(metadata, fieldIndex, field.name, { [fieldType]: refType });
                         }
                     }
                     else {
@@ -4132,15 +3937,14 @@
                 });
             });
             return new (schemaTypes[0])();
-        };
-        __decorate([
-            type([ReflectionType])
-        ], Reflection.prototype, "types", void 0);
-        return Reflection;
-    }(Schema));
+        }
+    }
+    __decorate([
+        type([ReflectionType])
+    ], Reflection.prototype, "types", void 0);
 
-    var StateView = /** @class */ (function () {
-        function StateView() {
+    class StateView {
+        constructor() {
             /**
              * List of ChangeTree's that are visible to this view
              */
@@ -4156,22 +3960,17 @@
             this.changes = new Map();
         }
         // TODO: allow to set multiple tags at once
-        StateView.prototype.add = function (obj, tag) {
-            var _this = this;
-            var _a, _b;
-            if (tag === void 0) { tag = DEFAULT_VIEW_TAG; }
+        add(obj, tag = DEFAULT_VIEW_TAG) {
             if (!obj[$changes]) {
                 console.warn("StateView#add(), invalid object:", obj);
                 return this;
             }
-            var changeTree = obj[$changes];
+            let changeTree = obj[$changes];
             this.items.add(changeTree);
             // Add children of this ChangeTree to this view
-            changeTree.forEachChild(function (change, _) {
-                return _this.add(change.ref, tag);
-            });
+            changeTree.forEachChild((change, _) => this.add(change.ref, tag));
             // FIXME: ArraySchema/MapSchema does not have metadata
-            var metadata = obj.constructor[Symbol.metadata];
+            const metadata = obj.constructor[Symbol.metadata];
             // add parent ChangeTree's, if they are invisible to this view
             // TODO: REFACTOR addParent()
             this.addParent(changeTree, tag);
@@ -4179,7 +3978,7 @@
             // TODO: when adding an item of a MapSchema, the changes may not
             // be set (only the parent's changes are set)
             //
-            var changes = this.changes.get(changeTree);
+            let changes = this.changes.get(changeTree);
             if (changes === undefined) {
                 changes = new Map();
                 this.changes.set(changeTree, changes);
@@ -4189,7 +3988,7 @@
                 if (!this.tags) {
                     this.tags = new WeakMap();
                 }
-                var tags = void 0;
+                let tags;
                 if (!this.tags.has(changeTree)) {
                     tags = new Set();
                     this.tags.set(changeTree, tags);
@@ -4200,7 +3999,7 @@
                 tags.add(tag);
                 // console.log("BY TAG:", tag);
                 // Ref: add tagged properties
-                (_b = (_a = metadata === null || metadata === void 0 ? void 0 : metadata[-3]) === null || _a === void 0 ? void 0 : _a[tag]) === null || _b === void 0 ? void 0 : _b.forEach(function (index) {
+                metadata?.[-3]?.[tag]?.forEach((index) => {
                     if (changeTree.getChange(index) !== exports.OPERATION.DELETE) {
                         changes.set(index, exports.OPERATION.ADD);
                     }
@@ -4214,14 +4013,13 @@
                 //         changes.set(index, OPERATION.ADD);
                 //     }
                 // });
-                var allChangesSet = (changeTree.isFiltered || changeTree.isPartiallyFiltered)
+                const allChangesSet = (changeTree.isFiltered || changeTree.isPartiallyFiltered)
                     ? changeTree.allFilteredChanges
                     : changeTree.allChanges;
-                var it_2 = allChangesSet.keys();
-                var isInvisible = this.invisible.has(changeTree);
-                for (var _i = 0, it_1 = it_2; _i < it_1.length; _i++) {
-                    var index = it_1[_i];
-                    if ((isInvisible || (metadata === null || metadata === void 0 ? void 0 : metadata[metadata === null || metadata === void 0 ? void 0 : metadata[index]].tag) === tag) &&
+                const it = allChangesSet.keys();
+                const isInvisible = this.invisible.has(changeTree);
+                for (const index of it) {
+                    if ((isInvisible || metadata?.[metadata?.[index]].tag === tag) &&
                         changeTree.getChange(index) !== exports.OPERATION.DELETE) {
                         changes.set(index, exports.OPERATION.ADD);
                     }
@@ -4234,14 +4032,14 @@
                 this.items.add(changeTree);
             }
             return this;
-        };
-        StateView.prototype.addParent = function (changeTree, tag) {
-            var parentRef = changeTree.parent;
+        }
+        addParent(changeTree, tag) {
+            const parentRef = changeTree.parent;
             if (!parentRef) {
                 return;
             }
-            var parentChangeTree = parentRef[$changes];
-            var parentIndex = changeTree.parentIndex;
+            const parentChangeTree = parentRef[$changes];
+            const parentIndex = changeTree.parentIndex;
             if (!this.invisible.has(parentChangeTree)) {
                 // parent is already available, no need to add it!
                 return;
@@ -4249,7 +4047,7 @@
             this.addParent(parentChangeTree, tag);
             // add parent's tag properties
             if (parentChangeTree.getChange(parentIndex) !== exports.OPERATION.DELETE) {
-                var parentChanges = this.changes.get(parentChangeTree);
+                let parentChanges = this.changes.get(parentChangeTree);
                 if (parentChanges === undefined) {
                     parentChanges = new Map();
                     this.changes.set(parentChangeTree, parentChanges);
@@ -4265,7 +4063,7 @@
                 if (!this.tags) {
                     this.tags = new WeakMap();
                 }
-                var tags = void 0;
+                let tags;
                 if (!this.tags.has(parentChangeTree)) {
                     tags = new Set();
                     this.tags.set(parentChangeTree, tags);
@@ -4276,51 +4074,46 @@
                 tags.add(tag);
                 parentChanges.set(parentIndex, exports.OPERATION.ADD);
             }
-        };
-        StateView.prototype.remove = function (obj, tag) {
-            if (tag === void 0) { tag = DEFAULT_VIEW_TAG; }
-            var changeTree = obj[$changes];
+        }
+        remove(obj, tag = DEFAULT_VIEW_TAG) {
+            const changeTree = obj[$changes];
             if (!changeTree) {
                 console.warn("StateView#remove(), invalid object:", obj);
                 return this;
             }
             this.items.delete(changeTree);
-            var ref = changeTree.ref;
-            var metadata = ref.constructor[Symbol.metadata];
-            var changes = this.changes.get(changeTree);
+            const ref = changeTree.ref;
+            const metadata = ref.constructor[Symbol.metadata];
+            let changes = this.changes.get(changeTree);
             if (changes === undefined) {
                 changes = new Map();
                 this.changes.set(changeTree, changes);
             }
             if (tag === DEFAULT_VIEW_TAG) {
                 // parent is collection (Map/Array)
-                var parent = changeTree.parent;
+                const parent = changeTree.parent;
                 if (!Metadata.isValidInstance(parent)) {
-                    var parentChangeTree = parent[$changes];
-                    var changes_1 = this.changes.get(parentChangeTree);
-                    if (changes_1 === undefined) {
-                        changes_1 = new Map();
-                        this.changes.set(parentChangeTree, changes_1);
+                    const parentChangeTree = parent[$changes];
+                    let changes = this.changes.get(parentChangeTree);
+                    if (changes === undefined) {
+                        changes = new Map();
+                        this.changes.set(parentChangeTree, changes);
                     }
                     // DELETE / DELETE BY REF ID
-                    changes_1.set(changeTree.parentIndex, exports.OPERATION.DELETE);
+                    changes.set(changeTree.parentIndex, exports.OPERATION.DELETE);
                 }
                 else {
                     // delete all "tagged" properties.
-                    metadata[-2].forEach(function (index) {
-                        return changes.set(index, exports.OPERATION.DELETE);
-                    });
+                    metadata[-2].forEach((index) => changes.set(index, exports.OPERATION.DELETE));
                 }
             }
             else {
                 // delete only tagged properties
-                metadata[-3][tag].forEach(function (index) {
-                    return changes.set(index, exports.OPERATION.DELETE);
-                });
+                metadata[-3][tag].forEach((index) => changes.set(index, exports.OPERATION.DELETE));
             }
             // remove tag
             if (this.tags && this.tags.has(changeTree)) {
-                var tags = this.tags.get(changeTree);
+                const tags = this.tags.get(changeTree);
                 if (tag === undefined) {
                     // delete all tags
                     this.tags.delete(changeTree);
@@ -4335,9 +4128,8 @@
                 }
             }
             return this;
-        };
-        return StateView;
-    }());
+        }
+    }
 
     registerType("map", { constructor: MapSchema });
     registerType("array", { constructor: ArraySchema });