@colyseus/schema 1.1.0-alpha.0 → 2.0.0

package/build/cjs/index.js

@@ -2,9 +2,53 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __spreadArray(to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+}
+
 // export const SWITCH_TO_STRUCTURE = 193; (easily collides with DELETE_AND_ADD + fieldIndex = 2)
-const SWITCH_TO_STRUCTURE = 255; // (decoding collides with DELETE_AND_ADD + fieldIndex = 63)
-const TYPE_ID = 213;
+var SWITCH_TO_STRUCTURE = 255; // (decoding collides with DELETE_AND_ADD + fieldIndex = 63)
+var TYPE_ID = 213;
 /**
  * Encoding Schema field operations.
  */
@@ -41,75 +85,8 @@ exports.OPERATION = void 0;
 //     CLEAR = 10,
 // }
 
-//
-// Root holds all schema references by unique id
-//
-class Root {
-    constructor() {
-        //
-        // Relation of refId => Schema structure
-        // For direct access of structures during decoding time.
-        //
-        this.refs = new Map();
-        this.refCounts = {};
-        this.deletedRefs = new Set();
-        this.nextUniqueId = 0;
-    }
-    getNextUniqueId() {
-        return this.nextUniqueId++;
-    }
-    // for decoding
-    addRef(refId, ref, incrementCount = true) {
-        this.refs.set(refId, ref);
-        if (incrementCount) {
-            this.refCounts[refId] = (this.refCounts[refId] || 0) + 1;
-        }
-    }
-    // for decoding
-    removeRef(refId) {
-        this.refCounts[refId] = this.refCounts[refId] - 1;
-        this.deletedRefs.add(refId);
-    }
-    clearRefs() {
-        this.refs.clear();
-        this.deletedRefs.clear();
-        this.refCounts = {};
-    }
-    // for decoding
-    garbageCollectDeletedRefs() {
-        this.deletedRefs.forEach((refId) => {
-            if (this.refCounts[refId] <= 0) {
-                const ref = this.refs.get(refId);
-                //
-                // Ensure child schema instances have their references removed as well.
-                //
-                if (ref instanceof Schema) {
-                    for (const fieldName in ref['_definition'].schema) {
-                        if (typeof (ref['_definition'].schema[fieldName]) !== "string" &&
-                            ref[fieldName] &&
-                            ref[fieldName]['$changes']) {
-                            this.removeRef(ref[fieldName]['$changes'].refId);
-                        }
-                    }
-                }
-                else {
-                    const definition = ref['$changes'].parent._definition;
-                    const type = definition.schema[definition.fieldsByIndex[ref['$changes'].parentIndex]];
-                    if (typeof (Object.values(type)[0]) === "function") {
-                        Array.from(ref.values())
-                            .forEach((child) => this.removeRef(child['$changes'].refId));
-                    }
-                }
-                this.refs.delete(refId);
-                delete this.refCounts[refId];
-            }
-        });
-        // clear deleted refs.
-        this.deletedRefs.clear();
-    }
-}
-class ChangeTree {
-    constructor(ref, parent, root) {
+var ChangeTree = /** @class */ (function () {
+    function ChangeTree(ref, parent, root) {
         this.changed = false;
         this.changes = new Map();
         this.allChanges = new Set();
@@ -119,7 +96,8 @@ class ChangeTree {
         this.ref = ref;
         this.setParent(parent, root);
     }
-    setParent(parent, root, parentIndex) {
+    ChangeTree.prototype.setParent = function (parent, root, parentIndex) {
+        var _this = this;
         if (!this.indexes) {
             this.indexes = (this.ref instanceof Schema)
                 ? this.ref['_definition'].indexes
@@ -136,34 +114,35 @@ class ChangeTree {
         // assign same parent on child structures
         //
         if (this.ref instanceof Schema) {
-            const definition = this.ref['_definition'];
-            for (let field in definition.schema) {
-                const value = this.ref[field];
+            var definition = this.ref['_definition'];
+            for (var field in definition.schema) {
+                var value = this.ref[field];
                 if (value && value['$changes']) {
-                    const parentIndex = definition.indexes[field];
-                    value['$changes'].setParent(this.ref, root, parentIndex);
+                    var parentIndex_1 = definition.indexes[field];
+                    value['$changes'].setParent(this.ref, root, parentIndex_1);
                 }
             }
         }
         else if (typeof (this.ref) === "object") {
-            this.ref.forEach((value, key) => {
+            this.ref.forEach(function (value, key) {
                 if (value instanceof Schema) {
-                    const changeTreee = value['$changes'];
-                    const parentIndex = this.ref['$changes'].indexes[key];
-                    changeTreee.setParent(this.ref, this.root, parentIndex);
+                    var changeTreee = value['$changes'];
+                    var parentIndex_2 = _this.ref['$changes'].indexes[key];
+                    changeTreee.setParent(_this.ref, _this.root, parentIndex_2);
                 }
             });
         }
-    }
-    operation(op) {
+    };
+    ChangeTree.prototype.operation = function (op) {
         this.changes.set(--this.currentCustomOperation, op);
-    }
-    change(fieldName, operation = exports.OPERATION.ADD) {
-        const index = (typeof (fieldName) === "number")
+    };
+    ChangeTree.prototype.change = function (fieldName, operation) {
+        if (operation === void 0) { operation = exports.OPERATION.ADD; }
+        var index = (typeof (fieldName) === "number")
             ? fieldName
             : this.indexes[fieldName];
         this.assertValidIndex(index, fieldName);
-        const previousChange = this.changes.get(index);
+        var previousChange = this.changes.get(index);
         if (!previousChange ||
             previousChange.op === exports.OPERATION.DELETE ||
             previousChange.op === exports.OPERATION.TOUCH // (mazmorra.io's BattleAction issue)
@@ -175,38 +154,38 @@ class ChangeTree {
                         ? exports.OPERATION.DELETE_AND_ADD
                         : operation,
                 // : OPERATION.REPLACE,
-                index
+                index: index
             });
         }
         this.allChanges.add(index);
         this.changed = true;
         this.touchParents();
-    }
-    touch(fieldName) {
-        const index = (typeof (fieldName) === "number")
+    };
+    ChangeTree.prototype.touch = function (fieldName) {
+        var index = (typeof (fieldName) === "number")
             ? fieldName
             : this.indexes[fieldName];
         this.assertValidIndex(index, fieldName);
         if (!this.changes.has(index)) {
-            this.changes.set(index, { op: exports.OPERATION.TOUCH, index });
+            this.changes.set(index, { op: exports.OPERATION.TOUCH, index: index });
         }
         this.allChanges.add(index);
         // ensure touch is placed until the $root is found.
         this.touchParents();
-    }
-    touchParents() {
+    };
+    ChangeTree.prototype.touchParents = function () {
         if (this.parent) {
             this.parent['$changes'].touch(this.parentIndex);
         }
-    }
-    getType(index) {
+    };
+    ChangeTree.prototype.getType = function (index) {
         if (this.ref['_definition']) {
-            const definition = this.ref['_definition'];
+            var definition = this.ref['_definition'];
             return definition.schema[definition.fieldsByIndex[index]];
         }
         else {
-            const definition = this.parent['_definition'];
-            const parentType = definition.schema[definition.fieldsByIndex[this.parentIndex]];
+            var definition = this.parent['_definition'];
+            var parentType = definition.schema[definition.fieldsByIndex[this.parentIndex]];
             //
             // Get the child type from parent structure.
             // - ["string"] => "string"
@@ -215,28 +194,28 @@ class ChangeTree {
             //
             return Object.values(parentType)[0];
         }
-    }
-    getChildrenFilter() {
-        const childFilters = this.parent['_definition'].childFilters;
+    };
+    ChangeTree.prototype.getChildrenFilter = function () {
+        var childFilters = this.parent['_definition'].childFilters;
         return childFilters && childFilters[this.parentIndex];
-    }
+    };
     //
     // used during `.encode()`
     //
-    getValue(index) {
+    ChangeTree.prototype.getValue = function (index) {
         return this.ref['getByIndex'](index);
-    }
-    delete(fieldName) {
-        const index = (typeof (fieldName) === "number")
+    };
+    ChangeTree.prototype.delete = function (fieldName) {
+        var index = (typeof (fieldName) === "number")
             ? fieldName
             : this.indexes[fieldName];
         if (index === undefined) {
-            console.warn(`@colyseus/schema ${this.ref.constructor.name}: trying to delete non-existing index: ${fieldName} (${index})`);
+            console.warn("@colyseus/schema " + this.ref.constructor.name + ": trying to delete non-existing index: " + fieldName + " (" + index + ")");
             return;
         }
-        const previousValue = this.getValue(index);
+        var previousValue = this.getValue(index);
         // console.log("$changes.delete =>", { fieldName, index, previousValue });
-        this.changes.set(index, { op: exports.OPERATION.DELETE, index });
+        this.changes.set(index, { op: exports.OPERATION.DELETE, index: index });
         this.allChanges.delete(index);
         // delete cache
         delete this.caches[index];
@@ -246,8 +225,11 @@ class ChangeTree {
         }
         this.changed = true;
         this.touchParents();
-    }
-    discard(changed = false, discardAll = false) {
+    };
+    ChangeTree.prototype.discard = function (changed, discardAll) {
+        var _this = this;
+        if (changed === void 0) { changed = false; }
+        if (discardAll === void 0) { discardAll = false; }
         //
         // Map, Array, etc:
         // Remove cached key to ensure ADD operations is unsed instead of
@@ -256,10 +238,10 @@ class ChangeTree {
         // TODO: refactor this. this is not relevant for Collection and Set.
         //
         if (!(this.ref instanceof Schema)) {
-            this.changes.forEach((change) => {
+            this.changes.forEach(function (change) {
                 if (change.op === exports.OPERATION.DELETE) {
-                    const index = this.ref['getIndex'](change.index);
-                    delete this.indexes[index];
+                    var index = _this.ref['getIndex'](change.index);
+                    delete _this.indexes[index];
                 }
             });
         }
@@ -270,50 +252,88 @@ class ChangeTree {
         }
         // re-set `currentCustomOperation`
         this.currentCustomOperation = 0;
-    }
+    };
     /**
      * Recursively discard all changes from this, and child structures.
      */
-    discardAll() {
-        this.changes.forEach((change) => {
-            const value = this.getValue(change.index);
+    ChangeTree.prototype.discardAll = function () {
+        var _this = this;
+        this.changes.forEach(function (change) {
+            var value = _this.getValue(change.index);
             if (value && value['$changes']) {
                 value['$changes'].discardAll();
             }
         });
         this.discard();
-    }
+    };
     // cache(field: number, beginIndex: number, endIndex: number) {
-    cache(field, cachedBytes) {
+    ChangeTree.prototype.cache = function (field, cachedBytes) {
         this.caches[field] = cachedBytes;
-    }
-    clone() {
+    };
+    ChangeTree.prototype.clone = function () {
         return new ChangeTree(this.ref, this.parent, this.root);
-    }
-    ensureRefId() {
+    };
+    ChangeTree.prototype.ensureRefId = function () {
         // skip if refId is already set.
         if (this.refId !== undefined) {
             return;
         }
         this.refId = this.root.getNextUniqueId();
-    }
-    assertValidIndex(index, fieldName) {
+    };
+    ChangeTree.prototype.assertValidIndex = function (index, fieldName) {
         if (index === undefined) {
-            throw new Error(`ChangeTree: missing index for field "${fieldName}"`);
+            throw new Error("ChangeTree: missing index for field \"" + fieldName + "\"");
+        }
+    };
+    return ChangeTree;
+}());
+
+function addCallback($callbacks, op, callback, existing) {
+    // initialize list of callbacks
+    if (!$callbacks[op]) {
+        $callbacks[op] = [];
+    }
+    $callbacks[op].push(callback);
+    //
+    // Trigger callback for existing elements
+    // - OPERATION.ADD
+    // - OPERATION.REPLACE
+    //
+    existing === null || existing === void 0 ? void 0 : existing.forEach(function (item, key) { return callback(item, key); });
+    return function () { return spliceOne($callbacks[op], $callbacks[op].indexOf(callback)); };
+}
+function removeChildRefs(changes) {
+    var _this = this;
+    var needRemoveRef = (typeof (this.$changes.getType()) !== "string");
+    this.$items.forEach(function (item, key) {
+        changes.push({
+            refId: _this.$changes.refId,
+            op: exports.OPERATION.DELETE,
+            field: key,
+            value: undefined,
+            previousValue: item
+        });
+        if (needRemoveRef) {
+            _this.$changes.root.removeRef(item['$changes'].refId);
         }
+    });
+}
+function spliceOne(arr, index) {
+    // manually splice an array
+    if (index === -1 || index >= arr.length) {
+        return false;
     }
+    var len = arr.length - 1;
+    for (var i = index; i < len; i++) {
+        arr[i] = arr[i + 1];
+    }
+    arr.length = len;
+    return true;
 }
 
-//
-// Notes:
-// -----
-//
-// - The tsconfig.json of @colyseus/schema uses ES2018.
-// - ES2019 introduces `flatMap` / `flat`, which is not currently relevant, and caused other issues.
-//
-const DEFAULT_SORT = (a, b) => {
-    const A = a.toString();
-    const B = b.toString();
+var DEFAULT_SORT = function (a, b) {
+    var A = a.toString();
+    var B = b.toString();
     if (A < B)
         return -1;
     else if (A > B)
@@ -330,7 +350,7 @@ function getArrayProxy(value) {
     // - allow `delete map["key"]`
     //
     value = new Proxy(value, {
-        get: (obj, prop) => {
+        get: function (obj, prop) {
             if (typeof (prop) !== "symbol" &&
                 !isNaN(prop) // https://stackoverflow.com/a/175787/892698
             ) {
@@ -340,11 +360,11 @@ function getArrayProxy(value) {
                 return obj[prop];
             }
         },
-        set: (obj, prop, setValue) => {
+        set: function (obj, prop, setValue) {
             if (typeof (prop) !== "symbol" &&
                 !isNaN(prop)) {
-                const indexes = Array.from(obj['$items'].keys());
-                const key = parseInt(indexes[prop] || prop);
+                var indexes = Array.from(obj['$items'].keys());
+                var key = parseInt(indexes[prop] || prop);
                 if (setValue === undefined || setValue === null) {
                     obj.deleteAt(key);
                 }
@@ -357,7 +377,7 @@ function getArrayProxy(value) {
             }
             return true;
         },
-        deleteProperty: (obj, prop) => {
+        deleteProperty: function (obj, prop) {
             if (typeof (prop) === "number") {
                 obj.deleteAt(prop);
             }
@@ -369,145 +389,179 @@ function getArrayProxy(value) {
     });
     return value;
 }
-class ArraySchema {
-    constructor(...items) {
+var ArraySchema = /** @class */ (function () {
+    function ArraySchema() {
+        var items = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            items[_i] = arguments[_i];
+        }
         this.$changes = new ChangeTree(this);
         this.$items = new Map();
         this.$indexes = new Map();
         this.$refId = 0;
         this.push.apply(this, items);
     }
-    static is(type) {
-        return Array.isArray(type);
-    }
-    set length(value) {
-        if (value === 0) {
-            this.clear();
-        }
-        else {
-            this.splice(value, this.length - value);
-        }
-    }
-    get length() {
-        return this.$items.size;
-    }
-    push(...values) {
-        let lastIndex;
-        values.forEach(value => {
+    ArraySchema.prototype.onAdd = function (callback, triggerAll) {
+        if (triggerAll === void 0) { triggerAll = true; }
+        return addCallback((this.$callbacks || (this.$callbacks = [])), exports.OPERATION.ADD, callback, (triggerAll)
+            ? this.$items
+            : undefined);
+    };
+    ArraySchema.prototype.onRemove = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.DELETE, callback); };
+    ArraySchema.prototype.onChange = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.REPLACE, callback); };
+    ArraySchema.is = function (type) {
+        return (
+        // type format: ["string"]
+        Array.isArray(type) ||
+            // type format: { array: "string" }
+            (type['array'] !== undefined));
+    };
+    Object.defineProperty(ArraySchema.prototype, "length", {
+        get: function () {
+            return this.$items.size;
+        },
+        set: function (value) {
+            if (value === 0) {
+                this.clear();
+            }
+            else {
+                this.splice(value, this.length - value);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ArraySchema.prototype.push = function () {
+        var _this = this;
+        var values = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            values[_i] = arguments[_i];
+        }
+        var lastIndex;
+        values.forEach(function (value) {
             // set "index" for reference.
-            lastIndex = this.$refId++;
-            this.setAt(lastIndex, value);
+            lastIndex = _this.$refId++;
+            _this.setAt(lastIndex, value);
         });
         return lastIndex;
-    }
+    };
     /**
      * Removes the last element from an array and returns it.
      */
-    pop() {
-        const key = Array.from(this.$indexes.values()).pop();
+    ArraySchema.prototype.pop = function () {
+        var key = Array.from(this.$indexes.values()).pop();
         if (key === undefined) {
             return undefined;
         }
         this.$changes.delete(key);
         this.$indexes.delete(key);
-        const value = this.$items.get(key);
+        var value = this.$items.get(key);
         this.$items.delete(key);
         return value;
-    }
-    at(index) {
+    };
+    ArraySchema.prototype.at = function (index) {
         //
         // FIXME: this should be O(1)
         //
-        const key = Array.from(this.$items.keys())[index];
+        var key = Array.from(this.$items.keys())[index];
         return this.$items.get(key);
-    }
-    setAt(index, value) {
+    };
+    ArraySchema.prototype.setAt = function (index, value) {
+        var _a, _b;
         if (value['$changes'] !== undefined) {
             value['$changes'].setParent(this, this.$changes.root, index);
         }
-        const operation = this.$changes.indexes[index]?.op ?? exports.OPERATION.ADD;
+        var operation = (_b = (_a = this.$changes.indexes[index]) === null || _a === void 0 ? void 0 : _a.op) !== null && _b !== void 0 ? _b : exports.OPERATION.ADD;
         this.$changes.indexes[index] = index;
         this.$indexes.set(index, index);
         this.$items.set(index, value);
         this.$changes.change(index, operation);
-    }
-    deleteAt(index) {
-        const key = Array.from(this.$items.keys())[index];
+    };
+    ArraySchema.prototype.deleteAt = function (index) {
+        var key = Array.from(this.$items.keys())[index];
         if (key === undefined) {
             return false;
         }
         return this.$deleteAt(key);
-    }
-    $deleteAt(index) {
+    };
+    ArraySchema.prototype.$deleteAt = function (index) {
         // delete at internal index
         this.$changes.delete(index);
         this.$indexes.delete(index);
         return this.$items.delete(index);
-    }
-    clear(isDecoding) {
+    };
+    ArraySchema.prototype.clear = function (changes) {
         // discard previous operations.
         this.$changes.discard(true, true);
         this.$changes.indexes = {};
         // clear previous indexes
         this.$indexes.clear();
-        // flag child items for garbage collection.
-        if (isDecoding && typeof (this.$changes.getType()) !== "string") {
-            this.$items.forEach((item) => {
-                this.$changes.root.removeRef(item['$changes'].refId);
-            });
+        //
+        // When decoding:
+        // - enqueue items for DELETE callback.
+        // - flag child items for garbage collection.
+        //
+        if (changes) {
+            removeChildRefs.call(this, changes);
         }
         // clear items
         this.$items.clear();
         this.$changes.operation({ index: 0, op: exports.OPERATION.CLEAR });
         // touch all structures until reach root
         this.$changes.touchParents();
-    }
+    };
     /**
      * Combines two or more arrays.
      * @param items Additional items to add to the end of array1.
      */
-    concat(...items) {
-        return new ArraySchema(...Array.from(this.$items.values()).concat(...items));
-    }
+    ArraySchema.prototype.concat = function () {
+        var _a;
+        var items = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            items[_i] = arguments[_i];
+        }
+        return new (ArraySchema.bind.apply(ArraySchema, __spreadArray([void 0], (_a = Array.from(this.$items.values())).concat.apply(_a, items))))();
+    };
     /**
      * Adds all the elements of an array separated by the specified separator string.
      * @param separator A string used to separate one element of an array from the next in the resulting String. If omitted, the array elements are separated with a comma.
      */
-    join(separator) {
+    ArraySchema.prototype.join = function (separator) {
         return Array.from(this.$items.values()).join(separator);
-    }
+    };
     /**
      * Reverses the elements in an Array.
      */
-    reverse() {
-        const indexes = Array.from(this.$items.keys());
-        const reversedItems = Array.from(this.$items.values()).reverse();
-        reversedItems.forEach((item, i) => {
-            this.setAt(indexes[i], item);
+    ArraySchema.prototype.reverse = function () {
+        var _this = this;
+        var indexes = Array.from(this.$items.keys());
+        var reversedItems = Array.from(this.$items.values()).reverse();
+        reversedItems.forEach(function (item, i) {
+            _this.setAt(indexes[i], item);
         });
         return this;
-    }
+    };
     /**
      * Removes the first element from an array and returns it.
      */
-    shift() {
-        const indexes = Array.from(this.$items.keys());
-        const shiftAt = indexes.shift();
+    ArraySchema.prototype.shift = function () {
+        var indexes = Array.from(this.$items.keys());
+        var shiftAt = indexes.shift();
         if (shiftAt === undefined) {
             return undefined;
         }
-        const value = this.$items.get(shiftAt);
+        var value = this.$items.get(shiftAt);
         this.$deleteAt(shiftAt);
         return value;
-    }
+    };
     /**
      * Returns a section of an array.
      * @param start The beginning of the specified portion of the array.
      * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'.
      */
-    slice(start, end) {
-        return new ArraySchema(...Array.from(this.$items.values()).slice(start, end));
-    }
+    ArraySchema.prototype.slice = function (start, end) {
+        return new (ArraySchema.bind.apply(ArraySchema, __spreadArray([void 0], Array.from(this.$items.values()).slice(start, end))))();
+    };
     /**
      * Sorts an array.
      * @param compareFn Function used to determine the order of the elements. It is expected to return
@@ -517,62 +571,75 @@ class ArraySchema {
      * [11,2,22,1].sort((a, b) => a - b)
      * ```
      */
-    sort(compareFn = DEFAULT_SORT) {
-        const indexes = Array.from(this.$items.keys());
-        const sortedItems = Array.from(this.$items.values()).sort(compareFn);
-        sortedItems.forEach((item, i) => {
-            this.setAt(indexes[i], item);
+    ArraySchema.prototype.sort = function (compareFn) {
+        var _this = this;
+        if (compareFn === void 0) { compareFn = DEFAULT_SORT; }
+        var indexes = Array.from(this.$items.keys());
+        var sortedItems = Array.from(this.$items.values()).sort(compareFn);
+        sortedItems.forEach(function (item, i) {
+            _this.setAt(indexes[i], item);
         });
         return this;
-    }
+    };
     /**
      * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
      * @param start The zero-based location in the array from which to start removing elements.
      * @param deleteCount The number of elements to remove.
      * @param items Elements to insert into the array in place of the deleted elements.
      */
-    splice(start, deleteCount = this.length - start, ...items) {
-        const indexes = Array.from(this.$items.keys());
-        const removedItems = [];
-        for (let i = start; i < start + deleteCount; i++) {
+    ArraySchema.prototype.splice = function (start, deleteCount) {
+        if (deleteCount === void 0) { deleteCount = this.length - start; }
+        var items = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            items[_i - 2] = arguments[_i];
+        }
+        var indexes = Array.from(this.$items.keys());
+        var removedItems = [];
+        for (var i = start; i < start + deleteCount; i++) {
             removedItems.push(this.$items.get(indexes[i]));
             this.$deleteAt(indexes[i]);
         }
         return removedItems;
-    }
+    };
     /**
      * Inserts new elements at the start of an array.
      * @param items  Elements to insert at the start of the Array.
      */
-    unshift(...items) {
-        const length = this.length;
-        const addedLength = items.length;
+    ArraySchema.prototype.unshift = function () {
+        var _this = this;
+        var items = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            items[_i] = arguments[_i];
+        }
+        var length = this.length;
+        var addedLength = items.length;
         // const indexes = Array.from(this.$items.keys());
-        const previousValues = Array.from(this.$items.values());
-        items.forEach((item, i) => {
-            this.setAt(i, item);
+        var previousValues = Array.from(this.$items.values());
+        items.forEach(function (item, i) {
+            _this.setAt(i, item);
         });
-        previousValues.forEach((previousValue, i) => {
-            this.setAt(addedLength + i, previousValue);
+        previousValues.forEach(function (previousValue, i) {
+            _this.setAt(addedLength + i, previousValue);
         });
         return length + addedLength;
-    }
+    };
     /**
      * Returns the index of the first occurrence of a value in an array.
      * @param searchElement The value to locate in the array.
      * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
      */
-    indexOf(searchElement, fromIndex) {
+    ArraySchema.prototype.indexOf = function (searchElement, fromIndex) {
         return Array.from(this.$items.values()).indexOf(searchElement, fromIndex);
-    }
+    };
     /**
      * Returns the index of the last occurrence of a specified value in an array.
      * @param searchElement The value to locate in the array.
      * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at the last index in the array.
      */
-    lastIndexOf(searchElement, fromIndex = this.length - 1) {
+    ArraySchema.prototype.lastIndexOf = function (searchElement, fromIndex) {
+        if (fromIndex === void 0) { fromIndex = this.length - 1; }
         return Array.from(this.$items.values()).lastIndexOf(searchElement, fromIndex);
-    }
+    };
     /**
      * Determines whether all the members of an array satisfy the specified test.
      * @param callbackfn A function that accepts up to three arguments. The every method calls
@@ -581,9 +648,9 @@ class ArraySchema {
      * @param thisArg An object to which the this keyword can refer in the callbackfn function.
      * If thisArg is omitted, undefined is used as the this value.
      */
-    every(callbackfn, thisArg) {
+    ArraySchema.prototype.every = function (callbackfn, thisArg) {
         return Array.from(this.$items.values()).every(callbackfn, thisArg);
-    }
+    };
     /**
      * Determines whether the specified callback function returns true for any element of an array.
      * @param callbackfn A function that accepts up to three arguments. The some method calls
@@ -592,44 +659,44 @@ class ArraySchema {
      * @param thisArg An object to which the this keyword can refer in the callbackfn function.
      * If thisArg is omitted, undefined is used as the this value.
      */
-    some(callbackfn, thisArg) {
+    ArraySchema.prototype.some = function (callbackfn, thisArg) {
         return Array.from(this.$items.values()).some(callbackfn, thisArg);
-    }
+    };
     /**
      * Performs the specified action for each element in an array.
      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array.
      * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
      */
-    forEach(callbackfn, thisArg) {
+    ArraySchema.prototype.forEach = function (callbackfn, thisArg) {
         Array.from(this.$items.values()).forEach(callbackfn, thisArg);
-    }
+    };
     /**
      * Calls a defined callback function on each element of an array, and returns an array that contains the results.
      * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
      */
-    map(callbackfn, thisArg) {
+    ArraySchema.prototype.map = function (callbackfn, thisArg) {
         return Array.from(this.$items.values()).map(callbackfn, thisArg);
-    }
-    filter(callbackfn, thisArg) {
+    };
+    ArraySchema.prototype.filter = function (callbackfn, thisArg) {
         return Array.from(this.$items.values()).filter(callbackfn, thisArg);
-    }
+    };
     /**
      * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
      * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
      * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
      */
-    reduce(callbackfn, initialValue) {
+    ArraySchema.prototype.reduce = function (callbackfn, initialValue) {
         return Array.from(this.$items.values()).reduce(callbackfn, initialValue);
-    }
+    };
     /**
      * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
      * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
      */
-    reduceRight(callbackfn, initialValue) {
+    ArraySchema.prototype.reduceRight = function (callbackfn, initialValue) {
         return Array.from(this.$items.values()).reduceRight(callbackfn, initialValue);
-    }
+    };
     /**
      * Returns the value of the first element in the array where predicate is true, and undefined
      * otherwise.
@@ -639,9 +706,9 @@ class ArraySchema {
      * @param thisArg If provided, it will be used as the this value for each invocation of
      * predicate. If it is not provided, undefined is used instead.
      */
-    find(predicate, thisArg) {
+    ArraySchema.prototype.find = function (predicate, thisArg) {
         return Array.from(this.$items.values()).find(predicate, thisArg);
-    }
+    };
     /**
      * Returns the index of the first element in the array where predicate is true, and -1
      * otherwise.
@@ -651,9 +718,9 @@ class ArraySchema {
      * @param thisArg If provided, it will be used as the this value for each invocation of
      * predicate. If it is not provided, undefined is used instead.
      */
-    findIndex(predicate, thisArg) {
+    ArraySchema.prototype.findIndex = function (predicate, thisArg) {
         return Array.from(this.$items.values()).findIndex(predicate, thisArg);
-    }
+    };
     /**
      * Returns the this object after filling the section identified by start and end with value
      * @param value value to fill array section with
@@ -662,12 +729,12 @@ class ArraySchema {
      * @param end index to stop filling the array at. If end is negative, it is treated as
      * length+end.
      */
-    fill(value, start, end) {
+    ArraySchema.prototype.fill = function (value, start, end) {
         //
         // TODO
         //
         throw new Error("ArraySchema#fill() not implemented");
-    }
+    };
     /**
      * Returns the this object after copying a section of the array identified by start and end
      * to the same array starting at position target
@@ -677,48 +744,47 @@ class ArraySchema {
      * is treated as length+end.
      * @param end If not specified, length of the this object is used as its default value.
      */
-    copyWithin(target, start, end) {
+    ArraySchema.prototype.copyWithin = function (target, start, end) {
         //
         // TODO
         //
         throw new Error("ArraySchema#copyWithin() not implemented");
-    }
+    };
     /**
      * Returns a string representation of an array.
      */
-    toString() { return this.$items.toString(); }
+    ArraySchema.prototype.toString = function () { return this.$items.toString(); };
     /**
      * Returns a string representation of an array. The elements are converted to string using their toLocalString methods.
      */
-    toLocaleString() { return this.$items.toLocaleString(); }
-    ;
+    ArraySchema.prototype.toLocaleString = function () { return this.$items.toLocaleString(); };
     /** Iterator */
-    [Symbol.iterator]() {
+    ArraySchema.prototype[Symbol.iterator] = function () {
         return Array.from(this.$items.values())[Symbol.iterator]();
-    }
-    [Symbol.unscopables]() {
+    };
+    ArraySchema.prototype[Symbol.unscopables] = function () {
         return this.$items[Symbol.unscopables]();
-    }
+    };
     /**
      * Returns an iterable of key, value pairs for every entry in the array
      */
-    entries() { return this.$items.entries(); }
+    ArraySchema.prototype.entries = function () { return this.$items.entries(); };
     /**
      * Returns an iterable of keys in the array
      */
-    keys() { return this.$items.keys(); }
+    ArraySchema.prototype.keys = function () { return this.$items.keys(); };
     /**
      * Returns an iterable of values in the array
      */
-    values() { return this.$items.values(); }
+    ArraySchema.prototype.values = function () { return this.$items.values(); };
     /**
      * Determines whether an array includes a certain element, returning true or false as appropriate.
      * @param searchElement The element to search for.
      * @param fromIndex The position in this array at which to begin searching for searchElement.
      */
-    includes(searchElement, fromIndex) {
+    ArraySchema.prototype.includes = function (searchElement, fromIndex) {
         return Array.from(this.$items.values()).includes(searchElement, fromIndex);
-    }
+    };
     /**
      * Calls a defined callback function on each element of an array. Then, flattens the result into
      * a new array.
@@ -730,10 +796,10 @@ class ArraySchema {
      * thisArg is omitted, undefined is used as the this value.
      */
     // @ts-ignore
-    flatMap(callback, thisArg) {
+    ArraySchema.prototype.flatMap = function (callback, thisArg) {
         // @ts-ignore
         throw new Error("ArraySchema#flatMap() is not supported.");
-    }
+    };
     /**
      * Returns a new array with all sub-array elements concatenated into it recursively up to the
      * specified depth.
@@ -741,62 +807,59 @@ class ArraySchema {
      * @param depth The maximum recursion depth
      */
     // @ts-ignore
-    flat(depth) {
+    ArraySchema.prototype.flat = function (depth) {
         // @ts-ignore
         throw new Error("ArraySchema#flat() is not supported.");
-    }
+    };
     // get size () {
     //     return this.$items.size;
     // }
-    setIndex(index, key) {
+    ArraySchema.prototype.setIndex = function (index, key) {
         this.$indexes.set(index, key);
-    }
-    getIndex(index) {
+    };
+    ArraySchema.prototype.getIndex = function (index) {
         return this.$indexes.get(index);
-    }
-    getByIndex(index) {
+    };
+    ArraySchema.prototype.getByIndex = function (index) {
         return this.$items.get(this.$indexes.get(index));
-    }
-    deleteByIndex(index) {
-        const key = this.$indexes.get(index);
+    };
+    ArraySchema.prototype.deleteByIndex = function (index) {
+        var key = this.$indexes.get(index);
         this.$items.delete(key);
         this.$indexes.delete(index);
-    }
-    toArray() {
+    };
+    ArraySchema.prototype.toArray = function () {
         return Array.from(this.$items.values());
-    }
-    toJSON() {
-        return this.toArray().map((value) => {
+    };
+    ArraySchema.prototype.toJSON = function () {
+        return this.toArray().map(function (value) {
             return (typeof (value['toJSON']) === "function")
                 ? value['toJSON']()
                 : value;
         });
-    }
+    };
     //
     // Decoding utilities
     //
-    clone(isDecoding) {
-        let cloned;
+    ArraySchema.prototype.clone = function (isDecoding) {
+        var cloned;
         if (isDecoding) {
-            cloned = new ArraySchema(...Array.from(this.$items.values()));
+            cloned = new (ArraySchema.bind.apply(ArraySchema, __spreadArray([void 0], Array.from(this.$items.values()))))();
         }
         else {
-            cloned = new ArraySchema(...this.map(item => ((item['$changes'])
+            cloned = new (ArraySchema.bind.apply(ArraySchema, __spreadArray([void 0], this.map(function (item) { return ((item['$changes'])
                 ? item.clone()
-                : item)));
+                : item); }))))();
         }
         return cloned;
-    }
-    ;
-    triggerAll() {
-        Schema.prototype.triggerAll.apply(this);
-    }
-}
+    };
+    return ArraySchema;
+}());
 
 function getMapProxy(value) {
     value['$proxy'] = true;
     value = new Proxy(value, {
-        get: (obj, prop) => {
+        get: function (obj, prop) {
             if (typeof (prop) !== "symbol" && // accessing properties
                 typeof (obj[prop]) === "undefined") {
                 return obj.get(prop);
@@ -805,7 +868,7 @@ function getMapProxy(value) {
                 return obj[prop];
             }
         },
-        set: (obj, prop, setValue) => {
+        set: function (obj, prop, setValue) {
             if (typeof (prop) !== "symbol" &&
                 (prop.indexOf("$") === -1 &&
                     prop !== "onAdd" &&
@@ -818,46 +881,62 @@ function getMapProxy(value) {
             }
             return true;
         },
-        deleteProperty: (obj, prop) => {
+        deleteProperty: function (obj, prop) {
             obj.delete(prop);
             return true;
         },
     });
     return value;
 }
-class MapSchema {
-    constructor(initialValues) {
+var MapSchema = /** @class */ (function () {
+    function MapSchema(initialValues) {
+        var _this = this;
         this.$changes = new ChangeTree(this);
         this.$items = new Map();
         this.$indexes = new Map();
         this.$refId = 0;
         if (initialValues) {
             if (initialValues instanceof Map) {
-                initialValues.forEach((v, k) => this.set(k, v));
+                initialValues.forEach(function (v, k) { return _this.set(k, v); });
             }
             else {
-                for (const k in initialValues) {
+                for (var k in initialValues) {
                     this.set(k, initialValues[k]);
                 }
             }
         }
     }
-    static is(type) {
+    MapSchema.prototype.onAdd = function (callback, triggerAll) {
+        if (triggerAll === void 0) { triggerAll = true; }
+        return addCallback((this.$callbacks || (this.$callbacks = [])), exports.OPERATION.ADD, callback, (triggerAll)
+            ? this.$items
+            : undefined);
+    };
+    MapSchema.prototype.onRemove = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.DELETE, callback); };
+    MapSchema.prototype.onChange = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.REPLACE, callback); };
+    MapSchema.is = function (type) {
         return type['map'] !== undefined;
-    }
+    };
     /** Iterator */
-    [Symbol.iterator]() { return this.$items[Symbol.iterator](); }
-    get [Symbol.toStringTag]() { return this.$items[Symbol.toStringTag]; }
-    set(key, value) {
+    MapSchema.prototype[Symbol.iterator] = function () { return this.$items[Symbol.iterator](); };
+    Object.defineProperty(MapSchema.prototype, Symbol.toStringTag, {
+        get: function () { return this.$items[Symbol.toStringTag]; },
+        enumerable: false,
+        configurable: true
+    });
+    MapSchema.prototype.set = function (key, value) {
+        if (value === undefined || value === null) {
+            throw new Error("MapSchema#set('" + key + "', " + value + "): trying to set " + value + " value on '" + key + "'.");
+        }
         // get "index" for this value.
-        const hasIndex = typeof (this.$changes.indexes[key]) !== "undefined";
-        const index = (hasIndex)
+        var hasIndex = typeof (this.$changes.indexes[key]) !== "undefined";
+        var index = (hasIndex)
             ? this.$changes.indexes[key]
             : this.$refId++;
-        let operation = (hasIndex)
+        var operation = (hasIndex)
             ? exports.OPERATION.REPLACE
             : exports.OPERATION.ADD;
-        const isRef = (value['$changes']) !== undefined;
+        var isRef = (value['$changes']) !== undefined;
         if (isRef) {
             value['$changes'].setParent(this, this.$changes.root, index);
         }
@@ -876,11 +955,11 @@ class MapSchema {
         this.$items.set(key, value);
         this.$changes.change(key, operation);
         return this;
-    }
-    get(key) {
+    };
+    MapSchema.prototype.get = function (key) {
         return this.$items.get(key);
-    }
-    delete(key) {
+    };
+    MapSchema.prototype.delete = function (key) {
         //
         // TODO: add a "purge" method after .encode() runs, to cleanup removed `$indexes`
         //
@@ -891,71 +970,77 @@ class MapSchema {
         // // this.$indexes.delete(index);
         this.$changes.delete(key);
         return this.$items.delete(key);
-    }
-    clear(isDecoding) {
+    };
+    MapSchema.prototype.clear = function (changes) {
         // discard previous operations.
         this.$changes.discard(true, true);
         this.$changes.indexes = {};
         // clear previous indexes
         this.$indexes.clear();
-        // flag child items for garbage collection.
-        if (isDecoding && typeof (this.$changes.getType()) !== "string") {
-            this.$items.forEach((item) => {
-                this.$changes.root.removeRef(item['$changes'].refId);
-            });
+        //
+        // When decoding:
+        // - enqueue items for DELETE callback.
+        // - flag child items for garbage collection.
+        //
+        if (changes) {
+            removeChildRefs.call(this, changes);
         }
         // clear items
         this.$items.clear();
         this.$changes.operation({ index: 0, op: exports.OPERATION.CLEAR });
         // touch all structures until reach root
         this.$changes.touchParents();
-    }
-    has(key) {
+    };
+    MapSchema.prototype.has = function (key) {
         return this.$items.has(key);
-    }
-    forEach(callbackfn) {
+    };
+    MapSchema.prototype.forEach = function (callbackfn) {
         this.$items.forEach(callbackfn);
-    }
-    entries() {
+    };
+    MapSchema.prototype.entries = function () {
         return this.$items.entries();
-    }
-    keys() {
+    };
+    MapSchema.prototype.keys = function () {
         return this.$items.keys();
-    }
-    values() {
+    };
+    MapSchema.prototype.values = function () {
         return this.$items.values();
-    }
-    get size() {
-        return this.$items.size;
-    }
-    setIndex(index, key) {
+    };
+    Object.defineProperty(MapSchema.prototype, "size", {
+        get: function () {
+            return this.$items.size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MapSchema.prototype.setIndex = function (index, key) {
         this.$indexes.set(index, key);
-    }
-    getIndex(index) {
+    };
+    MapSchema.prototype.getIndex = function (index) {
         return this.$indexes.get(index);
-    }
-    getByIndex(index) {
+    };
+    MapSchema.prototype.getByIndex = function (index) {
         return this.$items.get(this.$indexes.get(index));
-    }
-    deleteByIndex(index) {
-        const key = this.$indexes.get(index);
+    };
+    MapSchema.prototype.deleteByIndex = function (index) {
+        var key = this.$indexes.get(index);
         this.$items.delete(key);
         this.$indexes.delete(index);
-    }
-    toJSON() {
-        const map = {};
-        this.forEach((value, key) => {
+    };
+    MapSchema.prototype.toJSON = function () {
+        var map = {};
+        this.forEach(function (value, key) {
             map[key] = (typeof (value['toJSON']) === "function")
                 ? value['toJSON']()
                 : value;
         });
         return map;
-    }
+    };
     //
     // Decoding utilities
     //
-    clone(isDecoding) {
-        let cloned;
+    MapSchema.prototype.clone = function (isDecoding) {
+        var cloned;
         if (isDecoding) {
             // client-side
             cloned = Object.assign(new MapSchema(), this);
@@ -963,7 +1048,7 @@ class MapSchema {
         else {
             // server-side
             cloned = new MapSchema();
-            this.forEach((value, key) => {
+            this.forEach(function (value, key) {
                 if (value['$changes']) {
                     cloned.set(key, value['clone']());
                 }
@@ -973,13 +1058,11 @@ class MapSchema {
             });
         }
         return cloned;
-    }
-    triggerAll() {
-        Schema.prototype.triggerAll.apply(this);
-    }
-}
+    };
+    return MapSchema;
+}());
 
-const registeredTypes = {};
+var registeredTypes = {};
 function registerType(identifier, definition) {
     registeredTypes[identifier] = definition;
 }
@@ -987,8 +1070,8 @@ function getType(identifier) {
     return registeredTypes[identifier];
 }
 
-class SchemaDefinition {
-    constructor() {
+var SchemaDefinition = /** @class */ (function () {
+    function SchemaDefinition() {
         //
         // TODO: use a "field" structure combining all these properties per-field.
         //
@@ -997,8 +1080,8 @@ class SchemaDefinition {
         this.deprecated = {};
         this.descriptors = {};
     }
-    static create(parent) {
-        const definition = new SchemaDefinition();
+    SchemaDefinition.create = function (parent) {
+        var definition = new SchemaDefinition();
         // support inheritance
         definition.schema = Object.assign({}, parent && parent.schema || {});
         definition.indexes = Object.assign({}, parent && parent.indexes || {});
@@ -1006,16 +1089,19 @@ class SchemaDefinition {
         definition.descriptors = Object.assign({}, parent && parent.descriptors || {});
         definition.deprecated = Object.assign({}, parent && parent.deprecated || {});
         return definition;
-    }
-    addField(field, type) {
-        const index = this.getNextFieldIndex();
+    };
+    SchemaDefinition.prototype.addField = function (field, type) {
+        var index = this.getNextFieldIndex();
         this.fieldsByIndex[index] = field;
         this.indexes[field] = index;
         this.schema[field] = (Array.isArray(type))
             ? { array: type[0] }
             : type;
-    }
-    addFilter(field, cb) {
+    };
+    SchemaDefinition.prototype.hasField = function (field) {
+        return this.indexes[field] !== undefined;
+    };
+    SchemaDefinition.prototype.addFilter = function (field, cb) {
         if (!this.filters) {
             this.filters = {};
             this.indexesWithFilters = [];
@@ -1023,10 +1109,10 @@ class SchemaDefinition {
         this.filters[this.indexes[field]] = cb;
         this.indexesWithFilters.push(this.indexes[field]);
         return true;
-    }
-    addChildrenFilter(field, cb) {
-        const index = this.indexes[field];
-        const type = this.schema[field];
+    };
+    SchemaDefinition.prototype.addChildrenFilter = function (field, cb) {
+        var index = this.indexes[field];
+        var type = this.schema[field];
         if (getType(Object.keys(type)[0])) {
             if (!this.childFilters) {
                 this.childFilters = {};
@@ -1035,52 +1121,74 @@ class SchemaDefinition {
             return true;
         }
         else {
-            console.warn(`@filterChildren: field '${field}' can't have children. Ignoring filter.`);
+            console.warn("@filterChildren: field '" + field + "' can't have children. Ignoring filter.");
         }
-    }
-    getChildrenFilter(field) {
+    };
+    SchemaDefinition.prototype.getChildrenFilter = function (field) {
         return this.childFilters && this.childFilters[this.indexes[field]];
-    }
-    getNextFieldIndex() {
+    };
+    SchemaDefinition.prototype.getNextFieldIndex = function () {
         return Object.keys(this.schema || {}).length;
-    }
-}
+    };
+    return SchemaDefinition;
+}());
 function hasFilter(klass) {
     return klass._context && klass._context.useFilters;
 }
-class Context {
-    constructor() {
+var Context = /** @class */ (function () {
+    function Context() {
         this.types = {};
         this.schemas = new Map();
         this.useFilters = false;
     }
-    has(schema) {
+    Context.prototype.has = function (schema) {
         return this.schemas.has(schema);
-    }
-    get(typeid) {
+    };
+    Context.prototype.get = function (typeid) {
         return this.types[typeid];
-    }
-    add(schema, typeid = this.schemas.size) {
+    };
+    Context.prototype.add = function (schema, typeid) {
+        if (typeid === void 0) { typeid = this.schemas.size; }
         // FIXME: move this to somewhere else?
         // support inheritance
         schema._definition = SchemaDefinition.create(schema._definition);
         schema._typeid = typeid;
         this.types[typeid] = schema;
         this.schemas.set(schema, typeid);
-    }
-    static create(context = new Context) {
+    };
+    Context.create = function (options) {
+        if (options === void 0) { options = {}; }
         return function (definition) {
-            return type(definition, context);
+            if (!options.context) {
+                options.context = new Context();
+            }
+            return type(definition, options);
         };
-    }
-}
-const globalContext = new Context();
+    };
+    return Context;
+}());
+var globalContext = new Context();
 /**
- * `@type()` decorator for proxies
+ * [See documentation](https://docs.colyseus.io/state/schema/)
+ *
+ * Annotate a Schema property to be serializeable.
+ * \@type()'d fields are automatically flagged as "dirty" for the next patch.
+ *
+ * @example Standard usage, with automatic change tracking.
+ * ```
+ * \@type("string") propertyName: string;
+ * ```
+ *
+ * @example You can provide the "manual" option if you'd like to manually control your patches via .setDirty().
+ * ```
+ * \@type("string", { manual: true })
+ * ```
  */
-function type(type, context = globalContext) {
+function type(type, options) {
+    if (options === void 0) { options = {}; }
     return function (target, field) {
-        const constructor = target.constructor;
+        var context = options.context || globalContext;
+        var constructor = target.constructor;
         constructor._context = context;
         /*
          * static schema
@@ -1088,26 +1196,49 @@ function type(type, context = globalContext) {
         if (!context.has(constructor)) {
             context.add(constructor);
         }
-        const definition = constructor._definition;
+        var definition = constructor._definition;
         definition.addField(field, type);
         /**
          * skip if descriptor already exists for this field (`@deprecated()`)
          */
         if (definition.descriptors[field]) {
-            return;
+            if (definition.deprecated[field]) {
+                // do not create accessors for deprecated properties.
+                return;
+            }
+            else {
+                // trying to define same property multiple times across inheritance.
+                // https://github.com/colyseus/colyseus-unity3d/issues/131#issuecomment-814308572
+                try {
+                    throw new Error("@colyseus/schema: Duplicate '" + field + "' definition on '" + constructor.name + "'.\nCheck @type() annotation");
+                }
+                catch (e) {
+                    var definitionAtLine = e.stack.split("\n")[4].trim();
+                    throw new Error(e.message + " " + definitionAtLine);
+                }
+            }
         }
-        const isArray = ArraySchema.is(type);
-        const isMap = !isArray && MapSchema.is(type);
+        var isArray = ArraySchema.is(type);
+        var isMap = !isArray && MapSchema.is(type);
         // TODO: refactor me.
         // Allow abstract intermediary classes with no fields to be serialized
         // (See "should support an inheritance with a Schema type without fields" test)
         if (typeof (type) !== "string" && !Schema.is(type)) {
-            const childType = Object.values(type)[0];
+            var childType = Object.values(type)[0];
             if (typeof (childType) !== "string" && !context.has(childType)) {
                 context.add(childType);
             }
         }
-        const fieldCached = `_${field}`;
+        if (options.manual) {
+            // do not declare getter/setter descriptor
+            definition.descriptors[field] = {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            };
+            return;
+        }
+        var fieldCached = "_" + field;
         definition.descriptors[fieldCached] = {
             enumerable: false,
             configurable: false,
@@ -1129,7 +1260,7 @@ function type(type, context = globalContext) {
                     value !== null) {
                     // automaticallty transform Array into ArraySchema
                     if (isArray && !(value instanceof ArraySchema)) {
-                        value = new ArraySchema(...value);
+                        value = new (ArraySchema.bind.apply(ArraySchema, __spreadArray([void 0], value)))();
                     }
                     // automaticallty transform Map into MapSchema
                     if (isMap && !(value instanceof MapSchema)) {
@@ -1172,8 +1303,8 @@ function type(type, context = globalContext) {
  */
 function filter(cb) {
     return function (target, field) {
-        const constructor = target.constructor;
-        const definition = constructor._definition;
+        var constructor = target.constructor;
+        var definition = constructor._definition;
         if (definition.addFilter(field, cb)) {
             constructor._context.useFilters = true;
         }
@@ -1181,8 +1312,8 @@ function filter(cb) {
 }
 function filterChildren(cb) {
     return function (target, field) {
-        const constructor = target.constructor;
-        const definition = constructor._definition;
+        var constructor = target.constructor;
+        var definition = constructor._definition;
         if (definition.addChildrenFilter(field, cb)) {
             constructor._context.useFilters = true;
         }
@@ -1192,14 +1323,15 @@ function filterChildren(cb) {
  * `@deprecated()` flag a field as deprecated.
  * The previous `@type()` annotation should remain along with this one.
  */
-function deprecated(throws = true, context = globalContext) {
+function deprecated(throws) {
+    if (throws === void 0) { throws = true; }
     return function (target, field) {
-        const constructor = target.constructor;
-        const definition = constructor._definition;
+        var constructor = target.constructor;
+        var definition = constructor._definition;
         definition.deprecated[field] = true;
         if (throws) {
             definition.descriptors[field] = {
-                get: function () { throw new Error(`${field} is deprecated.`); },
+                get: function () { throw new Error(field + " is deprecated."); },
                 set: function (value) { },
                 enumerable: false,
                 configurable: true
@@ -1207,9 +1339,13 @@ function deprecated(throws = true, context = globalContext) {
         }
     };
 }
-function defineTypes(target, fields, context = target._context || globalContext) {
-    for (let field in fields) {
-        type(fields[field], context)(target.prototype, field);
+function defineTypes(target, fields, options) {
+    if (options === void 0) { options = {}; }
+    if (!options.context) {
+        options.context = target._context || options.context || globalContext;
+    }
+    for (var field in fields) {
+        type(fields[field], options)(target.prototype, field);
     }
     return target;
 }
@@ -1307,24 +1443,24 @@ function int32$1(bytes, value) {
     bytes.push((value >> 24) & 255);
 }
 function uint32$1(bytes, value) {
-    const b4 = value >> 24;
-    const b3 = value >> 16;
-    const b2 = value >> 8;
-    const b1 = value;
+    var b4 = value >> 24;
+    var b3 = value >> 16;
+    var b2 = value >> 8;
+    var b1 = value;
     bytes.push(b1 & 255);
     bytes.push(b2 & 255);
     bytes.push(b3 & 255);
     bytes.push(b4 & 255);
 }
 function int64$1(bytes, value) {
-    const high = Math.floor(value / Math.pow(2, 32));
-    const low = value >>> 0;
+    var high = Math.floor(value / Math.pow(2, 32));
+    var low = value >>> 0;
     uint32$1(bytes, low);
     uint32$1(bytes, high);
 }
 function uint64$1(bytes, value) {
-    const high = (value / Math.pow(2, 32)) >> 0;
-    const low = value >>> 0;
+    var high = (value / Math.pow(2, 32)) >> 0;
+    var low = value >>> 0;
     uint32$1(bytes, low);
     uint32$1(bytes, high);
 }
@@ -1334,9 +1470,9 @@ function float32$1(bytes, value) {
 function float64$1(bytes, value) {
     writeFloat64(bytes, value);
 }
-const _int32$1 = new Int32Array(2);
-const _float32$1 = new Float32Array(_int32$1.buffer);
-const _float64$1 = new Float64Array(_int32$1.buffer);
+var _int32$1 = new Int32Array(2);
+var _float32$1 = new Float32Array(_int32$1.buffer);
+var _float64$1 = new Float64Array(_int32$1.buffer);
 function writeFloat32(bytes, value) {
     _float32$1[0] = value;
     int32$1(bytes, _int32$1[0]);
@@ -1354,8 +1490,8 @@ function string$1(bytes, value) {
     if (!value) {
         value = "";
     }
-    let length = utf8Length(value);
-    let size = 0;
+    var length = utf8Length(value);
+    var size = 0;
     // fixstr
     if (length < 0x20) {
         bytes.push(length | 0xa0);
@@ -1569,18 +1705,18 @@ 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);
+    var low = uint32(bytes, it);
+    var 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);
+    var low = uint32(bytes, it);
+    var 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);
+var _int32 = new Int32Array(2);
+var _float32 = new Float32Array(_int32.buffer);
+var _float64 = new Float64Array(_int32.buffer);
 function readFloat32(bytes, it) {
     _int32[0] = int32(bytes, it);
     return _float32[0];
@@ -1594,8 +1730,8 @@ function boolean(bytes, it) {
     return uint8(bytes, it) > 0;
 }
 function string(bytes, it) {
-    const prefix = bytes[it.offset++];
-    let length;
+    var prefix = bytes[it.offset++];
+    var length;
     if (prefix < 0xc0) {
         // fixstr
         length = prefix & 0x1f;
@@ -1609,12 +1745,12 @@ function string(bytes, it) {
     else if (prefix === 0xdb) {
         length = uint32(bytes, it);
     }
-    const value = utf8Read(bytes, it.offset, length);
+    var value = utf8Read(bytes, it.offset, length);
     it.offset += length;
     return value;
 }
 function stringCheck(bytes, it) {
-    const prefix = bytes[it.offset];
+    var prefix = bytes[it.offset];
     return (
     // fixstr
     (prefix < 0xc0 && prefix > 0xa0) ||
@@ -1626,7 +1762,7 @@ function stringCheck(bytes, it) {
         prefix === 0xdb);
 }
 function number(bytes, it) {
-    const prefix = bytes[it.offset++];
+    var prefix = bytes[it.offset++];
     if (prefix < 0x80) {
         // positive fixint
         return prefix;
@@ -1677,7 +1813,7 @@ function number(bytes, it) {
     }
 }
 function numberCheck(bytes, it) {
-    const prefix = bytes[it.offset];
+    var prefix = bytes[it.offset];
     // positive fixint - 0x00 - 0x7f
     // float 32        - 0xca
     // float 64        - 0xcb
@@ -1736,23 +1872,32 @@ var decode = /*#__PURE__*/Object.freeze({
     switchStructureCheck: switchStructureCheck
 });
 
-class CollectionSchema {
-    constructor(initialValues) {
+var CollectionSchema = /** @class */ (function () {
+    function CollectionSchema(initialValues) {
+        var _this = this;
         this.$changes = new ChangeTree(this);
         this.$items = new Map();
         this.$indexes = new Map();
         this.$refId = 0;
         if (initialValues) {
-            initialValues.forEach((v) => this.add(v));
+            initialValues.forEach(function (v) { return _this.add(v); });
         }
     }
-    static is(type) {
+    CollectionSchema.prototype.onAdd = function (callback, triggerAll) {
+        if (triggerAll === void 0) { triggerAll = true; }
+        return addCallback((this.$callbacks || (this.$callbacks = [])), exports.OPERATION.ADD, callback, (triggerAll)
+            ? this.$items
+            : undefined);
+    };
+    CollectionSchema.prototype.onRemove = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.DELETE, callback); };
+    CollectionSchema.prototype.onChange = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.REPLACE, callback); };
+    CollectionSchema.is = function (type) {
         return type['collection'] !== undefined;
-    }
-    add(value) {
+    };
+    CollectionSchema.prototype.add = function (value) {
         // set "index" for reference.
-        const index = this.$refId++;
-        const isRef = (value['$changes']) !== undefined;
+        var index = this.$refId++;
+        var isRef = (value['$changes']) !== undefined;
         if (isRef) {
             value['$changes'].setParent(this, this.$changes.root, index);
         }
@@ -1761,18 +1906,18 @@ class CollectionSchema {
         this.$items.set(index, value);
         this.$changes.change(index);
         return index;
-    }
-    at(index) {
-        const key = Array.from(this.$items.keys())[index];
+    };
+    CollectionSchema.prototype.at = function (index) {
+        var key = Array.from(this.$items.keys())[index];
         return this.$items.get(key);
-    }
-    entries() {
+    };
+    CollectionSchema.prototype.entries = function () {
         return this.$items.entries();
-    }
-    delete(item) {
-        const entries = this.$items.entries();
-        let index;
-        let entry;
+    };
+    CollectionSchema.prototype.delete = function (item) {
+        var entries = this.$items.entries();
+        var index;
+        var entry;
         while (entry = entries.next()) {
             if (entry.done) {
                 break;
@@ -1788,68 +1933,75 @@ class CollectionSchema {
         this.$changes.delete(index);
         this.$indexes.delete(index);
         return this.$items.delete(index);
-    }
-    clear(isDecoding) {
+    };
+    CollectionSchema.prototype.clear = function (changes) {
         // discard previous operations.
         this.$changes.discard(true, true);
         this.$changes.indexes = {};
         // clear previous indexes
         this.$indexes.clear();
-        // flag child items for garbage collection.
-        if (isDecoding && typeof (this.$changes.getType()) !== "string") {
-            this.$items.forEach((item) => {
-                this.$changes.root.removeRef(item['$changes'].refId);
-            });
+        //
+        // When decoding:
+        // - enqueue items for DELETE callback.
+        // - flag child items for garbage collection.
+        //
+        if (changes) {
+            removeChildRefs.call(this, changes);
         }
         // clear items
         this.$items.clear();
         this.$changes.operation({ index: 0, op: exports.OPERATION.CLEAR });
         // touch all structures until reach root
         this.$changes.touchParents();
-    }
-    has(value) {
-        return Array.from(this.$items.values()).some((v) => v === value);
-    }
-    forEach(callbackfn) {
-        this.$items.forEach((value, key, _) => callbackfn(value, key, this));
-    }
-    values() {
+    };
+    CollectionSchema.prototype.has = function (value) {
+        return Array.from(this.$items.values()).some(function (v) { return v === value; });
+    };
+    CollectionSchema.prototype.forEach = function (callbackfn) {
+        var _this = this;
+        this.$items.forEach(function (value, key, _) { return callbackfn(value, key, _this); });
+    };
+    CollectionSchema.prototype.values = function () {
         return this.$items.values();
-    }
-    get size() {
-        return this.$items.size;
-    }
-    setIndex(index, key) {
+    };
+    Object.defineProperty(CollectionSchema.prototype, "size", {
+        get: function () {
+            return this.$items.size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CollectionSchema.prototype.setIndex = function (index, key) {
         this.$indexes.set(index, key);
-    }
-    getIndex(index) {
+    };
+    CollectionSchema.prototype.getIndex = function (index) {
         return this.$indexes.get(index);
-    }
-    getByIndex(index) {
+    };
+    CollectionSchema.prototype.getByIndex = function (index) {
         return this.$items.get(this.$indexes.get(index));
-    }
-    deleteByIndex(index) {
-        const key = this.$indexes.get(index);
+    };
+    CollectionSchema.prototype.deleteByIndex = function (index) {
+        var key = this.$indexes.get(index);
         this.$items.delete(key);
         this.$indexes.delete(index);
-    }
-    toArray() {
+    };
+    CollectionSchema.prototype.toArray = function () {
         return Array.from(this.$items.values());
-    }
-    toJSON() {
-        const values = [];
-        this.forEach((value, key) => {
+    };
+    CollectionSchema.prototype.toJSON = function () {
+        var values = [];
+        this.forEach(function (value, key) {
             values.push((typeof (value['toJSON']) === "function")
                 ? value['toJSON']()
                 : value);
         });
         return values;
-    }
+    };
     //
     // Decoding utilities
     //
-    clone(isDecoding) {
-        let cloned;
+    CollectionSchema.prototype.clone = function (isDecoding) {
+        var cloned;
         if (isDecoding) {
             // client-side
             cloned = Object.assign(new CollectionSchema(), this);
@@ -1857,7 +2009,7 @@ class CollectionSchema {
         else {
             // server-side
             cloned = new CollectionSchema();
-            this.forEach((value) => {
+            this.forEach(function (value) {
                 if (value['$changes']) {
                     cloned.add(value['clone']());
                 }
@@ -1867,48 +2019,57 @@ class CollectionSchema {
             });
         }
         return cloned;
-    }
-    triggerAll() {
-        Schema.prototype.triggerAll.apply(this);
-    }
-}
+    };
+    return CollectionSchema;
+}());
 
-class SetSchema {
-    constructor(initialValues) {
+var SetSchema = /** @class */ (function () {
+    function SetSchema(initialValues) {
+        var _this = this;
         this.$changes = new ChangeTree(this);
         this.$items = new Map();
         this.$indexes = new Map();
         this.$refId = 0;
         if (initialValues) {
-            initialValues.forEach((v) => this.add(v));
+            initialValues.forEach(function (v) { return _this.add(v); });
         }
     }
-    static is(type) {
+    SetSchema.prototype.onAdd = function (callback, triggerAll) {
+        if (triggerAll === void 0) { triggerAll = true; }
+        return addCallback((this.$callbacks || (this.$callbacks = [])), exports.OPERATION.ADD, callback, (triggerAll)
+            ? this.$items
+            : undefined);
+    };
+    SetSchema.prototype.onRemove = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.DELETE, callback); };
+    SetSchema.prototype.onChange = function (callback) { return addCallback(this.$callbacks || (this.$callbacks = []), exports.OPERATION.REPLACE, callback); };
+    SetSchema.is = function (type) {
         return type['set'] !== undefined;
-    }
-    add(value) {
+    };
+    SetSchema.prototype.add = function (value) {
+        var _a, _b;
+        // immediatelly return false if value already added.
         if (this.has(value)) {
             return false;
         }
         // set "index" for reference.
-        const index = this.$refId++;
-        const isRef = (value['$changes']) !== undefined;
-        if (isRef) {
+        var index = this.$refId++;
+        if ((value['$changes']) !== undefined) {
             value['$changes'].setParent(this, this.$changes.root, index);
         }
+        var operation = (_b = (_a = this.$changes.indexes[index]) === null || _a === void 0 ? void 0 : _a.op) !== null && _b !== void 0 ? _b : exports.OPERATION.ADD;
         this.$changes.indexes[index] = index;
         this.$indexes.set(index, index);
         this.$items.set(index, value);
-        this.$changes.change(index);
+        this.$changes.change(index, operation);
         return index;
-    }
-    entries() {
+    };
+    SetSchema.prototype.entries = function () {
         return this.$items.entries();
-    }
-    delete(item) {
-        const entries = this.$items.entries();
-        let index;
-        let entry;
+    };
+    SetSchema.prototype.delete = function (item) {
+        var entries = this.$items.entries();
+        var index;
+        var entry;
         while (entry = entries.next()) {
             if (entry.done) {
                 break;
@@ -1924,29 +2085,31 @@ class SetSchema {
         this.$changes.delete(index);
         this.$indexes.delete(index);
         return this.$items.delete(index);
-    }
-    clear(isDecoding) {
+    };
+    SetSchema.prototype.clear = function (changes) {
         // discard previous operations.
         this.$changes.discard(true, true);
         this.$changes.indexes = {};
         // clear previous indexes
         this.$indexes.clear();
-        // flag child items for garbage collection.
-        if (isDecoding && typeof (this.$changes.getType()) !== "string") {
-            this.$items.forEach((item) => {
-                this.$changes.root.removeRef(item['$changes'].refId);
-            });
+        //
+        // When decoding:
+        // - enqueue items for DELETE callback.
+        // - flag child items for garbage collection.
+        //
+        if (changes) {
+            removeChildRefs.call(this, changes);
         }
         // clear items
         this.$items.clear();
         this.$changes.operation({ index: 0, op: exports.OPERATION.CLEAR });
         // touch all structures until reach root
         this.$changes.touchParents();
-    }
-    has(value) {
-        const values = this.$items.values();
-        let has = false;
-        let entry;
+    };
+    SetSchema.prototype.has = function (value) {
+        var values = this.$items.values();
+        var has = false;
+        var entry;
         while (entry = values.next()) {
             if (entry.done) {
                 break;
@@ -1957,47 +2120,52 @@ class SetSchema {
             }
         }
         return has;
-    }
-    forEach(callbackfn) {
-        this.$items.forEach((value, key, _) => callbackfn(value, key, this));
-    }
-    values() {
+    };
+    SetSchema.prototype.forEach = function (callbackfn) {
+        var _this = this;
+        this.$items.forEach(function (value, key, _) { return callbackfn(value, key, _this); });
+    };
+    SetSchema.prototype.values = function () {
         return this.$items.values();
-    }
-    get size() {
-        return this.$items.size;
-    }
-    setIndex(index, key) {
+    };
+    Object.defineProperty(SetSchema.prototype, "size", {
+        get: function () {
+            return this.$items.size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SetSchema.prototype.setIndex = function (index, key) {
         this.$indexes.set(index, key);
-    }
-    getIndex(index) {
+    };
+    SetSchema.prototype.getIndex = function (index) {
         return this.$indexes.get(index);
-    }
-    getByIndex(index) {
+    };
+    SetSchema.prototype.getByIndex = function (index) {
         return this.$items.get(this.$indexes.get(index));
-    }
-    deleteByIndex(index) {
-        const key = this.$indexes.get(index);
+    };
+    SetSchema.prototype.deleteByIndex = function (index) {
+        var key = this.$indexes.get(index);
         this.$items.delete(key);
         this.$indexes.delete(index);
-    }
-    toArray() {
+    };
+    SetSchema.prototype.toArray = function () {
         return Array.from(this.$items.values());
-    }
-    toJSON() {
-        const values = [];
-        this.forEach((value, key) => {
+    };
+    SetSchema.prototype.toJSON = function () {
+        var values = [];
+        this.forEach(function (value, key) {
             values.push((typeof (value['toJSON']) === "function")
                 ? value['toJSON']()
                 : value);
         });
         return values;
-    }
+    };
     //
     // Decoding utilities
     //
-    clone(isDecoding) {
-        let cloned;
+    SetSchema.prototype.clone = function (isDecoding) {
+        var cloned;
         if (isDecoding) {
             // client-side
             cloned = Object.assign(new SetSchema(), this);
@@ -2005,7 +2173,7 @@ class SetSchema {
         else {
             // server-side
             cloned = new SetSchema();
-            this.forEach((value) => {
+            this.forEach(function (value) {
                 if (value['$changes']) {
                     cloned.add(value['clone']());
                 }
@@ -2015,64 +2183,113 @@ class SetSchema {
             });
         }
         return cloned;
-    }
-    triggerAll() {
-        Schema.prototype.triggerAll.apply(this);
-    }
-}
-
-/**
- * Extracted from https://www.npmjs.com/package/strong-events
- */
-class EventEmitter {
-    constructor() {
-        this.handlers = [];
-    }
-    register(cb, once = false) {
-        this.handlers.push(cb);
-        return this;
-    }
-    invoke(...args) {
-        this.handlers.forEach((handler) => handler(...args));
-    }
-    invokeAsync(...args) {
-        return Promise.all(this.handlers.map((handler) => handler(...args)));
-    }
-    remove(cb) {
-        const index = this.handlers.indexOf(cb);
-        this.handlers[index] = this.handlers[this.handlers.length - 1];
-        this.handlers.pop();
-    }
-    clear() {
-        this.handlers = [];
-    }
-}
+    };
+    return SetSchema;
+}());
 
-class ClientState {
-    constructor() {
+var ClientState = /** @class */ (function () {
+    function ClientState() {
         this.refIds = new WeakSet();
         this.containerIndexes = new WeakMap();
     }
     // containerIndexes = new Map<ChangeTree, Set<number>>();
-    addRefId(changeTree) {
+    ClientState.prototype.addRefId = function (changeTree) {
         if (!this.refIds.has(changeTree)) {
             this.refIds.add(changeTree);
             this.containerIndexes.set(changeTree, new Set());
         }
-    }
-    static get(client) {
+    };
+    ClientState.get = function (client) {
         if (client.$filterState === undefined) {
             client.$filterState = new ClientState();
         }
         return client.$filterState;
+    };
+    return ClientState;
+}());
+
+var ReferenceTracker = /** @class */ (function () {
+    function ReferenceTracker() {
+        //
+        // Relation of refId => Schema structure
+        // For direct access of structures during decoding time.
+        //
+        this.refs = new Map();
+        this.refCounts = {};
+        this.deletedRefs = new Set();
+        this.nextUniqueId = 0;
     }
-}
+    ReferenceTracker.prototype.getNextUniqueId = function () {
+        return this.nextUniqueId++;
+    };
+    // for decoding
+    ReferenceTracker.prototype.addRef = function (refId, ref, incrementCount) {
+        if (incrementCount === void 0) { incrementCount = true; }
+        this.refs.set(refId, ref);
+        if (incrementCount) {
+            this.refCounts[refId] = (this.refCounts[refId] || 0) + 1;
+        }
+    };
+    // for decoding
+    ReferenceTracker.prototype.removeRef = function (refId) {
+        this.refCounts[refId] = this.refCounts[refId] - 1;
+        this.deletedRefs.add(refId);
+    };
+    ReferenceTracker.prototype.clearRefs = function () {
+        this.refs.clear();
+        this.deletedRefs.clear();
+        this.refCounts = {};
+    };
+    // for decoding
+    ReferenceTracker.prototype.garbageCollectDeletedRefs = function () {
+        var _this = this;
+        this.deletedRefs.forEach(function (refId) {
+            //
+            // Skip active references.
+            //
+            if (_this.refCounts[refId] > 0) {
+                return;
+            }
+            var ref = _this.refs.get(refId);
+            //
+            // Ensure child schema instances have their references removed as well.
+            //
+            if (ref instanceof Schema) {
+                for (var fieldName in ref['_definition'].schema) {
+                    if (typeof (ref['_definition'].schema[fieldName]) !== "string" &&
+                        ref[fieldName] &&
+                        ref[fieldName]['$changes']) {
+                        _this.removeRef(ref[fieldName]['$changes'].refId);
+                    }
+                }
+            }
+            else {
+                var definition = ref['$changes'].parent._definition;
+                var type = definition.schema[definition.fieldsByIndex[ref['$changes'].parentIndex]];
+                if (typeof (Object.values(type)[0]) === "function") {
+                    Array.from(ref.values())
+                        .forEach(function (child) { return _this.removeRef(child['$changes'].refId); });
+                }
+            }
+            _this.refs.delete(refId);
+            delete _this.refCounts[refId];
+        });
+        // clear deleted refs.
+        this.deletedRefs.clear();
+    };
+    return ReferenceTracker;
+}());
 
-class EncodeSchemaError extends Error {
-}
+var EncodeSchemaError = /** @class */ (function (_super) {
+    __extends(EncodeSchemaError, _super);
+    function EncodeSchemaError() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return EncodeSchemaError;
+}(Error));
 function assertType(value, type, klass, field) {
-    let typeofTarget;
-    let allowNull = false;
+    var typeofTarget;
+    var allowNull = false;
     switch (type) {
         case "number":
         case "int8":
@@ -2087,7 +2304,7 @@ function assertType(value, type, klass, field) {
         case "float64":
             typeofTarget = "number";
             if (isNaN(value)) {
-                console.log(`trying to encode "NaN" in ${klass.constructor.name}#${field}`);
+                console.log("trying to encode \"NaN\" in " + klass.constructor.name + "#" + field);
             }
             break;
         case "string":
@@ -2099,23 +2316,23 @@ function assertType(value, type, klass, field) {
             return;
     }
     if (typeof (value) !== typeofTarget && (!allowNull || (allowNull && value !== null))) {
-        let foundValue = `'${JSON.stringify(value)}'${(value && value.constructor && ` (${value.constructor.name})`) || ''}`;
-        throw new EncodeSchemaError(`a '${typeofTarget}' was expected, but ${foundValue} was provided in ${klass.constructor.name}#${field}`);
+        var foundValue = "'" + JSON.stringify(value) + "'" + ((value && value.constructor && " (" + value.constructor.name + ")") || '');
+        throw new EncodeSchemaError("a '" + typeofTarget + "' was expected, but " + foundValue + " was provided in " + klass.constructor.name + "#" + field);
     }
 }
 function assertInstanceType(value, type, klass, field) {
     if (!(value instanceof type)) {
-        throw new EncodeSchemaError(`a '${type.name}' was expected, but '${value.constructor.name}' was provided in ${klass.constructor.name}#${field}`);
+        throw new EncodeSchemaError("a '" + type.name + "' was expected, but '" + value.constructor.name + "' was provided in " + klass.constructor.name + "#" + field);
     }
 }
 function encodePrimitiveType(type, bytes, value, klass, field) {
     assertType(value, type, klass, field);
-    const encodeFunc = encode[type];
+    var encodeFunc = encode[type];
     if (encodeFunc) {
         encodeFunc(bytes, value);
     }
     else {
-        throw new EncodeSchemaError(`a '${type}' was expected, but ${value} was provided in ${klass.constructor.name}#${field}`);
+        throw new EncodeSchemaError("a '" + type + "' was expected, but " + value + " was provided in " + klass.constructor.name + "#" + field);
     }
 }
 function decodePrimitiveType(type, bytes, it) {
@@ -2124,23 +2341,32 @@ function decodePrimitiveType(type, bytes, it) {
 /**
  * Schema encoder / decoder
  */
-class Schema {
+var Schema = /** @class */ (function () {
     // allow inherited classes to have a constructor
-    constructor(...args) {
+    function Schema() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
         // fix enumerability of fields for end-user
         Object.defineProperties(this, {
             $changes: {
-                value: new ChangeTree(this, undefined, new Root()),
+                value: new ChangeTree(this, undefined, new ReferenceTracker()),
                 enumerable: false,
                 writable: true
             },
-            $listeners: {
-                value: {},
+            // $listeners: {
+            //     value: undefined,
+            //     enumerable: false,
+            //     writable: true
+            // },
+            $callbacks: {
+                value: undefined,
                 enumerable: false,
                 writable: true
             },
         });
-        const descriptors = this._definition.descriptors;
+        var descriptors = this._definition.descriptors;
         if (descriptors) {
             Object.defineProperties(this, descriptors);
         }
@@ -2151,53 +2377,74 @@ class Schema {
             this.assign(args[0]);
         }
     }
-    static onError(e) {
+    Schema.onError = function (e) {
         console.error(e);
-    }
-    static is(type) {
+    };
+    Schema.is = function (type) {
         return (type['_definition'] &&
             type['_definition'].schema !== undefined);
-    }
-    assign(props) {
+    };
+    Schema.prototype.onChange = function (callback) {
+        return addCallback((this.$callbacks || (this.$callbacks = [])), exports.OPERATION.REPLACE, callback);
+    };
+    Schema.prototype.onRemove = function (callback) {
+        return addCallback((this.$callbacks || (this.$callbacks = [])), exports.OPERATION.DELETE, callback);
+    };
+    Schema.prototype.assign = function (props) {
         Object.assign(this, props);
         return this;
-    }
-    get _definition() { return this.constructor._definition; }
-    listen(attr, callback) {
-        if (!this.$listeners[attr]) {
-            this.$listeners[attr] = new EventEmitter();
+    };
+    Object.defineProperty(Schema.prototype, "_definition", {
+        get: function () { return this.constructor._definition; },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * (Server-side): Flag a property to be encoded for the next patch.
+     * @param instance Schema instance
+     * @param property string representing the property name, or number representing the index of the property.
+     * @param operation OPERATION to perform (detected automatically)
+     */
+    Schema.prototype.setDirty = function (property, operation) {
+        this.$changes.change(property, operation);
+    };
+    Schema.prototype.listen = function (attr, callback) {
+        var _this = this;
+        if (!this.$callbacks) {
+            this.$callbacks = {};
+        }
+        if (!this.$callbacks[attr]) {
+            this.$callbacks[attr] = [];
         }
-        this.$listeners[attr].register(callback);
+        this.$callbacks[attr].push(callback);
         // return un-register callback.
-        return () => this.$listeners[attr].remove(callback);
-    }
-    decode(bytes, it = { offset: 0 }, ref = this, allChanges = new Map()) {
-        const $root = this.$changes.root;
-        const totalBytes = bytes.length;
-        let refId = 0;
-        let changes = [];
+        return function () { return spliceOne(_this.$callbacks[attr], _this.$callbacks[attr].indexOf(callback)); };
+    };
+    Schema.prototype.decode = function (bytes, it, ref) {
+        if (it === void 0) { it = { offset: 0 }; }
+        if (ref === void 0) { ref = this; }
+        var allChanges = [];
+        var $root = this.$changes.root;
+        var totalBytes = bytes.length;
+        var refId = 0;
         $root.refs.set(refId, this);
-        allChanges.set(refId, changes);
         while (it.offset < totalBytes) {
-            let byte = bytes[it.offset++];
+            var byte = bytes[it.offset++];
             if (byte == SWITCH_TO_STRUCTURE) {
                 refId = number(bytes, it);
-                const nextRef = $root.refs.get(refId);
+                var nextRef = $root.refs.get(refId);
                 //
                 // Trying to access a reference that haven't been decoded yet.
                 //
                 if (!nextRef) {
-                    throw new Error(`"refId" not found: ${refId}`);
+                    throw new Error("\"refId\" not found: " + refId);
                 }
                 ref = nextRef;
-                // create empty list of changes for this refId.
-                changes = [];
-                allChanges.set(refId, changes);
                 continue;
             }
-            const changeTree = ref['$changes'];
-            const isSchema = (ref['_definition'] !== undefined);
-            const operation = (isSchema)
+            var changeTree = ref['$changes'];
+            var isSchema = (ref['_definition'] !== undefined);
+            var operation = (isSchema)
                 ? (byte >> 6) << 6 // "compressed" index + operation
                 : byte; // "uncompressed" index + operation (array/map items)
             if (operation === exports.OPERATION.CLEAR) {
@@ -2206,19 +2453,19 @@ class Schema {
                 // The `.clear()` method is calling `$root.removeRef(refId)` for
                 // each item inside this collection
                 //
-                ref.clear(true);
+                ref.clear(allChanges);
                 continue;
             }
-            const fieldIndex = (isSchema)
+            var fieldIndex = (isSchema)
                 ? byte % (operation || 255) // if "REPLACE" operation (0), use 255
                 : number(bytes, it);
-            const fieldName = (isSchema)
+            var fieldName = (isSchema)
                 ? (ref['_definition'].fieldsByIndex[fieldIndex])
                 : "";
-            let type = changeTree.getType(fieldIndex);
-            let value;
-            let previousValue;
-            let dynamicIndex;
+            var type = changeTree.getType(fieldIndex);
+            var value = void 0;
+            var previousValue = void 0;
+            var dynamicIndex = void 0;
             if (!isSchema) {
                 previousValue = ref['getByIndex'](fieldIndex);
                 if ((operation & exports.OPERATION.ADD) === exports.OPERATION.ADD) { // ADD or DELETE_AND_ADD
@@ -2233,7 +2480,7 @@ class Schema {
                 }
             }
             else {
-                previousValue = ref[`_${fieldName}`];
+                previousValue = ref["_" + fieldName];
             }
             //
             // Delete operations
@@ -2254,7 +2501,7 @@ class Schema {
                 // keep skipping next bytes until reaches a known structure
                 // by local decoder.
                 //
-                const nextIterator = { offset: it.offset };
+                var nextIterator = { offset: it.offset };
                 while (it.offset < totalBytes) {
                     if (switchStructureCheck(bytes, it)) {
                         nextIterator.offset = it.offset + 1;
@@ -2268,24 +2515,23 @@ class Schema {
             }
             else if (operation === exports.OPERATION.DELETE) ;
             else if (Schema.is(type)) {
-                const refId = number(bytes, it);
-                value = $root.refs.get(refId);
+                var refId_1 = number(bytes, it);
+                value = $root.refs.get(refId_1);
                 if (operation !== exports.OPERATION.REPLACE) {
-                    const childType = this.getSchemaType(bytes, it, type);
+                    var childType = this.getSchemaType(bytes, it, type);
                     if (!value) {
                         value = this.createTypeInstance(childType);
-                        value.$changes.refId = refId;
+                        value.$changes.refId = refId_1;
                         if (previousValue) {
-                            value.onChange = previousValue.onChange;
-                            value.onRemove = previousValue.onRemove;
-                            value.$listeners = previousValue.$listeners;
+                            value.$callbacks = previousValue.$callbacks;
+                            // value.$listeners = previousValue.$listeners;
                             if (previousValue['$changes'].refId &&
-                                refId !== previousValue['$changes'].refId) {
+                                refId_1 !== previousValue['$changes'].refId) {
                                 $root.removeRef(previousValue['$changes'].refId);
                             }
                         }
                     }
-                    $root.addRef(refId, value, (value !== previousValue));
+                    $root.addRef(refId_1, value, (value !== previousValue));
                 }
             }
             else if (typeof (type) === "string") {
@@ -2295,49 +2541,38 @@ class Schema {
                 value = decodePrimitiveType(type, bytes, it);
             }
             else {
-                const typeDef = getType(Object.keys(type)[0]);
-                const refId = number(bytes, it);
-                const valueRef = ($root.refs.has(refId))
-                    ? previousValue || $root.refs.get(refId)
+                var typeDef = getType(Object.keys(type)[0]);
+                var refId_2 = number(bytes, it);
+                var valueRef = ($root.refs.has(refId_2))
+                    ? previousValue || $root.refs.get(refId_2)
                     : new typeDef.constructor();
                 value = valueRef.clone(true);
-                value.$changes.refId = refId;
+                value.$changes.refId = refId_2;
                 // preserve schema callbacks
                 if (previousValue) {
-                    value.onAdd = previousValue.onAdd;
-                    value.onRemove = previousValue.onRemove;
-                    value.onChange = previousValue.onChange;
+                    value['$callbacks'] = previousValue['$callbacks'];
                     if (previousValue['$changes'].refId &&
-                        refId !== previousValue['$changes'].refId) {
+                        refId_2 !== previousValue['$changes'].refId) {
                         $root.removeRef(previousValue['$changes'].refId);
                         //
                         // Trigger onRemove if structure has been replaced.
                         //
-                        const deletes = [];
-                        const entries = previousValue.entries();
-                        let iter;
+                        var entries = previousValue.entries();
+                        var iter = void 0;
                         while ((iter = entries.next()) && !iter.done) {
-                            const [key, value] = iter.value;
-                            deletes.push({
+                            var _a = iter.value, key = _a[0], value_1 = _a[1];
+                            allChanges.push({
+                                refId: refId_2,
                                 op: exports.OPERATION.DELETE,
                                 field: key,
                                 value: undefined,
-                                previousValue: value,
+                                previousValue: value_1,
                             });
                         }
-                        allChanges.set(previousValue['$changes'].refId, deletes);
                     }
                 }
-                $root.addRef(refId, value, (valueRef !== previousValue));
-                //
-                // TODO: deprecate proxies on next version.
-                // get proxy to target value.
-                //
-                if (typeDef.getProxy) {
-                    value = typeDef.getProxy(value);
-                }
+                $root.addRef(refId_2, value, (valueRef !== previousValue));
             }
-            let hasChange = (previousValue !== value);
             if (value !== null &&
                 value !== undefined) {
                 if (value['$changes']) {
@@ -2345,18 +2580,11 @@ class Schema {
                 }
                 if (ref instanceof Schema) {
                     ref[fieldName] = value;
-                    //
-                    // FIXME: use `_field` instead of `field`.
-                    //
-                    // `field` is going to use the setter of the PropertyDescriptor
-                    // and create a proxy for array/map. This is only useful for
-                    // backwards-compatibility with @colyseus/schema@0.5.x
-                    //
-                    // // ref[_field] = value;
+                    // ref[`_${fieldName}`] = value;
                 }
                 else if (ref instanceof MapSchema) {
                     // const key = ref['$indexes'].get(field);
-                    const key = dynamicIndex;
+                    var key = dynamicIndex;
                     // ref.set(key, value);
                     ref['$items'].set(key, value);
                 }
@@ -2366,24 +2594,25 @@ class Schema {
                     // ref[key] = value;
                     ref.setAt(fieldIndex, value);
                 }
-                else if (ref instanceof CollectionSchema ||
-                    ref instanceof SetSchema) {
-                    const index = ref.add(value);
+                else if (ref instanceof CollectionSchema) {
+                    var index = ref.add(value);
                     ref['setIndex'](fieldIndex, index);
                 }
+                else if (ref instanceof SetSchema) {
+                    var index = ref.add(value);
+                    if (index !== false) {
+                        ref['setIndex'](fieldIndex, index);
+                    }
+                }
             }
-            if (hasChange
-            // &&
-            // (
-            //     this.onChange || ref.$listeners[field]
-            // )
-            ) {
-                changes.push({
+            if (previousValue !== value) {
+                allChanges.push({
+                    refId: refId,
                     op: operation,
                     field: fieldName,
-                    dynamicIndex,
-                    value,
-                    previousValue,
+                    dynamicIndex: dynamicIndex,
+                    value: value,
+                    previousValue: previousValue,
                 });
             }
         }
@@ -2391,16 +2620,19 @@ class Schema {
         // drop references of unused schemas
         $root.garbageCollectDeletedRefs();
         return allChanges;
-    }
-    encode(encodeAll = false, bytes = [], useFilters = false) {
-        const rootChangeTree = this.$changes;
-        const refIdsVisited = new WeakSet();
-        const changeTrees = [rootChangeTree];
-        let numChangeTrees = 1;
-        for (let i = 0; i < numChangeTrees; i++) {
-            const changeTree = changeTrees[i];
-            const ref = changeTree.ref;
-            const isSchema = (ref instanceof Schema);
+    };
+    Schema.prototype.encode = function (encodeAll, bytes, useFilters) {
+        if (encodeAll === void 0) { encodeAll = false; }
+        if (bytes === void 0) { bytes = []; }
+        if (useFilters === void 0) { useFilters = false; }
+        var rootChangeTree = this.$changes;
+        var refIdsVisited = new WeakSet();
+        var changeTrees = [rootChangeTree];
+        var numChangeTrees = 1;
+        for (var i = 0; i < numChangeTrees; i++) {
+            var changeTree = changeTrees[i];
+            var ref = changeTree.ref;
+            var isSchema = (ref instanceof Schema);
             // Generate unique refId for the ChangeTree.
             changeTree.ensureRefId();
             // mark this ChangeTree as visited.
@@ -2411,19 +2643,19 @@ class Schema {
                 uint8$1(bytes, SWITCH_TO_STRUCTURE);
                 number$1(bytes, changeTree.refId);
             }
-            const changes = (encodeAll)
+            var changes = (encodeAll)
                 ? Array.from(changeTree.allChanges)
                 : Array.from(changeTree.changes.values());
-            for (let j = 0, cl = changes.length; j < cl; j++) {
-                const operation = (encodeAll)
+            for (var j = 0, cl = changes.length; j < cl; j++) {
+                var operation = (encodeAll)
                     ? { op: exports.OPERATION.ADD, index: changes[j] }
                     : changes[j];
-                const fieldIndex = operation.index;
-                const field = (isSchema)
+                var fieldIndex = operation.index;
+                var field = (isSchema)
                     ? ref['_definition'].fieldsByIndex && ref['_definition'].fieldsByIndex[fieldIndex]
                     : fieldIndex;
                 // cache begin index if `useFilters`
-                const beginIndex = bytes.length;
+                var beginIndex = bytes.length;
                 // encode field index + operation
                 if (operation.op !== exports.OPERATION.TOUCH) {
                     if (isSchema) {
@@ -2453,7 +2685,7 @@ class Schema {
                         //
                         // MapSchema dynamic key
                         //
-                        const dynamicIndex = changeTree.ref['$indexes'].get(fieldIndex);
+                        var dynamicIndex = changeTree.ref['$indexes'].get(fieldIndex);
                         string$1(bytes, dynamicIndex);
                     }
                 }
@@ -2467,9 +2699,9 @@ class Schema {
                     continue;
                 }
                 // const type = changeTree.childType || ref._schema[field];
-                const type = changeTree.getType(fieldIndex);
+                var type = changeTree.getType(fieldIndex);
                 // const type = changeTree.getType(fieldIndex);
-                const value = changeTree.getValue(fieldIndex);
+                var value = changeTree.getValue(fieldIndex);
                 // Enqueue ChangeTree to be visited
                 if (value &&
                     value['$changes'] &&
@@ -2503,11 +2735,11 @@ class Schema {
                     //
                     // Custom type (MapSchema, ArraySchema, etc)
                     //
-                    const definition = getType(Object.keys(type)[0]);
+                    var definition = getType(Object.keys(type)[0]);
                     //
                     // ensure a ArraySchema has been provided
                     //
-                    assertInstanceType(ref[`_${field}`], definition.constructor, ref, field);
+                    assertInstanceType(ref["_" + field], definition.constructor, ref, field);
                     //
                     // Encode refId for this instance.
                     // The actual instance is going to be encoded on next `changeTree` iteration.
@@ -2524,37 +2756,38 @@ class Schema {
             }
         }
         return bytes;
-    }
-    encodeAll(useFilters) {
+    };
+    Schema.prototype.encodeAll = function (useFilters) {
         return this.encode(true, [], useFilters);
-    }
-    applyFilters(client, encodeAll = false) {
-        const root = this;
-        const refIdsDissallowed = new Set();
-        const $filterState = ClientState.get(client);
-        const changeTrees = [this.$changes];
-        let numChangeTrees = 1;
-        let filteredBytes = [];
-        for (let i = 0; i < numChangeTrees; i++) {
-            const changeTree = changeTrees[i];
+    };
+    Schema.prototype.applyFilters = function (client, encodeAll) {
+        var _a, _b;
+        if (encodeAll === void 0) { encodeAll = false; }
+        var root = this;
+        var refIdsDissallowed = new Set();
+        var $filterState = ClientState.get(client);
+        var changeTrees = [this.$changes];
+        var numChangeTrees = 1;
+        var filteredBytes = [];
+        var _loop_1 = function (i) {
+            var changeTree = changeTrees[i];
             if (refIdsDissallowed.has(changeTree.refId)) {
-                // console.log("REFID IS NOT ALLOWED. SKIP.", { refId: changeTree.refId })
-                continue;
+                return "continue";
             }
-            const ref = changeTree.ref;
-            const isSchema = ref instanceof Schema;
+            var ref = changeTree.ref;
+            var isSchema = ref instanceof Schema;
             uint8$1(filteredBytes, SWITCH_TO_STRUCTURE);
             number$1(filteredBytes, changeTree.refId);
-            const clientHasRefId = $filterState.refIds.has(changeTree);
-            const isEncodeAll = (encodeAll || !clientHasRefId);
+            var clientHasRefId = $filterState.refIds.has(changeTree);
+            var isEncodeAll = (encodeAll || !clientHasRefId);
             // console.log("REF:", ref.constructor.name);
             // console.log("Encode all?", isEncodeAll);
             //
             // include `changeTree` on list of known refIds by this client.
             //
             $filterState.addRefId(changeTree);
-            const containerIndexes = $filterState.containerIndexes.get(changeTree);
-            const changes = (isEncodeAll)
+            var containerIndexes = $filterState.containerIndexes.get(changeTree);
+            var changes = (isEncodeAll)
                 ? Array.from(changeTree.allChanges)
                 : Array.from(changeTree.changes.values());
             //
@@ -2564,8 +2797,8 @@ class Schema {
             if (!encodeAll &&
                 isSchema &&
                 ref._definition.indexesWithFilters) {
-                const indexesWithFilters = ref._definition.indexesWithFilters;
-                indexesWithFilters.forEach(indexWithFilter => {
+                var indexesWithFilters = ref._definition.indexesWithFilters;
+                indexesWithFilters.forEach(function (indexWithFilter) {
                     if (!containerIndexes.has(indexWithFilter) &&
                         changeTree.allChanges.has(indexWithFilter)) {
                         if (isEncodeAll) {
@@ -2577,8 +2810,8 @@ class Schema {
                     }
                 });
             }
-            for (let j = 0, cl = changes.length; j < cl; j++) {
-                const change = (isEncodeAll)
+            for (var j = 0, cl = changes.length; j < cl; j++) {
+                var change = (isEncodeAll)
                     ? { op: exports.OPERATION.ADD, index: changes[j] }
                     : changes[j];
                 // custom operations
@@ -2586,7 +2819,7 @@ class Schema {
                     uint8$1(filteredBytes, change.op);
                     continue;
                 }
-                const fieldIndex = change.index;
+                var fieldIndex = change.index;
                 //
                 // Deleting fields: encode the operation + field index
                 //
@@ -2607,11 +2840,11 @@ class Schema {
                     continue;
                 }
                 // indexed operation
-                const value = changeTree.getValue(fieldIndex);
-                const type = changeTree.getType(fieldIndex);
+                var value = changeTree.getValue(fieldIndex);
+                var type = changeTree.getType(fieldIndex);
                 if (isSchema) {
                     // Is a Schema!
-                    const filter = (ref._definition.filters &&
+                    var filter = (ref._definition.filters &&
                         ref._definition.filters[fieldIndex]);
                     if (filter && !filter.call(ref, client, value, root)) {
                         if (value && value['$changes']) {
@@ -2622,8 +2855,8 @@ class Schema {
                 }
                 else {
                     // Is a collection! (map, array, etc.)
-                    const parent = changeTree.parent;
-                    const filter = changeTree.getChildrenFilter();
+                    var parent = changeTree.parent;
+                    var filter = changeTree.getChildrenFilter();
                     if (filter && !filter.call(parent, client, ref['$indexes'].get(fieldIndex), value, root)) {
                         if (value && value['$changes']) {
                             refIdsDissallowed.add(value['$changes'].refId);
@@ -2647,7 +2880,7 @@ class Schema {
                         //
                         // use cached bytes directly if is from Schema type.
                         //
-                        filteredBytes = filteredBytes.concat(changeTree.caches[fieldIndex]);
+                        filteredBytes.push.apply(filteredBytes, (_a = changeTree.caches[fieldIndex]) !== null && _a !== void 0 ? _a : []);
                         containerIndexes.add(fieldIndex);
                     }
                     else {
@@ -2655,7 +2888,7 @@ class Schema {
                             //
                             // use cached bytes if already has the field
                             //
-                            filteredBytes = filteredBytes.concat(changeTree.caches[fieldIndex]);
+                            filteredBytes.push.apply(filteredBytes, (_b = changeTree.caches[fieldIndex]) !== null && _b !== void 0 ? _b : []);
                         }
                         else {
                             //
@@ -2668,7 +2901,7 @@ class Schema {
                                 //
                                 // MapSchema dynamic key
                                 //
-                                const dynamicIndex = changeTree.ref['$indexes'].get(fieldIndex);
+                                var dynamicIndex = changeTree.ref['$indexes'].get(fieldIndex);
                                 string$1(filteredBytes, dynamicIndex);
                             }
                             if (value['$changes']) {
@@ -2695,19 +2928,22 @@ class Schema {
                         //
                         // MapSchema dynamic key
                         //
-                        const dynamicIndex = changeTree.ref['$indexes'].get(fieldIndex);
+                        var dynamicIndex = changeTree.ref['$indexes'].get(fieldIndex);
                         string$1(filteredBytes, dynamicIndex);
                     }
                     number$1(filteredBytes, value['$changes'].refId);
                 }
             }
+        };
+        for (var i = 0; i < numChangeTrees; i++) {
+            _loop_1(i);
         }
         return filteredBytes;
-    }
-    clone() {
-        const cloned = new (this.constructor);
-        const schema = this._definition.schema;
-        for (let field in schema) {
+    };
+    Schema.prototype.clone = function () {
+        var cloned = new (this.constructor);
+        var schema = this._definition.schema;
+        for (var field in schema) {
             if (typeof (this[field]) === "object" &&
                 typeof (this[field].clone) === "function") {
                 // deep clone
@@ -2719,272 +2955,222 @@ class Schema {
             }
         }
         return cloned;
-    }
-    triggerAll() {
-        // skip if haven't received any remote refs yet.
-        if (this.$changes.root.refs.size === 0) {
-            return;
-        }
-        const allChanges = new Map();
-        Schema.prototype._triggerAllFillChanges.call(this, this, allChanges);
-        try {
-            Schema.prototype._triggerChanges.call(this, allChanges);
-        }
-        catch (e) {
-            Schema.onError(e);
-        }
-    }
-    toJSON() {
-        const schema = this._definition.schema;
-        const deprecated = this._definition.deprecated;
-        const obj = {};
-        for (let field in schema) {
+    };
+    Schema.prototype.toJSON = function () {
+        var schema = this._definition.schema;
+        var deprecated = this._definition.deprecated;
+        var obj = {};
+        for (var field in schema) {
             if (!deprecated[field] && this[field] !== null && typeof (this[field]) !== "undefined") {
                 obj[field] = (typeof (this[field]['toJSON']) === "function")
                     ? this[field]['toJSON']()
-                    : this[`_${field}`];
+                    : this["_" + field];
             }
         }
         return obj;
-    }
-    discardAllChanges() {
+    };
+    Schema.prototype.discardAllChanges = function () {
         this.$changes.discardAll();
-    }
-    getByIndex(index) {
+    };
+    Schema.prototype.getByIndex = function (index) {
         return this[this._definition.fieldsByIndex[index]];
-    }
-    deleteByIndex(index) {
+    };
+    Schema.prototype.deleteByIndex = function (index) {
         this[this._definition.fieldsByIndex[index]] = undefined;
-    }
-    tryEncodeTypeId(bytes, type, targetType) {
+    };
+    Schema.prototype.tryEncodeTypeId = function (bytes, type, targetType) {
         if (type._typeid !== targetType._typeid) {
             uint8$1(bytes, TYPE_ID);
             number$1(bytes, targetType._typeid);
         }
-    }
-    getSchemaType(bytes, it, defaultType) {
-        let type;
+    };
+    Schema.prototype.getSchemaType = function (bytes, it, defaultType) {
+        var type;
         if (bytes[it.offset] === TYPE_ID) {
             it.offset++;
             type = this.constructor._context.get(number(bytes, it));
         }
         return type || defaultType;
-    }
-    createTypeInstance(type) {
-        let instance = new type();
+    };
+    Schema.prototype.createTypeInstance = function (type) {
+        var instance = new type();
         // assign root on $changes
         instance.$changes.root = this.$changes.root;
         return instance;
-    }
-    _triggerAllFillChanges(ref, allChanges) {
-        if (allChanges.has(ref['$changes'].refId)) {
-            return;
-        }
-        const changes = [];
-        allChanges.set(ref['$changes'].refId || 0, changes);
-        if (ref instanceof Schema) {
-            const schema = ref._definition.schema;
-            for (let fieldName in schema) {
-                const _field = `_${fieldName}`;
-                const value = ref[_field];
-                if (value !== undefined) {
-                    changes.push({
-                        op: exports.OPERATION.ADD,
-                        field: fieldName,
-                        value,
-                        previousValue: undefined
-                    });
-                    if (value['$changes'] !== undefined) {
-                        Schema.prototype._triggerAllFillChanges.call(this, value, allChanges);
+    };
+    Schema.prototype._triggerChanges = function (changes) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var uniqueRefIds = new Set();
+        var $refs = this.$changes.root.refs;
+        var _loop_2 = function (i) {
+            var change = changes[i];
+            var refId = change.refId;
+            var ref = $refs.get(refId);
+            var $callbacks = ref['$callbacks'];
+            //
+            // trigger onRemove on child structure.
+            //
+            if ((change.op & exports.OPERATION.DELETE) === exports.OPERATION.DELETE &&
+                change.previousValue instanceof Schema) {
+                (_b = (_a = change.previousValue['$callbacks']) === null || _a === void 0 ? void 0 : _a[exports.OPERATION.DELETE]) === null || _b === void 0 ? void 0 : _b.forEach(function (callback) { return callback(); });
+            }
+            // no callbacks defined, skip this structure!
+            if (!$callbacks) {
+                return "continue";
+            }
+            if (ref instanceof Schema) {
+                if (!uniqueRefIds.has(refId)) {
+                    try {
+                        // trigger onChange
+                        (_d = (_c = $callbacks) === null || _c === void 0 ? void 0 : _c[exports.OPERATION.REPLACE]) === null || _d === void 0 ? void 0 : _d.forEach(function (callback) {
+                            return callback(changes);
+                        });
+                    }
+                    catch (e) {
+                        Schema.onError(e);
                     }
                 }
-            }
-        }
-        else {
-            const entries = ref.entries();
-            let iter;
-            while ((iter = entries.next()) && !iter.done) {
-                const [key, value] = iter.value;
-                changes.push({
-                    op: exports.OPERATION.ADD,
-                    field: key,
-                    dynamicIndex: key,
-                    value: value,
-                    previousValue: undefined,
-                });
-                if (value['$changes'] !== undefined) {
-                    Schema.prototype._triggerAllFillChanges.call(this, value, allChanges);
+                try {
+                    (_e = $callbacks[change.field]) === null || _e === void 0 ? void 0 : _e.forEach(function (callback) {
+                        return callback(change.value, change.previousValue);
+                    });
+                }
+                catch (e) {
+                    Schema.onError(e);
                 }
             }
-        }
-    }
-    _triggerChanges(allChanges) {
-        allChanges.forEach((changes, refId) => {
-            if (changes.length > 0) {
-                const ref = this.$changes.root.refs.get(refId);
-                const isSchema = ref instanceof Schema;
-                for (let i = 0; i < changes.length; i++) {
-                    const change = changes[i];
-                    const listener = ref['$listeners'] && ref['$listeners'][change.field];
-                    if (!isSchema) {
-                        if (change.op === exports.OPERATION.ADD && change.previousValue === undefined) {
-                            ref.onAdd?.(change.value, change.dynamicIndex ?? change.field);
-                        }
-                        else if (change.op === exports.OPERATION.DELETE) {
-                            //
-                            // FIXME: `previousValue` should always be avaiiable.
-                            // ADD + DELETE operations are still encoding DELETE operation.
-                            //
-                            if (change.previousValue !== undefined) {
-                                ref.onRemove?.(change.previousValue, change.dynamicIndex ?? change.field);
-                            }
-                        }
-                        else if (change.op === exports.OPERATION.DELETE_AND_ADD) {
-                            if (change.previousValue !== undefined) {
-                                ref.onRemove?.(change.previousValue, change.dynamicIndex);
-                            }
-                            ref.onAdd?.(change.value, change.dynamicIndex);
-                        }
-                        else if (change.op === exports.OPERATION.REPLACE ||
-                            change.value !== change.previousValue) {
-                            ref.onChange?.(change.value, change.dynamicIndex);
-                        }
-                    }
+            else {
+                // is a collection of items
+                if (change.op === exports.OPERATION.ADD && change.previousValue === undefined) {
+                    // triger onAdd
+                    (_f = $callbacks[exports.OPERATION.ADD]) === null || _f === void 0 ? void 0 : _f.forEach(function (callback) { var _a; return callback(change.value, (_a = change.dynamicIndex) !== null && _a !== void 0 ? _a : change.field); });
+                }
+                else if (change.op === exports.OPERATION.DELETE) {
                     //
-                    // trigger onRemove on child structure.
+                    // FIXME: `previousValue` should always be available.
+                    // ADD + DELETE operations are still encoding DELETE operation.
                     //
-                    if ((change.op & exports.OPERATION.DELETE) === exports.OPERATION.DELETE &&
-                        change.previousValue instanceof Schema &&
-                        change.previousValue.onRemove) {
-                        change.previousValue.onRemove();
-                    }
-                    if (listener) {
-                        try {
-                            listener.invoke(change.value, change.previousValue);
-                        }
-                        catch (e) {
-                            Schema.onError(e);
-                        }
+                    if (change.previousValue !== undefined) {
+                        // triger onRemove
+                        (_g = $callbacks[exports.OPERATION.DELETE]) === null || _g === void 0 ? void 0 : _g.forEach(function (callback) { var _a; return callback(change.previousValue, (_a = change.dynamicIndex) !== null && _a !== void 0 ? _a : change.field); });
                     }
                 }
-                if (isSchema) {
-                    if (ref.onChange) {
-                        try {
-                            ref.onChange(changes);
-                        }
-                        catch (e) {
-                            Schema.onError(e);
-                        }
+                else if (change.op === exports.OPERATION.DELETE_AND_ADD) {
+                    // triger onRemove
+                    if (change.previousValue !== undefined) {
+                        (_h = $callbacks[exports.OPERATION.DELETE]) === null || _h === void 0 ? void 0 : _h.forEach(function (callback) { var _a; return callback(change.previousValue, (_a = change.dynamicIndex) !== null && _a !== void 0 ? _a : change.field); });
                     }
+                    // triger onAdd
+                    (_j = $callbacks[exports.OPERATION.ADD]) === null || _j === void 0 ? void 0 : _j.forEach(function (callback) { var _a; return callback(change.value, (_a = change.dynamicIndex) !== null && _a !== void 0 ? _a : change.field); });
+                }
+                // trigger onChange
+                if (change.value !== change.previousValue) {
+                    (_k = $callbacks[exports.OPERATION.REPLACE]) === null || _k === void 0 ? void 0 : _k.forEach(function (callback) { var _a; return callback(change.value, (_a = change.dynamicIndex) !== null && _a !== void 0 ? _a : change.field); });
                 }
             }
-        });
-    }
-}
-Schema._definition = SchemaDefinition.create();
+            uniqueRefIds.add(refId);
+        };
+        for (var i = 0; i < changes.length; i++) {
+            _loop_2(i);
+        }
+    };
+    Schema._definition = SchemaDefinition.create();
+    return Schema;
+}());
 
 function dumpChanges(schema) {
-    const changeTrees = [schema['$changes']];
-    let numChangeTrees = 1;
-    const dump = {};
-    let currentStructure = dump;
-    for (let i = 0; i < numChangeTrees; i++) {
-        const changeTree = changeTrees[i];
-        changeTree.changes.forEach((change) => {
-            const ref = changeTree.ref;
-            const fieldIndex = change.index;
-            const field = (ref['_definition'])
+    var changeTrees = [schema['$changes']];
+    var numChangeTrees = 1;
+    var dump = {};
+    var currentStructure = dump;
+    var _loop_1 = function (i) {
+        var changeTree = changeTrees[i];
+        changeTree.changes.forEach(function (change) {
+            var ref = changeTree.ref;
+            var fieldIndex = change.index;
+            var field = (ref['_definition'])
                 ? ref['_definition'].fieldsByIndex[fieldIndex]
                 : ref['$indexes'].get(fieldIndex);
             currentStructure[field] = changeTree.getValue(fieldIndex);
         });
+    };
+    for (var i = 0; i < numChangeTrees; i++) {
+        _loop_1(i);
     }
     return dump;
 }
 
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-const reflectionContext = new Context();
+var reflectionContext = { context: new Context() };
 /**
  * Reflection
  */
-class ReflectionField extends Schema {
-}
-__decorate([
-    type("string", reflectionContext)
-], ReflectionField.prototype, "name", void 0);
-__decorate([
-    type("string", reflectionContext)
-], ReflectionField.prototype, "type", void 0);
-__decorate([
-    type("number", reflectionContext)
-], ReflectionField.prototype, "referencedType", void 0);
-class ReflectionType extends Schema {
-    constructor() {
-        super(...arguments);
-        this.fields = new ArraySchema();
-    }
-}
-__decorate([
-    type("number", reflectionContext)
-], ReflectionType.prototype, "id", void 0);
-__decorate([
-    type([ReflectionField], reflectionContext)
-], ReflectionType.prototype, "fields", void 0);
-class Reflection extends Schema {
-    constructor() {
-        super(...arguments);
-        this.types = new ArraySchema();
-    }
-    static encode(instance) {
-        const rootSchemaType = instance.constructor;
-        const reflection = new Reflection();
+var ReflectionField = /** @class */ (function (_super) {
+    __extends(ReflectionField, _super);
+    function ReflectionField() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    __decorate([
+        type("string", reflectionContext)
+    ], ReflectionField.prototype, "name", void 0);
+    __decorate([
+        type("string", reflectionContext)
+    ], ReflectionField.prototype, "type", void 0);
+    __decorate([
+        type("number", reflectionContext)
+    ], ReflectionField.prototype, "referencedType", void 0);
+    return ReflectionField;
+}(Schema));
+var ReflectionType = /** @class */ (function (_super) {
+    __extends(ReflectionType, _super);
+    function ReflectionType() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.fields = new ArraySchema();
+        return _this;
+    }
+    __decorate([
+        type("number", reflectionContext)
+    ], ReflectionType.prototype, "id", void 0);
+    __decorate([
+        type([ReflectionField], reflectionContext)
+    ], ReflectionType.prototype, "fields", void 0);
+    return ReflectionType;
+}(Schema));
+var Reflection = /** @class */ (function (_super) {
+    __extends(Reflection, _super);
+    function Reflection() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.types = new ArraySchema();
+        return _this;
+    }
+    Reflection.encode = function (instance) {
+        var rootSchemaType = instance.constructor;
+        var reflection = new Reflection();
         reflection.rootType = rootSchemaType._typeid;
-        const buildType = (currentType, schema) => {
-            for (let fieldName in schema) {
-                const field = new ReflectionField();
+        var buildType = function (currentType, schema) {
+            for (var fieldName in schema) {
+                var field = new ReflectionField();
                 field.name = fieldName;
-                let fieldType;
+                var fieldType = void 0;
                 if (typeof (schema[fieldName]) === "string") {
                     fieldType = schema[fieldName];
                 }
                 else {
-                    const type = schema[fieldName];
-                    let childTypeSchema;
+                    var type_1 = schema[fieldName];
+                    var childTypeSchema = void 0;
                     //
                     // TODO: refactor below.
                     //
-                    if (Schema.is(type)) {
+                    if (Schema.is(type_1)) {
                         fieldType = "ref";
                         childTypeSchema = schema[fieldName];
                     }
                     else {
-                        fieldType = Object.keys(type)[0];
-                        if (typeof (type[fieldType]) === "string") {
-                            fieldType += ":" + type[fieldType]; // array:string
+                        fieldType = Object.keys(type_1)[0];
+                        if (typeof (type_1[fieldType]) === "string") {
+                            fieldType += ":" + type_1[fieldType]; // array:string
                         }
                         else {
-                            childTypeSchema = type[fieldType];
+                            childTypeSchema = type_1[fieldType];
                         }
                     }
                     field.referencedType = (childTypeSchema)
@@ -2996,58 +3182,64 @@ class Reflection extends Schema {
             }
             reflection.types.push(currentType);
         };
-        const types = rootSchemaType._context.types;
-        for (let typeid in types) {
-            const type = new ReflectionType();
-            type.id = Number(typeid);
-            buildType(type, types[typeid]._definition.schema);
+        var types = rootSchemaType._context.types;
+        for (var typeid in types) {
+            var type_2 = new ReflectionType();
+            type_2.id = Number(typeid);
+            buildType(type_2, types[typeid]._definition.schema);
         }
         return reflection.encodeAll();
-    }
-    static decode(bytes, it) {
-        const context = new Context();
-        const reflection = new Reflection();
+    };
+    Reflection.decode = function (bytes, it) {
+        var context = new Context();
+        var reflection = new Reflection();
         reflection.decode(bytes, it);
-        const schemaTypes = reflection.types.reduce((types, reflectionType) => {
-            const schema = class _ extends Schema {
-            };
-            const typeid = reflectionType.id;
+        var schemaTypes = reflection.types.reduce(function (types, reflectionType) {
+            var schema = /** @class */ (function (_super) {
+                __extends(_, _super);
+                function _() {
+                    return _super !== null && _super.apply(this, arguments) || this;
+                }
+                return _;
+            }(Schema));
+            var typeid = reflectionType.id;
             types[typeid] = schema;
             context.add(schema, typeid);
             return types;
         }, {});
-        reflection.types.forEach((reflectionType) => {
-            const schemaType = schemaTypes[reflectionType.id];
-            reflectionType.fields.forEach(field => {
+        reflection.types.forEach(function (reflectionType) {
+            var schemaType = schemaTypes[reflectionType.id];
+            reflectionType.fields.forEach(function (field) {
+                var _a;
                 if (field.referencedType !== undefined) {
-                    let fieldType = field.type;
-                    let refType = schemaTypes[field.referencedType];
+                    var fieldType = field.type;
+                    var refType = schemaTypes[field.referencedType];
                     // map or array of primitive type (-1)
                     if (!refType) {
-                        const typeInfo = field.type.split(":");
+                        var typeInfo = field.type.split(":");
                         fieldType = typeInfo[0];
                         refType = typeInfo[1];
                     }
                     if (fieldType === "ref") {
-                        type(refType, context)(schemaType.prototype, field.name);
+                        type(refType, { context: context })(schemaType.prototype, field.name);
                     }
                     else {
-                        type({ [fieldType]: refType }, context)(schemaType.prototype, field.name);
+                        type((_a = {}, _a[fieldType] = refType, _a), { context: context })(schemaType.prototype, field.name);
                     }
                 }
                 else {
-                    type(field.type, context)(schemaType.prototype, field.name);
+                    type(field.type, { context: context })(schemaType.prototype, field.name);
                 }
             });
         });
-        const rootType = schemaTypes[reflection.rootType];
-        const rootInstance = new rootType();
+        var rootType = schemaTypes[reflection.rootType];
+        var rootInstance = new rootType();
         /**
          * auto-initialize referenced types on root type
          * to allow registering listeners immediatelly on client-side
          */
-        for (let fieldName in rootType._definition.schema) {
-            const fieldType = rootType._definition.schema[fieldName];
+        for (var fieldName in rootType._definition.schema) {
+            var fieldType = rootType._definition.schema[fieldName];
             if (typeof (fieldType) !== "string") {
                 rootInstance[fieldName] = (typeof (fieldType) === "function")
                     ? new fieldType() // is a schema reference
@@ -3055,17 +3247,18 @@ class Reflection extends Schema {
             }
         }
         return rootInstance;
-    }
-}
-__decorate([
-    type([ReflectionType], reflectionContext)
-], Reflection.prototype, "types", void 0);
-__decorate([
-    type("number", reflectionContext)
-], Reflection.prototype, "rootType", void 0);
+    };
+    __decorate([
+        type([ReflectionType], reflectionContext)
+    ], Reflection.prototype, "types", void 0);
+    __decorate([
+        type("number", reflectionContext)
+    ], Reflection.prototype, "rootType", void 0);
+    return Reflection;
+}(Schema));
 
-registerType("map", { constructor: MapSchema, getProxy: getMapProxy });
-registerType("array", { constructor: ArraySchema, getProxy: getArrayProxy });
+registerType("map", { constructor: MapSchema });
+registerType("array", { constructor: ArraySchema });
 registerType("set", { constructor: SetSchema });
 registerType("collection", { constructor: CollectionSchema, });