@colyseus/schema 3.0.0-alpha.40 → 3.0.0-alpha.41

package/build/cjs/index.js

@@ -20,8 +20,6 @@ exports.OPERATION = void 0;
     /**
      * ArraySchema operations
      */
-    OPERATION[OPERATION["PUSH"] = 11] = "PUSH";
-    OPERATION[OPERATION["UNSHIFT"] = 12] = "UNSHIFT";
     OPERATION[OPERATION["REVERSE"] = 15] = "REVERSE";
     OPERATION[OPERATION["MOVE"] = 32] = "MOVE";
     OPERATION[OPERATION["DELETE_BY_REFID"] = 33] = "DELETE_BY_REFID";
@@ -63,1055 +61,1283 @@ const $refTypeFieldIndexes = "$__refTypeFieldIndexes";
 const $viewFieldIndexes = "$__viewFieldIndexes";
 const $fieldIndexesByViewTag = "$__fieldIndexesByViewTag";
 
-const registeredTypes = {};
-const identifiers = new Map();
-function registerType(identifier, definition) {
-    identifiers.set(definition.constructor, identifier);
-    registeredTypes[identifier] = definition;
-}
-function getType(identifier) {
-    return registeredTypes[identifier];
+/**
+ * Copyright (c) 2018 Endel Dreyer
+ * Copyright (c) 2014 Ion Drive Software Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE
+ */
+/**
+ * msgpack implementation highly based on notepack.io
+ * https://github.com/darrachequesne/notepack
+ */
+let textEncoder;
+// @ts-ignore
+try {
+    textEncoder = new TextEncoder();
 }
-
-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) {
-            let inherits = TypeContext.inheritedTypes.get(parent);
-            if (!inherits) {
-                inherits = new Set();
-                TypeContext.inheritedTypes.set(parent, inherits);
-            }
-            inherits.add(target);
-        }
-    }
-    constructor(rootClass) {
-        this.types = {};
-        this.schemas = new Map();
-        this.hasFilters = false;
-        this.parentFiltered = {};
-        if (rootClass) {
-            this.discoverTypes(rootClass);
-        }
-    }
-    has(schema) {
-        return this.schemas.has(schema);
-    }
-    get(typeid) {
-        return this.types[typeid];
-    }
-    add(schema, typeid = this.schemas.size) {
-        // skip if already registered
-        if (this.schemas.has(schema)) {
-            return false;
-        }
-        this.types[typeid] = schema;
-        //
-        // Workaround to allow using an empty Schema (with no `@type()` fields)
-        //
-        if (schema[Symbol.metadata] === undefined) {
-            Metadata.initialize(schema);
-        }
-        this.schemas.set(schema, typeid);
-        return true;
-    }
-    getTypeId(klass) {
-        return this.schemas.get(klass);
-    }
-    discoverTypes(klass, parentIndex, parentFieldViewTag) {
-        if (!this.add(klass)) {
-            return;
-        }
-        // add classes inherited from this base class
-        TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
-            this.discoverTypes(child, parentIndex, parentFieldViewTag);
-        });
-        // add parent classes
-        let parent = klass;
-        while ((parent = Object.getPrototypeOf(parent)) &&
-            parent !== Schema && // stop at root (Schema)
-            parent !== Function.prototype // stop at root (non-Schema)
-        ) {
-            this.discoverTypes(parent);
-        }
-        const metadata = (klass[Symbol.metadata] ??= {});
-        // if any schema/field has filters, mark "context" as having filters.
-        if (metadata[$viewFieldIndexes]) {
-            this.hasFilters = true;
-        }
-        if (parentFieldViewTag !== undefined) {
-            this.parentFiltered[`${this.schemas.get(klass)}-${parentIndex}`] = true;
-        }
-        for (const fieldIndex in metadata) {
-            const index = fieldIndex;
-            const fieldType = metadata[index].type;
-            const viewTag = metadata[index].tag;
-            if (typeof (fieldType) === "string") {
-                continue;
+catch (e) { }
+const _convoBuffer$1 = new ArrayBuffer(8);
+const _int32$1 = new Int32Array(_convoBuffer$1);
+const _float32$1 = new Float32Array(_convoBuffer$1);
+const _float64$1 = new Float64Array(_convoBuffer$1);
+const _int64$1 = new BigInt64Array(_convoBuffer$1);
+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;
             }
-            if (Array.isArray(fieldType)) {
-                const type = fieldType[0];
-                // skip primitive types
-                if (type === "string") {
-                    continue;
-                }
-                this.discoverTypes(type, index, viewTag);
+            else if (c < 0x800) {
+                length += 2;
             }
-            else if (typeof (fieldType) === "function") {
-                this.discoverTypes(fieldType, viewTag);
+            else if (c < 0xd800 || c >= 0xe000) {
+                length += 3;
             }
             else {
-                const type = Object.values(fieldType)[0];
-                // skip primitive types
-                if (typeof (type) === "string") {
-                    continue;
-                }
-                this.discoverTypes(type, index, viewTag);
+                i++;
+                length += 4;
             }
         }
-    }
-}
-
-function getNormalizedType(type) {
-    return (Array.isArray(type))
-        ? { array: type[0] }
-        : (typeof (type['type']) !== "undefined")
-            ? type['type']
-            : type;
-}
-const Metadata = {
-    addField(metadata, index, name, type, descriptor) {
-        if (index > 64) {
-            throw new Error(`Can't define field '${name}'.\nSchema instances may only have up to 64 fields.`);
+        return length;
+    };
+function utf8Write(view, str, it) {
+    var c = 0;
+    for (var i = 0, l = str.length; i < l; i++) {
+        c = str.charCodeAt(i);
+        if (c < 0x80) {
+            view[it.offset++] = c;
         }
-        metadata[index] = Object.assign(metadata[index] || {}, // avoid overwriting previous field metadata (@owned / @deprecated)
-        {
-            type: getNormalizedType(type),
-            index,
-            name,
-        });
-        // create "descriptors" map
-        Object.defineProperty(metadata, $descriptors, {
-            value: metadata[$descriptors] || {},
-            enumerable: false,
-            configurable: true,
-        });
-        if (descriptor) {
-            // for encoder
-            metadata[$descriptors][name] = descriptor;
-            metadata[$descriptors][`_${name}`] = {
-                value: undefined,
-                writable: true,
-                enumerable: false,
-                configurable: true,
-            };
+        else if (c < 0x800) {
+            view[it.offset] = 0xc0 | (c >> 6);
+            view[it.offset + 1] = 0x80 | (c & 0x3f);
+            it.offset += 2;
         }
-        else {
-            // for decoder
-            metadata[$descriptors][name] = {
-                value: undefined,
-                writable: true,
-                enumerable: true,
-                configurable: true,
-            };
+        else if (c < 0xd800 || c >= 0xe000) {
+            view[it.offset] = 0xe0 | (c >> 12);
+            view[it.offset + 1] = 0x80 | (c >> 6 & 0x3f);
+            view[it.offset + 2] = 0x80 | (c & 0x3f);
+            it.offset += 3;
         }
-        // map -1 as last field index
-        Object.defineProperty(metadata, $numFields, {
-            value: index,
-            enumerable: false,
-            configurable: true
-        });
-        // map field name => index (non enumerable)
-        Object.defineProperty(metadata, name, {
-            value: index,
-            enumerable: false,
-            configurable: true,
-        });
-        // if child Ref/complex type, add to -4
-        if (typeof (metadata[index].type) !== "string") {
-            if (metadata[$refTypeFieldIndexes] === undefined) {
-                Object.defineProperty(metadata, $refTypeFieldIndexes, {
-                    value: [],
-                    enumerable: false,
-                    configurable: true,
-                });
-            }
-            metadata[$refTypeFieldIndexes].push(index);
+        else {
+            i++;
+            c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
+            view[it.offset] = 0xf0 | (c >> 18);
+            view[it.offset + 1] = 0x80 | (c >> 12 & 0x3f);
+            view[it.offset + 2] = 0x80 | (c >> 6 & 0x3f);
+            view[it.offset + 3] = 0x80 | (c & 0x3f);
+            it.offset += 4;
         }
-    },
-    setTag(metadata, fieldName, tag) {
-        const index = metadata[fieldName];
-        const field = metadata[index];
-        // add 'tag' to the field
-        field.tag = tag;
-        if (!metadata[$viewFieldIndexes]) {
-            // -2: all field indexes with "view" tag
-            Object.defineProperty(metadata, $viewFieldIndexes, {
-                value: [],
-                enumerable: false,
-                configurable: true
-            });
-            // -3: field indexes by "view" tag
-            Object.defineProperty(metadata, $fieldIndexesByViewTag, {
-                value: {},
-                enumerable: false,
-                configurable: true
-            });
+    }
+}
+function int8$1(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
+}
+function uint8$1(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
+}
+function int16$1(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
+    bytes[it.offset++] = (value >> 8) & 255;
+}
+function uint16$1(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
+    bytes[it.offset++] = (value >> 8) & 255;
+}
+function int32$1(bytes, value, it) {
+    bytes[it.offset++] = value & 255;
+    bytes[it.offset++] = (value >> 8) & 255;
+    bytes[it.offset++] = (value >> 16) & 255;
+    bytes[it.offset++] = (value >> 24) & 255;
+}
+function uint32$1(bytes, value, it) {
+    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) {
+    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) {
+    const high = (value / Math.pow(2, 32)) >> 0;
+    const low = value >>> 0;
+    uint32$1(bytes, low, it);
+    uint32$1(bytes, high, it);
+}
+function bigint64$1(bytes, value, it) {
+    _int64$1[0] = BigInt.asIntN(64, value);
+    int32$1(bytes, _int32$1[0], it);
+    int32$1(bytes, _int32$1[1], it);
+}
+function biguint64$1(bytes, value, it) {
+    _int64$1[0] = BigInt.asIntN(64, value);
+    int32$1(bytes, _int32$1[0], it);
+    int32$1(bytes, _int32$1[1], it);
+}
+function float32$1(bytes, value, it) {
+    _float32$1[0] = value;
+    int32$1(bytes, _int32$1[0], it);
+}
+function float64$1(bytes, value, it) {
+    _float64$1[0] = value;
+    int32$1(bytes, _int32$1[0 ], it);
+    int32$1(bytes, _int32$1[1 ], it);
+}
+function boolean$1(bytes, value, it) {
+    bytes[it.offset++] = value ? 1 : 0; // uint8
+}
+function string$1(bytes, value, it) {
+    // encode `null` strings as empty.
+    if (!value) {
+        value = "";
+    }
+    let length = utf8Length(value, "utf8");
+    let size = 0;
+    // fixstr
+    if (length < 0x20) {
+        bytes[it.offset++] = length | 0xa0;
+        size = 1;
+    }
+    // str 8
+    else if (length < 0x100) {
+        bytes[it.offset++] = 0xd9;
+        bytes[it.offset++] = length % 255;
+        size = 2;
+    }
+    // str 16
+    else if (length < 0x10000) {
+        bytes[it.offset++] = 0xda;
+        uint16$1(bytes, length, it);
+        size = 3;
+    }
+    // str 32
+    else if (length < 0x100000000) {
+        bytes[it.offset++] = 0xdb;
+        uint32$1(bytes, length, it);
+        size = 5;
+    }
+    else {
+        throw new Error('String too long');
+    }
+    utf8Write(bytes, value, it);
+    return size + length;
+}
+function number$1(bytes, value, it) {
+    if (isNaN(value)) {
+        return number$1(bytes, 0, it);
+    }
+    else if (!isFinite(value)) {
+        return number$1(bytes, (value > 0) ? Number.MAX_SAFE_INTEGER : -Number.MAX_SAFE_INTEGER, it);
+    }
+    else if (value !== (value | 0)) {
+        if (Math.abs(value) <= 3.4028235e+38) { // range check
+            _float32$1[0] = value;
+            if (Math.abs(Math.abs(_float32$1[0]) - Math.abs(value)) < 1e-4) { // precision check; adjust 1e-n (n = precision) to in-/decrease acceptable precision loss
+                // now we know value is in range for f32 and has acceptable precision for f32
+                bytes[it.offset++] = 0xca;
+                float32$1(bytes, value, it);
+                return 5;
+            }
         }
-        metadata[$viewFieldIndexes].push(index);
-        if (!metadata[$fieldIndexesByViewTag][tag]) {
-            metadata[$fieldIndexesByViewTag][tag] = [];
+        bytes[it.offset++] = 0xcb;
+        float64$1(bytes, value, it);
+        return 9;
+    }
+    if (value >= 0) {
+        // positive fixnum
+        if (value < 0x80) {
+            bytes[it.offset++] = value & 255; // uint8
+            return 1;
         }
-        metadata[$fieldIndexesByViewTag][tag].push(index);
-    },
-    setFields(target, fields) {
-        // for inheritance support
-        const constructor = target.prototype.constructor;
-        TypeContext.register(constructor);
-        const parentClass = Object.getPrototypeOf(constructor);
-        const parentMetadata = parentClass && parentClass[Symbol.metadata];
-        const metadata = Metadata.initialize(constructor);
-        // Use Schema's methods if not defined in the class
-        if (!constructor[$track]) {
-            constructor[$track] = Schema[$track];
+        // uint 8
+        if (value < 0x100) {
+            bytes[it.offset++] = 0xcc;
+            bytes[it.offset++] = value & 255; // uint8
+            return 2;
         }
-        if (!constructor[$encoder]) {
-            constructor[$encoder] = Schema[$encoder];
+        // uint 16
+        if (value < 0x10000) {
+            bytes[it.offset++] = 0xcd;
+            uint16$1(bytes, value, it);
+            return 3;
         }
-        if (!constructor[$decoder]) {
-            constructor[$decoder] = Schema[$decoder];
+        // uint 32
+        if (value < 0x100000000) {
+            bytes[it.offset++] = 0xce;
+            uint32$1(bytes, value, it);
+            return 5;
         }
-        if (!constructor.prototype.toJSON) {
-            constructor.prototype.toJSON = Schema.prototype.toJSON;
+        // uint 64
+        bytes[it.offset++] = 0xcf;
+        uint64$1(bytes, value, it);
+        return 9;
+    }
+    else {
+        // negative fixnum
+        if (value >= -0x20) {
+            bytes[it.offset++] = 0xe0 | (value + 0x20);
+            return 1;
         }
-        //
-        // detect index for this field, considering inheritance
-        //
-        let fieldIndex = metadata[$numFields] // current structure already has fields defined
-            ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
-            ?? -1; // no fields defined
-        fieldIndex++;
-        for (const field in fields) {
-            const type = fields[field];
-            const normalizedType = getNormalizedType(type);
-            // FIXME: this code is duplicated from @type() annotation
-            const complexTypeKlass = (Array.isArray(type))
-                ? getType("array")
-                : (typeof (Object.keys(type)[0]) === "string") && getType(Object.keys(type)[0]);
-            const childType = (complexTypeKlass)
-                ? Object.values(type)[0]
-                : normalizedType;
-            Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass));
-            fieldIndex++;
+        // int 8
+        if (value >= -0x80) {
+            bytes[it.offset++] = 0xd0;
+            int8$1(bytes, value, it);
+            return 2;
         }
-        return target;
-    },
-    isDeprecated(metadata, field) {
-        return metadata[field].deprecated === true;
-    },
-    init(klass) {
-        //
-        // Used only to initialize an empty Schema (Encoder#constructor)
-        // TODO: remove/refactor this...
-        //
-        const metadata = {};
-        klass[Symbol.metadata] = metadata;
-        Object.defineProperty(metadata, $numFields, {
-            value: 0,
-            enumerable: false,
-            configurable: true,
-        });
-    },
-    initialize(constructor) {
-        const parentClass = Object.getPrototypeOf(constructor);
-        const parentMetadata = parentClass[Symbol.metadata];
-        let metadata = constructor[Symbol.metadata] ?? Object.create(null);
-        // make sure inherited classes have their own metadata object.
-        if (parentClass !== Schema && metadata === parentMetadata) {
-            metadata = Object.create(null);
-            if (parentMetadata) {
-                //
-                // assign parent metadata to current
-                //
-                Object.setPrototypeOf(metadata, parentMetadata);
-                // $numFields
-                Object.defineProperty(metadata, $numFields, {
-                    value: parentMetadata[$numFields],
-                    enumerable: false,
-                    configurable: true,
-                    writable: true,
-                });
-                // $viewFieldIndexes / $fieldIndexesByViewTag
-                if (parentMetadata[$viewFieldIndexes] !== undefined) {
-                    Object.defineProperty(metadata, $viewFieldIndexes, {
-                        value: [...parentMetadata[$viewFieldIndexes]],
-                        enumerable: false,
-                        configurable: true,
-                        writable: true,
-                    });
-                    Object.defineProperty(metadata, $fieldIndexesByViewTag, {
-                        value: { ...parentMetadata[$fieldIndexesByViewTag] },
-                        enumerable: false,
-                        configurable: true,
-                        writable: true,
-                    });
-                }
-                // $refTypeFieldIndexes
-                if (parentMetadata[$refTypeFieldIndexes] !== undefined) {
-                    Object.defineProperty(metadata, $refTypeFieldIndexes, {
-                        value: [...parentMetadata[$refTypeFieldIndexes]],
-                        enumerable: false,
-                        configurable: true,
-                        writable: true,
-                    });
-                }
-                // $descriptors
-                Object.defineProperty(metadata, $descriptors, {
-                    value: { ...parentMetadata[$descriptors] },
-                    enumerable: false,
-                    configurable: true,
-                    writable: true,
-                });
-            }
+        // int 16
+        if (value >= -0x8000) {
+            bytes[it.offset++] = 0xd1;
+            int16$1(bytes, value, it);
+            return 3;
         }
-        constructor[Symbol.metadata] = metadata;
-        return metadata;
-    },
-    isValidInstance(klass) {
-        return (klass.constructor[Symbol.metadata] &&
-            Object.prototype.hasOwnProperty.call(klass.constructor[Symbol.metadata], $numFields));
-    },
-    getFields(klass) {
-        const metadata = klass[Symbol.metadata];
-        const fields = {};
-        for (let i = 0; i <= metadata[$numFields]; i++) {
-            fields[metadata[i].name] = metadata[i].type;
+        // int 32
+        if (value >= -0x80000000) {
+            bytes[it.offset++] = 0xd2;
+            int32$1(bytes, value, it);
+            return 5;
         }
-        return fields;
+        // int 64
+        bytes[it.offset++] = 0xd3;
+        int64$1(bytes, value, it);
+        return 9;
+    }
+}
+const encode = {
+    int8: int8$1,
+    uint8: uint8$1,
+    int16: int16$1,
+    uint16: uint16$1,
+    int32: int32$1,
+    uint32: uint32$1,
+    int64: int64$1,
+    uint64: uint64$1,
+    bigint64: bigint64$1,
+    biguint64: biguint64$1,
+    float32: float32$1,
+    float64: float64$1,
+    boolean: boolean$1,
+    string: string$1,
+    number: number$1,
+    utf8Write,
+    utf8Length,
+};
+
+/**
+ * Copyright (c) 2018 Endel Dreyer
+ * Copyright (c) 2014 Ion Drive Software Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE
+ */
+// force little endian to facilitate decoding on multiple implementations
+const _convoBuffer = new ArrayBuffer(8);
+const _int32 = new Int32Array(_convoBuffer);
+const _float32 = new Float32Array(_convoBuffer);
+const _float64 = new Float64Array(_convoBuffer);
+const _uint64 = new BigUint64Array(_convoBuffer);
+const _int64 = new BigInt64Array(_convoBuffer);
+function utf8Read(bytes, it, length) {
+    var string = '', chr = 0;
+    for (var i = it.offset, end = it.offset + length; i < end; i++) {
+        var byte = bytes[i];
+        if ((byte & 0x80) === 0x00) {
+            string += String.fromCharCode(byte);
+            continue;
+        }
+        if ((byte & 0xe0) === 0xc0) {
+            string += String.fromCharCode(((byte & 0x1f) << 6) |
+                (bytes[++i] & 0x3f));
+            continue;
+        }
+        if ((byte & 0xf0) === 0xe0) {
+            string += String.fromCharCode(((byte & 0x0f) << 12) |
+                ((bytes[++i] & 0x3f) << 6) |
+                ((bytes[++i] & 0x3f) << 0));
+            continue;
+        }
+        if ((byte & 0xf8) === 0xf0) {
+            chr = ((byte & 0x07) << 18) |
+                ((bytes[++i] & 0x3f) << 12) |
+                ((bytes[++i] & 0x3f) << 6) |
+                ((bytes[++i] & 0x3f) << 0);
+            if (chr >= 0x010000) { // surrogate pair
+                chr -= 0x010000;
+                string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
+            }
+            else {
+                string += String.fromCharCode(chr);
+            }
+            continue;
+        }
+        console.error('Invalid byte ' + byte.toString(16));
+        // (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) {
+    return uint8(bytes, it) << 24 >> 24;
+}
+function uint8(bytes, it) {
+    return bytes[it.offset++];
+}
+function int16(bytes, it) {
+    return uint16(bytes, it) << 16 >> 16;
+}
+function uint16(bytes, it) {
+    return bytes[it.offset++] | bytes[it.offset++] << 8;
+}
+function int32(bytes, it) {
+    return bytes[it.offset++] | bytes[it.offset++] << 8 | bytes[it.offset++] << 16 | bytes[it.offset++] << 24;
+}
+function uint32(bytes, it) {
+    return int32(bytes, it) >>> 0;
+}
+function float32(bytes, it) {
+    _int32[0] = int32(bytes, it);
+    return _float32[0];
+}
+function float64(bytes, it) {
+    _int32[0 ] = int32(bytes, it);
+    _int32[1 ] = int32(bytes, it);
+    return _float64[0];
+}
+function int64(bytes, it) {
+    const low = uint32(bytes, it);
+    const high = int32(bytes, it) * Math.pow(2, 32);
+    return high + low;
+}
+function uint64(bytes, it) {
+    const low = uint32(bytes, it);
+    const high = uint32(bytes, it) * Math.pow(2, 32);
+    return high + low;
+}
+function bigint64(bytes, it) {
+    _int32[0] = int32(bytes, it);
+    _int32[1] = int32(bytes, it);
+    return _int64[0];
+}
+function biguint64(bytes, it) {
+    _int32[0] = int32(bytes, it);
+    _int32[1] = int32(bytes, it);
+    return _uint64[0];
+}
+function boolean(bytes, it) {
+    return uint8(bytes, it) > 0;
+}
+function string(bytes, it) {
+    const prefix = bytes[it.offset++];
+    let length;
+    if (prefix < 0xc0) {
+        // fixstr
+        length = prefix & 0x1f;
+    }
+    else if (prefix === 0xd9) {
+        length = uint8(bytes, it);
+    }
+    else if (prefix === 0xda) {
+        length = uint16(bytes, it);
+    }
+    else if (prefix === 0xdb) {
+        length = uint32(bytes, it);
+    }
+    return utf8Read(bytes, it, length);
+}
+function number(bytes, it) {
+    const prefix = bytes[it.offset++];
+    if (prefix < 0x80) {
+        // positive fixint
+        return prefix;
     }
-};
-
-function setOperationAtIndex(changeSet, index) {
-    const operationsIndex = changeSet.indexes[index];
-    if (operationsIndex === undefined) {
-        changeSet.indexes[index] = changeSet.operations.push(index) - 1;
+    else if (prefix === 0xca) {
+        // float 32
+        return float32(bytes, it);
     }
-    else {
-        changeSet.operations[operationsIndex] = index;
+    else if (prefix === 0xcb) {
+        // float 64
+        return float64(bytes, it);
     }
-}
-function deleteOperationAtIndex(changeSet, index) {
-    const operationsIndex = changeSet.indexes[index];
-    if (operationsIndex !== undefined) {
-        changeSet.operations[operationsIndex] = undefined;
+    else if (prefix === 0xcc) {
+        // uint 8
+        return uint8(bytes, it);
     }
-    delete changeSet.indexes[index];
-}
-function enqueueChangeTree(root, changeTree, changeSet, queueRootIndex = changeTree[changeSet].queueRootIndex) {
-    if (root && root[changeSet][queueRootIndex] !== changeTree) {
-        changeTree[changeSet].queueRootIndex = root[changeSet].push(changeTree) - 1;
+    else if (prefix === 0xcd) {
+        // uint 16
+        return uint16(bytes, it);
     }
-}
-class ChangeTree {
-    constructor(ref) {
-        this.isFiltered = false;
-        this.isPartiallyFiltered = false;
-        this.indexedOperations = {};
-        //
-        // TODO:
-        //   try storing the index + operation per item.
-        //   example: 1024 & 1025 => ADD, 1026 => DELETE
-        //
-        // => https://chatgpt.com/share/67107d0c-bc20-8004-8583-83b17dd7c196
-        //
-        this.changes = { indexes: {}, operations: [] };
-        this.allChanges = { indexes: {}, operations: [] };
-        /**
-         * Is this a new instance? Used on ArraySchema to determine OPERATION.MOVE_AND_ADD operation.
-         */
-        this.isNew = true;
-        this.ref = ref;
-        //
-        // Does this structure have "filters" declared?
-        //
-        if (ref.constructor[Symbol.metadata]?.[$viewFieldIndexes]) {
-            this.allFilteredChanges = { indexes: {}, operations: [] };
-            this.filteredChanges = { indexes: {}, operations: [] };
-        }
+    else if (prefix === 0xce) {
+        // uint 32
+        return uint32(bytes, it);
     }
-    setRoot(root) {
-        this.root = root;
-        const isNewChangeTree = this.root.add(this);
-        const metadata = this.ref.constructor[Symbol.metadata];
-        if (this.root.types.hasFilters) {
-            //
-            // At Schema initialization, the "root" structure might not be available
-            // yet, as it only does once the "Encoder" has been set up.
-            //
-            // So the "parent" may be already set without a "root".
-            //
-            this.checkIsFiltered(metadata, this.parent, this.parentIndex);
-            if (this.isFiltered || this.isPartiallyFiltered) {
-                enqueueChangeTree(root, this, 'filteredChanges');
-                if (isNewChangeTree) {
-                    this.root.allFilteredChanges.push(this);
-                }
-            }
-        }
-        if (!this.isFiltered) {
-            enqueueChangeTree(root, this, 'changes');
-            if (isNewChangeTree) {
-                this.root.allChanges.push(this);
-            }
-        }
-        // Recursively set root on child structures
-        if (metadata) {
-            metadata[$refTypeFieldIndexes]?.forEach((index) => {
-                const field = metadata[index];
-                const value = this.ref[field.name];
-                value?.[$changes].setRoot(root);
-            });
-        }
-        else if (this.ref[$childType] && typeof (this.ref[$childType]) !== "string") {
-            // MapSchema / ArraySchema, etc.
-            this.ref.forEach((value, key) => {
-                value[$changes].setRoot(root);
-            });
-        }
+    else if (prefix === 0xcf) {
+        // uint 64
+        return uint64(bytes, it);
     }
-    setParent(parent, root, parentIndex) {
-        this.parent = parent;
-        this.parentIndex = parentIndex;
-        // avoid setting parents with empty `root`
-        if (!root) {
-            return;
-        }
-        const metadata = this.ref.constructor[Symbol.metadata];
-        // skip if parent is already set
-        if (root !== this.root) {
-            this.root = root;
-            const isNewChangeTree = root.add(this);
-            if (root.types.hasFilters) {
-                this.checkIsFiltered(metadata, parent, parentIndex);
-                if (this.isFiltered || this.isPartiallyFiltered) {
-                    enqueueChangeTree(root, this, 'filteredChanges');
-                    if (isNewChangeTree) {
-                        this.root.allFilteredChanges.push(this);
-                    }
-                }
-            }
-            if (!this.isFiltered) {
-                enqueueChangeTree(root, this, 'changes');
-                if (isNewChangeTree) {
-                    this.root.allChanges.push(this);
-                }
-            }
-        }
-        else {
-            root.add(this);
-        }
-        // assign same parent on child structures
-        if (metadata) {
-            metadata[$refTypeFieldIndexes]?.forEach((index) => {
-                const field = metadata[index];
-                const value = this.ref[field.name];
-                value?.[$changes].setParent(this.ref, root, index);
-                // try { throw new Error(); } catch (e) {
-                //     console.log(e.stack);
-                // }
-            });
-        }
-        else if (this.ref[$childType] && typeof (this.ref[$childType]) !== "string") {
-            // MapSchema / ArraySchema, etc.
-            this.ref.forEach((value, key) => {
-                value[$changes].setParent(this.ref, root, this.indexes[key] ?? key);
-            });
-        }
+    else if (prefix === 0xd0) {
+        // int 8
+        return int8(bytes, it);
     }
-    forEachChild(callback) {
-        //
-        // assign same parent on child structures
-        //
-        const metadata = this.ref.constructor[Symbol.metadata];
-        if (metadata) {
-            metadata[$refTypeFieldIndexes]?.forEach((index) => {
-                const field = metadata[index];
-                const value = this.ref[field.name];
-                if (value) {
-                    callback(value[$changes], index);
-                }
-            });
-        }
-        else if (this.ref[$childType] && typeof (this.ref[$childType]) !== "string") {
-            // MapSchema / ArraySchema, etc.
-            this.ref.forEach((value, key) => {
-                callback(value[$changes], this.indexes[key] ?? key);
-            });
-        }
+    else if (prefix === 0xd1) {
+        // int 16
+        return int16(bytes, it);
     }
-    operation(op) {
-        // operations without index use negative values to represent them
-        // this is checked during .encode() time.
-        this.changes.operations.push(-op);
-        enqueueChangeTree(this.root, this, 'changes');
+    else if (prefix === 0xd2) {
+        // int 32
+        return int32(bytes, it);
     }
-    change(index, operation = exports.OPERATION.ADD) {
-        const metadata = this.ref.constructor[Symbol.metadata];
-        const isFiltered = this.isFiltered || (metadata?.[index]?.tag !== undefined);
-        const changeSet = (isFiltered)
-            ? this.filteredChanges
-            : this.changes;
-        const previousOperation = this.indexedOperations[index];
-        if (!previousOperation || previousOperation === exports.OPERATION.DELETE) {
-            const op = (!previousOperation)
-                ? operation
-                : (previousOperation === exports.OPERATION.DELETE)
-                    ? exports.OPERATION.DELETE_AND_ADD
-                    : operation;
-            //
-            // TODO: are DELETE operations being encoded as ADD here ??
-            //
-            this.indexedOperations[index] = op;
-        }
-        setOperationAtIndex(changeSet, index);
-        if (isFiltered) {
-            setOperationAtIndex(this.allFilteredChanges, index);
-            if (this.root) {
-                enqueueChangeTree(this.root, this, 'filteredChanges');
-                enqueueChangeTree(this.root, this, 'allFilteredChanges');
+    else if (prefix === 0xd3) {
+        // int 64
+        return int64(bytes, it);
+    }
+    else if (prefix > 0xdf) {
+        // negative fixint
+        return (0xff - prefix + 1) * -1;
+    }
+}
+const decode = {
+    utf8Read,
+    int8,
+    uint8,
+    int16,
+    uint16,
+    int32,
+    uint32,
+    float32,
+    float64,
+    int64,
+    uint64,
+    bigint64,
+    biguint64,
+    boolean,
+    string,
+    number,
+};
+
+const registeredTypes = {};
+const identifiers = new Map();
+function registerType(identifier, definition) {
+    if (definition.constructor) {
+        identifiers.set(definition.constructor, identifier);
+        registeredTypes[identifier] = definition;
+    }
+    if (definition.encode) {
+        encode[identifier] = definition.encode;
+    }
+    if (definition.decode) {
+        decode[identifier] = definition.decode;
+    }
+}
+function getType(identifier) {
+    return registeredTypes[identifier];
+}
+function defineCustomTypes(types) {
+    for (const identifier in types) {
+        registerType(identifier, types[identifier]);
+    }
+    return (t) => type(t);
+}
+
+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) {
+            let inherits = TypeContext.inheritedTypes.get(parent);
+            if (!inherits) {
+                inherits = new Set();
+                TypeContext.inheritedTypes.set(parent, inherits);
             }
+            inherits.add(target);
         }
-        else {
-            setOperationAtIndex(this.allChanges, index);
-            enqueueChangeTree(this.root, this, 'changes');
+    }
+    constructor(rootClass) {
+        this.types = {};
+        this.schemas = new Map();
+        this.hasFilters = false;
+        this.parentFiltered = {};
+        if (rootClass) {
+            this.discoverTypes(rootClass);
         }
     }
-    shiftChangeIndexes(shiftIndex) {
-        //
-        // Used only during:
+    has(schema) {
+        return this.schemas.has(schema);
+    }
+    get(typeid) {
+        return this.types[typeid];
+    }
+    add(schema, typeid = this.schemas.size) {
+        // skip if already registered
+        if (this.schemas.has(schema)) {
+            return false;
+        }
+        this.types[typeid] = schema;
         //
-        // - ArraySchema#unshift()
+        // Workaround to allow using an empty Schema (with no `@type()` fields)
         //
-        const changeSet = (this.isFiltered)
-            ? this.filteredChanges
-            : this.changes;
-        const newIndexedOperations = {};
-        const newIndexes = {};
-        for (const index in this.indexedOperations) {
-            newIndexedOperations[Number(index) + shiftIndex] = this.indexedOperations[index];
-            newIndexes[Number(index) + shiftIndex] = changeSet[index];
+        if (schema[Symbol.metadata] === undefined) {
+            Metadata.initialize(schema);
         }
-        this.indexedOperations = newIndexedOperations;
-        changeSet.indexes = newIndexes;
-        changeSet.operations = changeSet.operations.map((index) => index + shiftIndex);
+        this.schemas.set(schema, typeid);
+        return true;
     }
-    shiftAllChangeIndexes(shiftIndex, startIndex = 0) {
-        //
-        // Used only during:
-        //
-        // - ArraySchema#splice()
-        //
-        if (this.isFiltered || this.isPartiallyFiltered) {
-            this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allFilteredChanges);
-            this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
+    getTypeId(klass) {
+        return this.schemas.get(klass);
+    }
+    discoverTypes(klass, parentIndex, parentFieldViewTag) {
+        if (!this.add(klass)) {
+            return;
         }
-        else {
-            this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
+        // add classes inherited from this base class
+        TypeContext.inheritedTypes.get(klass)?.forEach((child) => {
+            this.discoverTypes(child, parentIndex, parentFieldViewTag);
+        });
+        // add parent classes
+        let parent = klass;
+        while ((parent = Object.getPrototypeOf(parent)) &&
+            parent !== Schema && // stop at root (Schema)
+            parent !== Function.prototype // stop at root (non-Schema)
+        ) {
+            this.discoverTypes(parent);
         }
-    }
-    _shiftAllChangeIndexes(shiftIndex, startIndex = 0, changeSet) {
-        const newIndexes = {};
-        for (const key in changeSet.indexes) {
-            const index = changeSet.indexes[key];
-            if (index > startIndex) {
-                newIndexes[Number(key) + shiftIndex] = index;
+        const metadata = (klass[Symbol.metadata] ??= {});
+        // if any schema/field has filters, mark "context" as having filters.
+        if (metadata[$viewFieldIndexes]) {
+            this.hasFilters = true;
+        }
+        if (parentFieldViewTag !== undefined) {
+            this.parentFiltered[`${this.schemas.get(klass)}-${parentIndex}`] = true;
+        }
+        for (const fieldIndex in metadata) {
+            const index = fieldIndex;
+            const fieldType = metadata[index].type;
+            const viewTag = metadata[index].tag;
+            if (typeof (fieldType) === "string") {
+                continue;
             }
-            else {
-                newIndexes[key] = index;
+            if (Array.isArray(fieldType)) {
+                const type = fieldType[0];
+                // skip primitive types
+                if (type === "string") {
+                    continue;
+                }
+                this.discoverTypes(type, index, viewTag);
             }
-        }
-        changeSet.indexes = newIndexes;
-        for (let i = 0; i < changeSet.operations.length; i++) {
-            const index = changeSet.operations[i];
-            if (index > startIndex) {
-                changeSet.operations[i] = index + shiftIndex;
+            else if (typeof (fieldType) === "function") {
+                this.discoverTypes(fieldType, viewTag);
+            }
+            else {
+                const type = Object.values(fieldType)[0];
+                // skip primitive types
+                if (typeof (type) === "string") {
+                    continue;
+                }
+                this.discoverTypes(type, index, viewTag);
             }
         }
     }
-    indexedOperation(index, operation, allChangesIndex = index) {
-        this.indexedOperations[index] = operation;
-        if (this.filteredChanges) {
-            setOperationAtIndex(this.allFilteredChanges, allChangesIndex);
-            setOperationAtIndex(this.filteredChanges, index);
-            enqueueChangeTree(this.root, this, 'filteredChanges');
-        }
-        else {
-            setOperationAtIndex(this.allChanges, allChangesIndex);
-            setOperationAtIndex(this.changes, index);
-            enqueueChangeTree(this.root, this, 'changes');
+}
+
+function getNormalizedType(type) {
+    return (Array.isArray(type))
+        ? { array: type[0] }
+        : (typeof (type['type']) !== "undefined")
+            ? type['type']
+            : type;
+}
+const Metadata = {
+    addField(metadata, index, name, type, descriptor) {
+        if (index > 64) {
+            throw new Error(`Can't define field '${name}'.\nSchema instances may only have up to 64 fields.`);
         }
-    }
-    getType(index) {
-        if (Metadata.isValidInstance(this.ref)) {
-            const metadata = this.ref.constructor[Symbol.metadata];
-            return metadata[index].type;
+        metadata[index] = Object.assign(metadata[index] || {}, // avoid overwriting previous field metadata (@owned / @deprecated)
+        {
+            type: getNormalizedType(type),
+            index,
+            name,
+        });
+        // create "descriptors" map
+        Object.defineProperty(metadata, $descriptors, {
+            value: metadata[$descriptors] || {},
+            enumerable: false,
+            configurable: true,
+        });
+        if (descriptor) {
+            // for encoder
+            metadata[$descriptors][name] = descriptor;
+            metadata[$descriptors][`_${name}`] = {
+                value: undefined,
+                writable: true,
+                enumerable: false,
+                configurable: true,
+            };
         }
         else {
-            //
-            // Get the child type from parent structure.
-            // - ["string"] => "string"
-            // - { map: "string" } => "string"
-            // - { set: "string" } => "string"
-            //
-            return this.ref[$childType];
+            // for decoder
+            metadata[$descriptors][name] = {
+                value: undefined,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            };
         }
-    }
-    getChange(index) {
-        return this.indexedOperations[index];
-    }
-    //
-    // used during `.encode()`
-    //
-    getValue(index, isEncodeAll = false) {
-        //
-        // `isEncodeAll` param is only used by ArraySchema
-        //
-        return this.ref[$getByIndex](index, isEncodeAll);
-    }
-    delete(index, operation, allChangesIndex = index) {
-        if (index === undefined) {
-            try {
-                throw new Error(`@colyseus/schema ${this.ref.constructor.name}: trying to delete non-existing index '${index}'`);
-            }
-            catch (e) {
-                console.warn(e);
+        // map -1 as last field index
+        Object.defineProperty(metadata, $numFields, {
+            value: index,
+            enumerable: false,
+            configurable: true
+        });
+        // map field name => index (non enumerable)
+        Object.defineProperty(metadata, name, {
+            value: index,
+            enumerable: false,
+            configurable: true,
+        });
+        // if child Ref/complex type, add to -4
+        if (typeof (metadata[index].type) !== "string") {
+            if (metadata[$refTypeFieldIndexes] === undefined) {
+                Object.defineProperty(metadata, $refTypeFieldIndexes, {
+                    value: [],
+                    enumerable: false,
+                    configurable: true,
+                });
             }
-            return;
+            metadata[$refTypeFieldIndexes].push(index);
         }
-        const changeSet = (this.filteredChanges)
-            ? this.filteredChanges
-            : this.changes;
-        this.indexedOperations[index] = operation ?? exports.OPERATION.DELETE;
-        setOperationAtIndex(changeSet, index);
-        const previousValue = this.getValue(index);
-        // remove `root` reference
-        if (previousValue && previousValue[$changes]) {
-            //
-            // FIXME: this.root is "undefined"
-            //
-            // This method is being called at decoding time when a DELETE operation is found.
-            //
-            // - This is due to using the concrete Schema class at decoding time.
-            // - "Reflected" structures do not have this problem.
-            //
-            // (the property descriptors should NOT be used at decoding time. only at encoding time.)
-            //
-            this.root?.remove(previousValue[$changes]);
+    },
+    setTag(metadata, fieldName, tag) {
+        const index = metadata[fieldName];
+        const field = metadata[index];
+        // add 'tag' to the field
+        field.tag = tag;
+        if (!metadata[$viewFieldIndexes]) {
+            // -2: all field indexes with "view" tag
+            Object.defineProperty(metadata, $viewFieldIndexes, {
+                value: [],
+                enumerable: false,
+                configurable: true
+            });
+            // -3: field indexes by "view" tag
+            Object.defineProperty(metadata, $fieldIndexesByViewTag, {
+                value: {},
+                enumerable: false,
+                configurable: true
+            });
+        }
+        metadata[$viewFieldIndexes].push(index);
+        if (!metadata[$fieldIndexesByViewTag][tag]) {
+            metadata[$fieldIndexesByViewTag][tag] = [];
+        }
+        metadata[$fieldIndexesByViewTag][tag].push(index);
+    },
+    setFields(target, fields) {
+        // for inheritance support
+        const constructor = target.prototype.constructor;
+        TypeContext.register(constructor);
+        const parentClass = Object.getPrototypeOf(constructor);
+        const parentMetadata = parentClass && parentClass[Symbol.metadata];
+        const metadata = Metadata.initialize(constructor);
+        // Use Schema's methods if not defined in the class
+        if (!constructor[$track]) {
+            constructor[$track] = Schema[$track];
         }
-        //
-        // FIXME: this is looking a ugly and repeated
-        //
-        if (this.filteredChanges) {
-            deleteOperationAtIndex(this.allFilteredChanges, allChangesIndex);
-            enqueueChangeTree(this.root, this, 'filteredChanges');
+        if (!constructor[$encoder]) {
+            constructor[$encoder] = Schema[$encoder];
         }
-        else {
-            deleteOperationAtIndex(this.allChanges, allChangesIndex);
-            enqueueChangeTree(this.root, this, 'changes');
+        if (!constructor[$decoder]) {
+            constructor[$decoder] = Schema[$decoder];
+        }
+        if (!constructor.prototype.toJSON) {
+            constructor.prototype.toJSON = Schema.prototype.toJSON;
         }
-    }
-    endEncode() {
-        this.indexedOperations = {};
-        // // clear changes
-        // this.changes.indexes = {};
-        // this.changes.operations.length = 0;
-        // ArraySchema and MapSchema have a custom "encode end" method
-        this.ref[$onEncodeEnd]?.();
-        // Not a new instance anymore
-        this.isNew = 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.
+        // detect index for this field, considering inheritance
         //
-        this.ref[$onEncodeEnd]?.();
-        this.indexedOperations = {};
-        this.changes.indexes = {};
-        this.changes.operations.length = 0;
-        this.changes.queueRootIndex = undefined;
-        if (this.filteredChanges !== undefined) {
-            this.filteredChanges.indexes = {};
-            this.filteredChanges.operations.length = 0;
-            this.filteredChanges.queueRootIndex = undefined;
+        let fieldIndex = metadata[$numFields] // current structure already has fields defined
+            ?? (parentMetadata && parentMetadata[$numFields]) // parent structure has fields defined
+            ?? -1; // no fields defined
+        fieldIndex++;
+        for (const field in fields) {
+            const type = fields[field];
+            const normalizedType = getNormalizedType(type);
+            // FIXME: this code is duplicated from @type() annotation
+            const complexTypeKlass = (Array.isArray(type))
+                ? getType("array")
+                : (typeof (Object.keys(type)[0]) === "string") && getType(Object.keys(type)[0]);
+            const childType = (complexTypeKlass)
+                ? Object.values(type)[0]
+                : normalizedType;
+            Metadata.addField(metadata, fieldIndex, field, type, getPropertyDescriptor(`_${field}`, fieldIndex, childType, complexTypeKlass));
+            fieldIndex++;
         }
-        if (discardAll) {
-            this.allChanges.indexes = {};
-            this.allChanges.operations.length = 0;
-            if (this.allFilteredChanges !== undefined) {
-                this.allFilteredChanges.indexes = {};
-                this.allFilteredChanges.operations.length = 0;
+        return target;
+    },
+    isDeprecated(metadata, field) {
+        return metadata[field].deprecated === true;
+    },
+    init(klass) {
+        //
+        // Used only to initialize an empty Schema (Encoder#constructor)
+        // TODO: remove/refactor this...
+        //
+        const metadata = {};
+        klass[Symbol.metadata] = metadata;
+        Object.defineProperty(metadata, $numFields, {
+            value: 0,
+            enumerable: false,
+            configurable: true,
+        });
+    },
+    initialize(constructor) {
+        const parentClass = Object.getPrototypeOf(constructor);
+        const parentMetadata = parentClass[Symbol.metadata];
+        let metadata = constructor[Symbol.metadata] ?? Object.create(null);
+        // make sure inherited classes have their own metadata object.
+        if (parentClass !== Schema && metadata === parentMetadata) {
+            metadata = Object.create(null);
+            if (parentMetadata) {
+                //
+                // assign parent metadata to current
+                //
+                Object.setPrototypeOf(metadata, parentMetadata);
+                // $numFields
+                Object.defineProperty(metadata, $numFields, {
+                    value: parentMetadata[$numFields],
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
+                // $viewFieldIndexes / $fieldIndexesByViewTag
+                if (parentMetadata[$viewFieldIndexes] !== undefined) {
+                    Object.defineProperty(metadata, $viewFieldIndexes, {
+                        value: [...parentMetadata[$viewFieldIndexes]],
+                        enumerable: false,
+                        configurable: true,
+                        writable: true,
+                    });
+                    Object.defineProperty(metadata, $fieldIndexesByViewTag, {
+                        value: { ...parentMetadata[$fieldIndexesByViewTag] },
+                        enumerable: false,
+                        configurable: true,
+                        writable: true,
+                    });
+                }
+                // $refTypeFieldIndexes
+                if (parentMetadata[$refTypeFieldIndexes] !== undefined) {
+                    Object.defineProperty(metadata, $refTypeFieldIndexes, {
+                        value: [...parentMetadata[$refTypeFieldIndexes]],
+                        enumerable: false,
+                        configurable: true,
+                        writable: true,
+                    });
+                }
+                // $descriptors
+                Object.defineProperty(metadata, $descriptors, {
+                    value: { ...parentMetadata[$descriptors] },
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                });
             }
-            // remove children references
-            this.forEachChild((changeTree, _) => this.root?.remove(changeTree));
         }
-    }
-    /**
-     * Recursively discard all changes from this, and child structures.
-     */
-    discardAll() {
-        const keys = Object.keys(this.indexedOperations);
-        for (let i = 0, len = keys.length; i < len; i++) {
-            const value = this.getValue(Number(keys[i]));
-            if (value && value[$changes]) {
-                value[$changes].discardAll();
-            }
+        constructor[Symbol.metadata] = metadata;
+        return metadata;
+    },
+    isValidInstance(klass) {
+        return (klass.constructor[Symbol.metadata] &&
+            Object.prototype.hasOwnProperty.call(klass.constructor[Symbol.metadata], $numFields));
+    },
+    getFields(klass) {
+        const metadata = klass[Symbol.metadata];
+        const fields = {};
+        for (let i = 0; i <= metadata[$numFields]; i++) {
+            fields[metadata[i].name] = metadata[i].type;
         }
-        this.discard();
+        return fields;
     }
-    ensureRefId() {
-        // skip if refId is already set.
-        if (this.refId !== undefined) {
-            return;
-        }
-        this.refId = this.root.getNextUniqueId();
+};
+
+function setOperationAtIndex(changeSet, index) {
+    const operationsIndex = changeSet.indexes[index];
+    if (operationsIndex === undefined) {
+        changeSet.indexes[index] = changeSet.operations.push(index) - 1;
     }
-    get changed() {
-        return (Object.entries(this.indexedOperations).length > 0);
+    else {
+        changeSet.operations[operationsIndex] = index;
     }
-    checkIsFiltered(metadata, parent, parentIndex) {
-        // Detect if current structure has "filters" declared
-        this.isPartiallyFiltered = metadata?.[$viewFieldIndexes] !== undefined;
-        if (this.isPartiallyFiltered) {
-            this.filteredChanges = this.filteredChanges || { indexes: {}, operations: [] };
-            this.allFilteredChanges = this.allFilteredChanges || { indexes: {}, operations: [] };
-        }
-        // skip if parent is not set
-        if (!parent) {
-            return;
-        }
-        if (!Metadata.isValidInstance(parent)) {
-            const parentChangeTree = parent[$changes];
-            parent = parentChangeTree.parent;
-            parentIndex = parentChangeTree.parentIndex;
-        }
-        const parentMetadata = parent.constructor?.[Symbol.metadata];
-        this.isFiltered = parentMetadata?.[$viewFieldIndexes]?.includes(parentIndex);
+}
+function deleteOperationAtIndex(changeSet, index) {
+    const operationsIndex = changeSet.indexes[index];
+    if (operationsIndex !== undefined) {
+        changeSet.operations[operationsIndex] = undefined;
+    }
+    delete changeSet.indexes[index];
+}
+function enqueueChangeTree(root, changeTree, changeSet, queueRootIndex = changeTree[changeSet].queueRootIndex) {
+    if (root && root[changeSet][queueRootIndex] !== changeTree) {
+        changeTree[changeSet].queueRootIndex = root[changeSet].push(changeTree) - 1;
+    }
+}
+class ChangeTree {
+    constructor(ref) {
+        this.isFiltered = false;
+        this.isPartiallyFiltered = false;
+        this.indexedOperations = {};
         //
-        // TODO: refactor this!
+        // TODO:
+        //   try storing the index + operation per item.
+        //   example: 1024 & 1025 => ADD, 1026 => DELETE
         //
-        //      swapping `changes` and `filteredChanges` is required here
-        //      because "isFiltered" may not be imedialely available on `change()`
+        // => https://chatgpt.com/share/67107d0c-bc20-8004-8583-83b17dd7c196
         //
-        if (this.isFiltered) {
-            this.filteredChanges = { indexes: {}, operations: [] };
+        this.changes = { indexes: {}, operations: [] };
+        this.allChanges = { indexes: {}, operations: [] };
+        /**
+         * Is this a new instance? Used on ArraySchema to determine OPERATION.MOVE_AND_ADD operation.
+         */
+        this.isNew = true;
+        this.ref = ref;
+        //
+        // Does this structure have "filters" declared?
+        //
+        if (ref.constructor[Symbol.metadata]?.[$viewFieldIndexes]) {
             this.allFilteredChanges = { indexes: {}, operations: [] };
-            if (this.changes.operations.length > 0) {
-                // swap changes reference
-                const changes = this.changes;
-                this.changes = this.filteredChanges;
-                this.filteredChanges = changes;
-                // swap "all changes" reference
-                const allFilteredChanges = this.allFilteredChanges;
-                this.allFilteredChanges = this.allChanges;
-                this.allChanges = allFilteredChanges;
-                // console.log("SWAP =>", {
-                //     "this.allFilteredChanges": this.allFilteredChanges,
-                //     "this.allChanges": this.allChanges
-                // })
-            }
+            this.filteredChanges = { indexes: {}, operations: [] };
         }
     }
-}
-
-/**
- * Copyright (c) 2018 Endel Dreyer
- * Copyright (c) 2014 Ion Drive Software Ltd.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE
- */
-/**
- * msgpack implementation highly based on notepack.io
- * https://github.com/darrachequesne/notepack
- */
-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;
+    setRoot(root) {
+        this.root = root;
+        const isNewChangeTree = this.root.add(this);
+        const metadata = this.ref.constructor[Symbol.metadata];
+        if (this.root.types.hasFilters) {
+            //
+            // At Schema initialization, the "root" structure might not be available
+            // yet, as it only does once the "Encoder" has been set up.
+            //
+            // So the "parent" may be already set without a "root".
+            //
+            this.checkIsFiltered(metadata, this.parent, this.parentIndex);
+            if (this.isFiltered || this.isPartiallyFiltered) {
+                enqueueChangeTree(root, this, 'filteredChanges');
+                if (isNewChangeTree) {
+                    this.root.allFilteredChanges.push(this);
+                }
             }
-            else if (c < 0x800) {
-                length += 2;
+        }
+        if (!this.isFiltered) {
+            enqueueChangeTree(root, this, 'changes');
+            if (isNewChangeTree) {
+                this.root.allChanges.push(this);
             }
-            else if (c < 0xd800 || c >= 0xe000) {
-                length += 3;
+        }
+        // Recursively set root on child structures
+        if (metadata) {
+            metadata[$refTypeFieldIndexes]?.forEach((index) => {
+                const field = metadata[index];
+                const value = this.ref[field.name];
+                value?.[$changes].setRoot(root);
+            });
+        }
+        else if (this.ref[$childType] && typeof (this.ref[$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            this.ref.forEach((value, key) => {
+                value[$changes].setRoot(root);
+            });
+        }
+    }
+    setParent(parent, root, parentIndex) {
+        this.parent = parent;
+        this.parentIndex = parentIndex;
+        // avoid setting parents with empty `root`
+        if (!root) {
+            return;
+        }
+        const metadata = this.ref.constructor[Symbol.metadata];
+        // skip if parent is already set
+        if (root !== this.root) {
+            this.root = root;
+            const isNewChangeTree = root.add(this);
+            if (root.types.hasFilters) {
+                this.checkIsFiltered(metadata, parent, parentIndex);
+                if (this.isFiltered || this.isPartiallyFiltered) {
+                    enqueueChangeTree(root, this, 'filteredChanges');
+                    if (isNewChangeTree) {
+                        this.root.allFilteredChanges.push(this);
+                    }
+                }
             }
-            else {
-                i++;
-                length += 4;
+            if (!this.isFiltered) {
+                enqueueChangeTree(root, this, 'changes');
+                if (isNewChangeTree) {
+                    this.root.allChanges.push(this);
+                }
             }
         }
-        return length;
-    };
-function utf8Write(view, str, it) {
-    var c = 0;
-    for (var i = 0, l = str.length; i < l; i++) {
-        c = str.charCodeAt(i);
-        if (c < 0x80) {
-            view[it.offset++] = c;
+        else {
+            root.add(this);
         }
-        else if (c < 0x800) {
-            view[it.offset] = 0xc0 | (c >> 6);
-            view[it.offset + 1] = 0x80 | (c & 0x3f);
-            it.offset += 2;
+        // assign same parent on child structures
+        if (metadata) {
+            metadata[$refTypeFieldIndexes]?.forEach((index) => {
+                const field = metadata[index];
+                const value = this.ref[field.name];
+                value?.[$changes].setParent(this.ref, root, index);
+                // try { throw new Error(); } catch (e) {
+                //     console.log(e.stack);
+                // }
+            });
         }
-        else if (c < 0xd800 || c >= 0xe000) {
-            view[it.offset] = 0xe0 | (c >> 12);
-            view[it.offset + 1] = 0x80 | (c >> 6 & 0x3f);
-            view[it.offset + 2] = 0x80 | (c & 0x3f);
-            it.offset += 3;
+        else if (this.ref[$childType] && typeof (this.ref[$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            this.ref.forEach((value, key) => {
+                value[$changes].setParent(this.ref, root, this.indexes[key] ?? key);
+            });
         }
-        else {
-            i++;
-            c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
-            view[it.offset] = 0xf0 | (c >> 18);
-            view[it.offset + 1] = 0x80 | (c >> 12 & 0x3f);
-            view[it.offset + 2] = 0x80 | (c >> 6 & 0x3f);
-            view[it.offset + 3] = 0x80 | (c & 0x3f);
-            it.offset += 4;
+    }
+    forEachChild(callback) {
+        //
+        // assign same parent on child structures
+        //
+        const metadata = this.ref.constructor[Symbol.metadata];
+        if (metadata) {
+            metadata[$refTypeFieldIndexes]?.forEach((index) => {
+                const field = metadata[index];
+                const value = this.ref[field.name];
+                if (value) {
+                    callback(value[$changes], index);
+                }
+            });
+        }
+        else if (this.ref[$childType] && typeof (this.ref[$childType]) !== "string") {
+            // MapSchema / ArraySchema, etc.
+            this.ref.forEach((value, key) => {
+                callback(value[$changes], this.indexes[key] ?? key);
+            });
         }
     }
-}
-function int8$1(bytes, value, it) {
-    bytes[it.offset++] = value & 255;
-}
-function uint8$1(bytes, value, it) {
-    bytes[it.offset++] = value & 255;
-}
-function int16$1(bytes, value, it) {
-    bytes[it.offset++] = value & 255;
-    bytes[it.offset++] = (value >> 8) & 255;
-}
-function uint16$1(bytes, value, it) {
-    bytes[it.offset++] = value & 255;
-    bytes[it.offset++] = (value >> 8) & 255;
-}
-function int32$1(bytes, value, it) {
-    bytes[it.offset++] = value & 255;
-    bytes[it.offset++] = (value >> 8) & 255;
-    bytes[it.offset++] = (value >> 16) & 255;
-    bytes[it.offset++] = (value >> 24) & 255;
-}
-function uint32$1(bytes, value, it) {
-    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) {
-    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) {
-    const high = (value / Math.pow(2, 32)) >> 0;
-    const low = value >>> 0;
-    uint32$1(bytes, low, it);
-    uint32$1(bytes, high, it);
-}
-function float32$1(bytes, value, it) {
-    writeFloat32(bytes, value, it);
-}
-function float64$1(bytes, value, it) {
-    writeFloat64(bytes, value, it);
-}
-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);
-}
-function writeFloat64(bytes, value, it) {
-    _float64$1[0] = value;
-    int32$1(bytes, _int32$1[0 ], it);
-    int32$1(bytes, _int32$1[1 ], it);
-}
-function boolean$1(bytes, value, it) {
-    bytes[it.offset++] = value ? 1 : 0; // uint8
-}
-function string$1(bytes, value, it) {
-    // encode `null` strings as empty.
-    if (!value) {
-        value = "";
+    operation(op) {
+        // operations without index use negative values to represent them
+        // this is checked during .encode() time.
+        this.changes.operations.push(-op);
+        enqueueChangeTree(this.root, this, 'changes');
     }
-    let length = utf8Length(value, "utf8");
-    let size = 0;
-    // fixstr
-    if (length < 0x20) {
-        bytes[it.offset++] = length | 0xa0;
-        size = 1;
+    change(index, operation = exports.OPERATION.ADD) {
+        const metadata = this.ref.constructor[Symbol.metadata];
+        const isFiltered = this.isFiltered || (metadata?.[index]?.tag !== undefined);
+        const changeSet = (isFiltered)
+            ? this.filteredChanges
+            : this.changes;
+        const previousOperation = this.indexedOperations[index];
+        if (!previousOperation || previousOperation === exports.OPERATION.DELETE) {
+            const op = (!previousOperation)
+                ? operation
+                : (previousOperation === exports.OPERATION.DELETE)
+                    ? exports.OPERATION.DELETE_AND_ADD
+                    : operation;
+            //
+            // TODO: are DELETE operations being encoded as ADD here ??
+            //
+            this.indexedOperations[index] = op;
+        }
+        setOperationAtIndex(changeSet, index);
+        if (isFiltered) {
+            setOperationAtIndex(this.allFilteredChanges, index);
+            if (this.root) {
+                enqueueChangeTree(this.root, this, 'filteredChanges');
+                enqueueChangeTree(this.root, this, 'allFilteredChanges');
+            }
+        }
+        else {
+            setOperationAtIndex(this.allChanges, index);
+            enqueueChangeTree(this.root, this, 'changes');
+        }
     }
-    // str 8
-    else if (length < 0x100) {
-        bytes[it.offset++] = 0xd9;
-        bytes[it.offset++] = length % 255;
-        size = 2;
+    shiftChangeIndexes(shiftIndex) {
+        //
+        // Used only during:
+        //
+        // - ArraySchema#unshift()
+        //
+        const changeSet = (this.isFiltered)
+            ? this.filteredChanges
+            : this.changes;
+        const newIndexedOperations = {};
+        const newIndexes = {};
+        for (const index in this.indexedOperations) {
+            newIndexedOperations[Number(index) + shiftIndex] = this.indexedOperations[index];
+            newIndexes[Number(index) + shiftIndex] = changeSet[index];
+        }
+        this.indexedOperations = newIndexedOperations;
+        changeSet.indexes = newIndexes;
+        changeSet.operations = changeSet.operations.map((index) => index + shiftIndex);
     }
-    // str 16
-    else if (length < 0x10000) {
-        bytes[it.offset++] = 0xda;
-        uint16$1(bytes, length, it);
-        size = 3;
+    shiftAllChangeIndexes(shiftIndex, startIndex = 0) {
+        //
+        // Used only during:
+        //
+        // - ArraySchema#splice()
+        //
+        if (this.isFiltered || this.isPartiallyFiltered) {
+            this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allFilteredChanges);
+            this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
+        }
+        else {
+            this._shiftAllChangeIndexes(shiftIndex, startIndex, this.allChanges);
+        }
     }
-    // str 32
-    else if (length < 0x100000000) {
-        bytes[it.offset++] = 0xdb;
-        uint32$1(bytes, length, it);
-        size = 5;
+    _shiftAllChangeIndexes(shiftIndex, startIndex = 0, changeSet) {
+        const newIndexes = {};
+        for (const key in changeSet.indexes) {
+            const index = changeSet.indexes[key];
+            if (index > startIndex) {
+                newIndexes[Number(key) + shiftIndex] = index;
+            }
+            else {
+                newIndexes[key] = index;
+            }
+        }
+        changeSet.indexes = newIndexes;
+        for (let i = 0; i < changeSet.operations.length; i++) {
+            const index = changeSet.operations[i];
+            if (index > startIndex) {
+                changeSet.operations[i] = index + shiftIndex;
+            }
+        }
     }
-    else {
-        throw new Error('String too long');
+    indexedOperation(index, operation, allChangesIndex = index) {
+        this.indexedOperations[index] = operation;
+        if (this.filteredChanges) {
+            setOperationAtIndex(this.allFilteredChanges, allChangesIndex);
+            setOperationAtIndex(this.filteredChanges, index);
+            enqueueChangeTree(this.root, this, 'filteredChanges');
+        }
+        else {
+            setOperationAtIndex(this.allChanges, allChangesIndex);
+            setOperationAtIndex(this.changes, index);
+            enqueueChangeTree(this.root, this, 'changes');
+        }
     }
-    utf8Write(bytes, value, it);
-    return size + length;
-}
-function number$1(bytes, value, it) {
-    if (isNaN(value)) {
-        return number$1(bytes, 0, it);
+    getType(index) {
+        if (Metadata.isValidInstance(this.ref)) {
+            const metadata = this.ref.constructor[Symbol.metadata];
+            return metadata[index].type;
+        }
+        else {
+            //
+            // Get the child type from parent structure.
+            // - ["string"] => "string"
+            // - { map: "string" } => "string"
+            // - { set: "string" } => "string"
+            //
+            return this.ref[$childType];
+        }
     }
-    else if (!isFinite(value)) {
-        return number$1(bytes, (value > 0) ? Number.MAX_SAFE_INTEGER : -Number.MAX_SAFE_INTEGER, it);
+    getChange(index) {
+        return this.indexedOperations[index];
     }
-    else if (value !== (value | 0)) {
-        bytes[it.offset++] = 0xcb;
-        writeFloat64(bytes, value, it);
-        return 9;
-        // TODO: encode float 32?
-        // is it possible to differentiate between float32 / float64 here?
-        // // float 32
-        // bytes.push(0xca);
-        // writeFloat32(bytes, value);
-        // return 5;
+    //
+    // used during `.encode()`
+    //
+    getValue(index, isEncodeAll = false) {
+        //
+        // `isEncodeAll` param is only used by ArraySchema
+        //
+        return this.ref[$getByIndex](index, isEncodeAll);
     }
-    if (value >= 0) {
-        // positive fixnum
-        if (value < 0x80) {
-            bytes[it.offset++] = value & 255; // uint8
-            return 1;
+    delete(index, operation, allChangesIndex = index) {
+        if (index === undefined) {
+            try {
+                throw new Error(`@colyseus/schema ${this.ref.constructor.name}: trying to delete non-existing index '${index}'`);
+            }
+            catch (e) {
+                console.warn(e);
+            }
+            return;
         }
-        // uint 8
-        if (value < 0x100) {
-            bytes[it.offset++] = 0xcc;
-            bytes[it.offset++] = value & 255; // uint8
-            return 2;
+        const changeSet = (this.filteredChanges)
+            ? this.filteredChanges
+            : this.changes;
+        this.indexedOperations[index] = operation ?? exports.OPERATION.DELETE;
+        setOperationAtIndex(changeSet, index);
+        const previousValue = this.getValue(index);
+        // remove `root` reference
+        if (previousValue && previousValue[$changes]) {
+            //
+            // FIXME: this.root is "undefined"
+            //
+            // This method is being called at decoding time when a DELETE operation is found.
+            //
+            // - This is due to using the concrete Schema class at decoding time.
+            // - "Reflected" structures do not have this problem.
+            //
+            // (the property descriptors should NOT be used at decoding time. only at encoding time.)
+            //
+            this.root?.remove(previousValue[$changes]);
         }
-        // uint 16
-        if (value < 0x10000) {
-            bytes[it.offset++] = 0xcd;
-            uint16$1(bytes, value, it);
-            return 3;
+        //
+        // FIXME: this is looking a ugly and repeated
+        //
+        if (this.filteredChanges) {
+            deleteOperationAtIndex(this.allFilteredChanges, allChangesIndex);
+            enqueueChangeTree(this.root, this, 'filteredChanges');
         }
-        // uint 32
-        if (value < 0x100000000) {
-            bytes[it.offset++] = 0xce;
-            uint32$1(bytes, value, it);
-            return 5;
+        else {
+            deleteOperationAtIndex(this.allChanges, allChangesIndex);
+            enqueueChangeTree(this.root, this, 'changes');
         }
-        // uint 64
-        bytes[it.offset++] = 0xcf;
-        uint64$1(bytes, value, it);
-        return 9;
     }
-    else {
-        // negative fixnum
-        if (value >= -0x20) {
-            bytes[it.offset++] = 0xe0 | (value + 0x20);
-            return 1;
+    endEncode() {
+        this.indexedOperations = {};
+        // // clear changes
+        // this.changes.indexes = {};
+        // this.changes.operations.length = 0;
+        // ArraySchema and MapSchema have a custom "encode end" method
+        this.ref[$onEncodeEnd]?.();
+        // Not a new instance anymore
+        this.isNew = 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.
+        //
+        this.ref[$onEncodeEnd]?.();
+        this.indexedOperations = {};
+        this.changes.indexes = {};
+        this.changes.operations.length = 0;
+        this.changes.queueRootIndex = undefined;
+        if (this.filteredChanges !== undefined) {
+            this.filteredChanges.indexes = {};
+            this.filteredChanges.operations.length = 0;
+            this.filteredChanges.queueRootIndex = undefined;
+        }
+        if (discardAll) {
+            this.allChanges.indexes = {};
+            this.allChanges.operations.length = 0;
+            if (this.allFilteredChanges !== undefined) {
+                this.allFilteredChanges.indexes = {};
+                this.allFilteredChanges.operations.length = 0;
+            }
+            // remove children references
+            this.forEachChild((changeTree, _) => this.root?.remove(changeTree));
+        }
+    }
+    /**
+     * Recursively discard all changes from this, and child structures.
+     */
+    discardAll() {
+        const keys = Object.keys(this.indexedOperations);
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const value = this.getValue(Number(keys[i]));
+            if (value && value[$changes]) {
+                value[$changes].discardAll();
+            }
+        }
+        this.discard();
+    }
+    ensureRefId() {
+        // skip if refId is already set.
+        if (this.refId !== undefined) {
+            return;
+        }
+        this.refId = this.root.getNextUniqueId();
+    }
+    get changed() {
+        return (Object.entries(this.indexedOperations).length > 0);
+    }
+    checkIsFiltered(metadata, parent, parentIndex) {
+        // Detect if current structure has "filters" declared
+        this.isPartiallyFiltered = metadata?.[$viewFieldIndexes] !== undefined;
+        if (this.isPartiallyFiltered) {
+            this.filteredChanges = this.filteredChanges || { indexes: {}, operations: [] };
+            this.allFilteredChanges = this.allFilteredChanges || { indexes: {}, operations: [] };
         }
-        // int 8
-        if (value >= -0x80) {
-            bytes[it.offset++] = 0xd0;
-            int8$1(bytes, value, it);
-            return 2;
+        // skip if parent is not set
+        if (!parent) {
+            return;
         }
-        // int 16
-        if (value >= -0x8000) {
-            bytes[it.offset++] = 0xd1;
-            int16$1(bytes, value, it);
-            return 3;
+        if (!Metadata.isValidInstance(parent)) {
+            const parentChangeTree = parent[$changes];
+            parent = parentChangeTree.parent;
+            parentIndex = parentChangeTree.parentIndex;
         }
-        // int 32
-        if (value >= -0x80000000) {
-            bytes[it.offset++] = 0xd2;
-            int32$1(bytes, value, it);
-            return 5;
+        const parentMetadata = parent.constructor?.[Symbol.metadata];
+        this.isFiltered = parentMetadata?.[$viewFieldIndexes]?.includes(parentIndex);
+        //
+        // TODO: refactor this!
+        //
+        //      swapping `changes` and `filteredChanges` is required here
+        //      because "isFiltered" may not be imedialely available on `change()`
+        //
+        if (this.isFiltered) {
+            this.filteredChanges = { indexes: {}, operations: [] };
+            this.allFilteredChanges = { indexes: {}, operations: [] };
+            if (this.changes.operations.length > 0) {
+                // swap changes reference
+                const changes = this.changes;
+                this.changes = this.filteredChanges;
+                this.filteredChanges = changes;
+                // swap "all changes" reference
+                const allFilteredChanges = this.allFilteredChanges;
+                this.allFilteredChanges = this.allChanges;
+                this.allChanges = allFilteredChanges;
+                // console.log("SWAP =>", {
+                //     "this.allFilteredChanges": this.allFilteredChanges,
+                //     "this.allChanges": this.allChanges
+                // })
+            }
         }
-        // int 64
-        bytes[it.offset++] = 0xd3;
-        int64$1(bytes, value, it);
-        return 9;
     }
 }
 
-var encode = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    boolean: boolean$1,
-    float32: float32$1,
-    float64: float64$1,
-    int16: int16$1,
-    int32: int32$1,
-    int64: int64$1,
-    int8: int8$1,
-    number: number$1,
-    string: string$1,
-    uint16: uint16$1,
-    uint32: uint32$1,
-    uint64: uint64$1,
-    uint8: uint8$1,
-    utf8Length: utf8Length,
-    utf8Write: utf8Write,
-    writeFloat32: writeFloat32,
-    writeFloat64: writeFloat64
-});
-
 function encodeValue(encoder, bytes, type, value, operation, it) {
     if (typeof (type) === "string") {
         encode[type]?.(bytes, value, it);
@@ -1121,7 +1347,7 @@ function encodeValue(encoder, bytes, type, value, operation, it) {
         // Encode refId for this instance.
         // The actual instance is going to be encoded on next `changeTree` iteration.
         //
-        number$1(bytes, value[$changes].refId, it);
+        encode.number(bytes, value[$changes].refId, it);
         // Try to encode inherited TYPE_ID if it's an ADD operation.
         if ((operation & exports.OPERATION.ADD) === exports.OPERATION.ADD) {
             encoder.tryEncodeTypeId(bytes, type, value.constructor, it);
@@ -1132,7 +1358,7 @@ function encodeValue(encoder, bytes, type, value, operation, it) {
         // Encode refId for this instance.
         // The actual instance is going to be encoded on next `changeTree` iteration.
         //
-        number$1(bytes, value[$changes].refId, it);
+        encode.number(bytes, value[$changes].refId, it);
     }
 }
 /**
@@ -1163,7 +1389,7 @@ const encodeKeyValueOperation = function (encoder, bytes, changeTree, index, ope
         return;
     }
     // encode index
-    number$1(bytes, index, it);
+    encode.number(bytes, index, it);
     // Do not encode value for DELETE operations
     if (operation === exports.OPERATION.DELETE) {
         return;
@@ -1178,7 +1404,7 @@ const encodeKeyValueOperation = function (encoder, bytes, changeTree, index, ope
             // MapSchema dynamic key
             //
             const dynamicIndex = changeTree.ref['$indexes'].get(index);
-            string$1(bytes, dynamicIndex, it);
+            encode.string(bytes, dynamicIndex, it);
         }
     }
     const type = ref[$childType];
@@ -1226,7 +1452,7 @@ const encodeArray = function (encoder, bytes, changeTree, field, operation, it,
         return;
     }
     // encode index
-    number$1(bytes, refOrIndex, it);
+    encode.number(bytes, refOrIndex, it);
     // Do not encode value for DELETE operations
     if (operation === exports.OPERATION.DELETE) {
         return;
@@ -1244,259 +1470,6 @@ const encodeArray = function (encoder, bytes, changeTree, field, operation, it,
     encodeValue(encoder, bytes, type, value, operation, it);
 };
 
-/**
- * Copyright (c) 2018 Endel Dreyer
- * Copyright (c) 2014 Ion Drive Software Ltd.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE
- */
-function utf8Read(bytes, it, length) {
-    var string = '', chr = 0;
-    for (var i = it.offset, end = it.offset + length; i < end; i++) {
-        var byte = bytes[i];
-        if ((byte & 0x80) === 0x00) {
-            string += String.fromCharCode(byte);
-            continue;
-        }
-        if ((byte & 0xe0) === 0xc0) {
-            string += String.fromCharCode(((byte & 0x1f) << 6) |
-                (bytes[++i] & 0x3f));
-            continue;
-        }
-        if ((byte & 0xf0) === 0xe0) {
-            string += String.fromCharCode(((byte & 0x0f) << 12) |
-                ((bytes[++i] & 0x3f) << 6) |
-                ((bytes[++i] & 0x3f) << 0));
-            continue;
-        }
-        if ((byte & 0xf8) === 0xf0) {
-            chr = ((byte & 0x07) << 18) |
-                ((bytes[++i] & 0x3f) << 12) |
-                ((bytes[++i] & 0x3f) << 6) |
-                ((bytes[++i] & 0x3f) << 0);
-            if (chr >= 0x010000) { // surrogate pair
-                chr -= 0x010000;
-                string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
-            }
-            else {
-                string += String.fromCharCode(chr);
-            }
-            continue;
-        }
-        console.error('Invalid byte ' + byte.toString(16));
-        // (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) {
-    return uint8(bytes, it) << 24 >> 24;
-}
-function uint8(bytes, it) {
-    return bytes[it.offset++];
-}
-function int16(bytes, it) {
-    return uint16(bytes, it) << 16 >> 16;
-}
-function uint16(bytes, it) {
-    return bytes[it.offset++] | bytes[it.offset++] << 8;
-}
-function int32(bytes, it) {
-    return bytes[it.offset++] | bytes[it.offset++] << 8 | bytes[it.offset++] << 16 | bytes[it.offset++] << 24;
-}
-function uint32(bytes, it) {
-    return int32(bytes, it) >>> 0;
-}
-function float32(bytes, it) {
-    return readFloat32(bytes, it);
-}
-function float64(bytes, it) {
-    return readFloat64(bytes, it);
-}
-function int64(bytes, it) {
-    const low = uint32(bytes, it);
-    const high = int32(bytes, it) * Math.pow(2, 32);
-    return high + low;
-}
-function uint64(bytes, it) {
-    const low = uint32(bytes, it);
-    const high = uint32(bytes, it) * Math.pow(2, 32);
-    return high + low;
-}
-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];
-}
-function readFloat64(bytes, it) {
-    _int32[0 ] = int32(bytes, it);
-    _int32[1 ] = int32(bytes, it);
-    return _float64[0];
-}
-function boolean(bytes, it) {
-    return uint8(bytes, it) > 0;
-}
-function string(bytes, it) {
-    const prefix = bytes[it.offset++];
-    let length;
-    if (prefix < 0xc0) {
-        // fixstr
-        length = prefix & 0x1f;
-    }
-    else if (prefix === 0xd9) {
-        length = uint8(bytes, it);
-    }
-    else if (prefix === 0xda) {
-        length = uint16(bytes, it);
-    }
-    else if (prefix === 0xdb) {
-        length = uint32(bytes, it);
-    }
-    return utf8Read(bytes, it, length);
-}
-function stringCheck(bytes, it) {
-    const prefix = bytes[it.offset];
-    return (
-    // fixstr
-    (prefix < 0xc0 && prefix > 0xa0) ||
-        // str 8
-        prefix === 0xd9 ||
-        // str 16
-        prefix === 0xda ||
-        // str 32
-        prefix === 0xdb);
-}
-function number(bytes, it) {
-    const prefix = bytes[it.offset++];
-    if (prefix < 0x80) {
-        // positive fixint
-        return prefix;
-    }
-    else if (prefix === 0xca) {
-        // float 32
-        return readFloat32(bytes, it);
-    }
-    else if (prefix === 0xcb) {
-        // float 64
-        return readFloat64(bytes, it);
-    }
-    else if (prefix === 0xcc) {
-        // uint 8
-        return uint8(bytes, it);
-    }
-    else if (prefix === 0xcd) {
-        // uint 16
-        return uint16(bytes, it);
-    }
-    else if (prefix === 0xce) {
-        // uint 32
-        return uint32(bytes, it);
-    }
-    else if (prefix === 0xcf) {
-        // uint 64
-        return uint64(bytes, it);
-    }
-    else if (prefix === 0xd0) {
-        // int 8
-        return int8(bytes, it);
-    }
-    else if (prefix === 0xd1) {
-        // int 16
-        return int16(bytes, it);
-    }
-    else if (prefix === 0xd2) {
-        // int 32
-        return int32(bytes, it);
-    }
-    else if (prefix === 0xd3) {
-        // int 64
-        return int64(bytes, it);
-    }
-    else if (prefix > 0xdf) {
-        // negative fixint
-        return (0xff - prefix + 1) * -1;
-    }
-}
-function numberCheck(bytes, it) {
-    const prefix = bytes[it.offset];
-    // positive fixint - 0x00 - 0x7f
-    // float 32        - 0xca
-    // float 64        - 0xcb
-    // uint 8          - 0xcc
-    // uint 16         - 0xcd
-    // uint 32         - 0xce
-    // uint 64         - 0xcf
-    // int 8           - 0xd0
-    // int 16          - 0xd1
-    // int 32          - 0xd2
-    // int 64          - 0xd3
-    return (prefix < 0x80 ||
-        (prefix >= 0xca && prefix <= 0xd3));
-}
-function arrayCheck(bytes, it) {
-    return bytes[it.offset] < 0xa0;
-    // const prefix = bytes[it.offset] ;
-    // if (prefix < 0xa0) {
-    //   return prefix;
-    // // array
-    // } else if (prefix === 0xdc) {
-    //   it.offset += 2;
-    // } else if (0xdd) {
-    //   it.offset += 4;
-    // }
-    // return prefix;
-}
-function switchStructureCheck(bytes, it) {
-    return (
-    // previous byte should be `SWITCH_TO_STRUCTURE`
-    bytes[it.offset - 1] === SWITCH_TO_STRUCTURE &&
-        // next byte should be a number
-        (bytes[it.offset] < 0x80 || (bytes[it.offset] >= 0xca && bytes[it.offset] <= 0xd3)));
-}
-
-var decode = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    arrayCheck: arrayCheck,
-    boolean: boolean,
-    float32: float32,
-    float64: float64,
-    int16: int16,
-    int32: int32,
-    int64: int64,
-    int8: int8,
-    number: number,
-    numberCheck: numberCheck,
-    readFloat32: readFloat32,
-    readFloat64: readFloat64,
-    string: string,
-    stringCheck: stringCheck,
-    switchStructureCheck: switchStructureCheck,
-    uint16: uint16,
-    uint32: uint32,
-    uint64: uint64,
-    uint8: uint8,
-    utf8Read: utf8Read
-});
-
 const DEFINITION_MISMATCH = -1;
 function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges) {
     const $root = decoder.root;
@@ -1531,7 +1504,7 @@ function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges
     }
     if (operation === exports.OPERATION.DELETE) ;
     else if (Schema.is(type)) {
-        const refId = number(bytes, it);
+        const refId = decode.number(bytes, it);
         value = $root.refs.get(refId);
         if (previousValue) {
             const previousRefId = $root.refIds.get(previousValue);
@@ -1560,7 +1533,7 @@ function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges
     }
     else {
         const typeDef = getType(Object.keys(type)[0]);
-        const refId = number(bytes, it);
+        const refId = decode.number(bytes, it);
         const valueRef = ($root.refs.has(refId))
             ? previousValue || $root.refs.get(refId)
             : new typeDef.constructor();
@@ -1639,12 +1612,12 @@ const decodeKeyValueOperation = function (decoder, bytes, it, ref, allChanges) {
         ref.clear();
         return;
     }
-    const index = number(bytes, it);
+    const index = decode.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
+            dynamicIndex = decode.string(bytes, it); // MapSchema
             ref['setIndex'](index, dynamicIndex);
         }
         else {
@@ -1706,7 +1679,7 @@ const decodeArray = function (decoder, bytes, it, ref, allChanges) {
     }
     else if (operation === exports.OPERATION.DELETE_BY_REFID) {
         // TODO: refactor here, try to follow same flow as below
-        const refId = number(bytes, it);
+        const refId = decode.number(bytes, it);
         const previousValue = decoder.root.refs.get(refId);
         index = ref.findIndex((value) => value === previousValue);
         ref[$deleteByIndex](index);
@@ -1722,7 +1695,7 @@ const decodeArray = function (decoder, bytes, it, ref, allChanges) {
         return;
     }
     else if (operation === exports.OPERATION.ADD_BY_REFID) {
-        const refId = number(bytes, it);
+        const refId = decode.number(bytes, it);
         const itemByRefId = decoder.root.refs.get(refId);
         // use existing index, or push new value
         index = (itemByRefId)
@@ -1730,7 +1703,7 @@ const decodeArray = function (decoder, bytes, it, ref, allChanges) {
             : ref.length;
     }
     else {
-        index = number(bytes, it);
+        index = decode.number(bytes, it);
     }
     const type = ref[$childType];
     let dynamicIndex = index;
@@ -1777,6 +1750,10 @@ function assertType(value, type, klass, field) {
                 console.log(`trying to encode "NaN" in ${klass.constructor.name}#${field}`);
             }
             break;
+        case "bigint64":
+        case "biguint64":
+            typeofTarget = "bigint";
+            break;
         case "string":
             typeofTarget = "string";
             allowNull = true;
@@ -1784,6 +1761,10 @@ function assertType(value, type, klass, field) {
         case "boolean":
             // boolean is always encoded as true/false based on truthiness
             return;
+        default:
+            // skip assertion for custom types
+            // TODO: allow custom types to define their own assertions
+            return;
     }
     if (typeof (value) !== typeofTarget && (!allowNull || (allowNull && value !== null))) {
         let foundValue = `'${JSON.stringify(value)}'${(value && value.constructor && ` (${value.constructor.name})`) || ''}`;
@@ -3788,7 +3769,7 @@ class Encoder {
             // (unless it "hasView", which will need to revisit the root)
             if (hasView || it.offset > initialOffset || changeTree !== rootChangeTree) {
                 buffer[it.offset++] = SWITCH_TO_STRUCTURE & 255;
-                number$1(buffer, changeTree.refId, it);
+                encode.number(buffer, changeTree.refId, it);
             }
             for (let j = 0, numChanges = operations.operations.length; j < numChanges; j++) {
                 const fieldIndex = operations.operations[j];
@@ -3917,7 +3898,7 @@ class Encoder {
             const encoder = ctor[$encoder];
             const metadata = ctor[Symbol.metadata];
             bytes[it.offset++] = SWITCH_TO_STRUCTURE & 255;
-            number$1(bytes, changeTree.refId, it);
+            encode.number(bytes, changeTree.refId, it);
             const keys = Object.keys(changes);
             for (let i = 0, numChanges = keys.length; i < numChanges; i++) {
                 const key = keys[i];
@@ -3983,7 +3964,7 @@ class Encoder {
         }
         if (baseTypeId !== targetTypeId) {
             bytes[it.offset++] = TYPE_ID & 255;
-            number$1(bytes, targetTypeId, it);
+            encode.number(bytes, targetTypeId, it);
         }
     }
     get hasChanges() {
@@ -4143,7 +4124,7 @@ class Decoder {
             //
             if (bytes[it.offset] == SWITCH_TO_STRUCTURE) {
                 it.offset++;
-                this.currentRefId = number(bytes, it);
+                this.currentRefId = decode.number(bytes, it);
                 const nextRef = $root.refs.get(this.currentRefId);
                 //
                 // Trying to access a reference that haven't been decoded yet.
@@ -4165,9 +4146,9 @@ class Decoder {
                 //
                 const nextIterator = { offset: it.offset };
                 while (it.offset < totalBytes) {
-                    if (switchStructureCheck(bytes, it)) {
+                    if (bytes[it.offset] === SWITCH_TO_STRUCTURE) {
                         nextIterator.offset = it.offset + 1;
-                        if ($root.refs.has(number(bytes, nextIterator))) {
+                        if ($root.refs.has(decode.number(bytes, nextIterator))) {
                             break;
                         }
                     }
@@ -4188,7 +4169,7 @@ class Decoder {
         let type;
         if (bytes[it.offset] === TYPE_ID) {
             it.offset++;
-            const type_id = number(bytes, it);
+            const type_id = decode.number(bytes, it);
             type = this.context.get(type_id);
         }
         return type || defaultType;
@@ -4867,6 +4848,7 @@ exports.TypeContext = TypeContext;
 exports.decode = decode;
 exports.decodeKeyValueOperation = decodeKeyValueOperation;
 exports.decodeSchemaOperation = decodeSchemaOperation;
+exports.defineCustomTypes = defineCustomTypes;
 exports.defineTypes = defineTypes;
 exports.deprecated = deprecated;
 exports.dumpChanges = dumpChanges;