{"version":3,"file":"js/230-9eca6e72d136f27606f7.js","mappings":"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","sources":["webpack://app/./node_modules/fast-deep-equal/es6/index.js","webpack://app/./node_modules/uuid/dist/esm-browser/rng.js","webpack://app/./node_modules/uuid/dist/esm-browser/regex.js","webpack://app/./node_modules/uuid/dist/esm-browser/stringify.js","webpack://app/./node_modules/uuid/dist/esm-browser/validate.js","webpack://app/./node_modules/uuid/dist/esm-browser/v4.js","webpack://app/./node_modules/mobx-keystone/node_modules/tslib/tslib.es6.js","webpack://app/./node_modules/mobx-keystone/dist/mobxkeystone.esm.js"],"sourcesContent":["'use strict';\n\n// do not edit .js files directly - edit src/index.jst\n\n\n  var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';\n\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    if (a.constructor !== b.constructor) return false;\n\n    var length, i, keys;\n    if (Array.isArray(a)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n\n    if ((a instanceof Map) && (b instanceof Map)) {\n      if (a.size !== b.size) return false;\n      for (i of a.entries())\n        if (!b.has(i[0])) return false;\n      for (i of a.entries())\n        if (!equal(i[1], b.get(i[0]))) return false;\n      return true;\n    }\n\n    if ((a instanceof Set) && (b instanceof Set)) {\n      if (a.size !== b.size) return false;\n      for (i of a.entries())\n        if (!b.has(i[0])) return false;\n      return true;\n    }\n\n    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (a[i] !== b[i]) return false;\n      return true;\n    }\n\n\n    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;\n    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();\n    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();\n\n    keys = Object.keys(a);\n    length = keys.length;\n    if (length !== Object.keys(b).length) return false;\n\n    for (i = length; i-- !== 0;)\n      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      var key = keys[i];\n\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  // true if both NaN, false otherwise\n  return a!==a && b!==b;\n};\n","// Unique ID creation requires a high quality random # generator. In the browser we therefore\n// require the crypto API and do not support built-in fallback to lower quality random number\n// generators (like Math.random()).\nvar getRandomValues;\nvar rnds8 = new Uint8Array(16);\nexport default function rng() {\n  // lazy load so that environments that need to polyfill have a chance to do so\n  if (!getRandomValues) {\n    // getRandomValues needs to be invoked in a context where \"this\" is a Crypto implementation. Also,\n    // find the complete implementation of crypto (msCrypto) on IE11.\n    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);\n\n    if (!getRandomValues) {\n      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n    }\n  }\n\n  return getRandomValues(rnds8);\n}","export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;","import validate from './validate.js';\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n\nvar byteToHex = [];\n\nfor (var i = 0; i < 256; ++i) {\n  byteToHex.push((i + 0x100).toString(16).substr(1));\n}\n\nfunction stringify(arr) {\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  // Note: Be careful editing this code!  It's been tuned for performance\n  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\n  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one\n  // of the following:\n  // - One or more input array values don't map to a hex octet (leading to\n  // \"undefined\" in the uuid)\n  // - Invalid input values for the RFC `version` or `variant` fields\n\n  if (!validate(uuid)) {\n    throw TypeError('Stringified UUID is invalid');\n  }\n\n  return uuid;\n}\n\nexport default stringify;","import REGEX from './regex.js';\n\nfunction validate(uuid) {\n  return typeof uuid === 'string' && REGEX.test(uuid);\n}\n\nexport default validate;","import rng from './rng.js';\nimport stringify from './stringify.js';\n\nfunction v4(options, buf, offset) {\n  options = options || {};\n  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n\n  rnds[6] = rnds[6] & 0x0f | 0x40;\n  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\n\n  if (buf) {\n    offset = offset || 0;\n\n    for (var i = 0; i < 16; ++i) {\n      buf[offset + i] = rnds[i];\n    }\n\n    return buf;\n  }\n\n  return stringify(rnds);\n}\n\nexport default v4;","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    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;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","import * as mobx from 'mobx';\nimport { isObservableMap, isObservableSet, isObservableArray, isObservableObject, createAtom, runInAction, action, observable, computed, untracked, isAction, remove, reaction, set, intercept, observe, isObservable, toJS, values, get, has, keys, entries } from 'mobx';\nimport { v4 } from 'uuid';\nimport { __decorate } from 'tslib';\nimport fastDeepEqual from 'fast-deep-equal/es6';\n\n/**\r\n * Action type, sync or async.\r\n */\nvar ActionContextActionType;\n\n(function (ActionContextActionType) {\n  ActionContextActionType[\"Sync\"] = \"sync\";\n  ActionContextActionType[\"Async\"] = \"async\";\n})(ActionContextActionType || (ActionContextActionType = {}));\n/**\r\n * An async step type.\r\n */\n\n\nvar ActionContextAsyncStepType;\n\n(function (ActionContextAsyncStepType) {\n  /**\r\n   * The flow is about to start.\r\n   */\n  ActionContextAsyncStepType[\"Spawn\"] = \"spawn\";\n  /**\r\n   * The flow is about to return (finish).\r\n   */\n\n  ActionContextAsyncStepType[\"Return\"] = \"return\";\n  /**\r\n   * The flow is about to continue.\r\n   */\n\n  ActionContextAsyncStepType[\"Resume\"] = \"resume\";\n  /**\r\n   * The flow yield just threw, which might be recovered (caught) or not.\r\n   */\n\n  ActionContextAsyncStepType[\"ResumeError\"] = \"resumeError\";\n  /**\r\n   * The flow is about to throw an error to the flow caller.\r\n   */\n\n  ActionContextAsyncStepType[\"Throw\"] = \"throw\";\n})(ActionContextAsyncStepType || (ActionContextAsyncStepType = {}));\n\nvar currentActionContext;\n/**\r\n * Gets the currently running action context, or undefined if none.\r\n *\r\n * @returns\r\n */\n\nfunction getCurrentActionContext() {\n  return currentActionContext;\n}\n/**\r\n * @ignore\r\n * @internal\r\n *\r\n * Sets the current action context.\r\n *\r\n * @param ctx Current action context.\r\n */\n\nfunction setCurrentActionContext(ctx) {\n  currentActionContext = ctx;\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}\n\nfunction _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n\n  try {\n    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction _construct(Parent, args, Class) {\n  if (_isNativeReflectConstruct()) {\n    _construct = Reflect.construct;\n  } else {\n    _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) _setPrototypeOf(instance, Class.prototype);\n      return instance;\n    };\n  }\n\n  return _construct.apply(null, arguments);\n}\n\nfunction _isNativeFunction(fn) {\n  return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n}\n\nfunction _wrapNativeSuper(Class) {\n  var _cache = typeof Map === \"function\" ? new Map() : undefined;\n\n  _wrapNativeSuper = function _wrapNativeSuper(Class) {\n    if (Class === null || !_isNativeFunction(Class)) return Class;\n\n    if (typeof Class !== \"function\") {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n\n    if (typeof _cache !== \"undefined\") {\n      if (_cache.has(Class)) return _cache.get(Class);\n\n      _cache.set(Class, Wrapper);\n    }\n\n    function Wrapper() {\n      return _construct(Class, arguments, _getPrototypeOf(this).constructor);\n    }\n\n    Wrapper.prototype = Object.create(Class.prototype, {\n      constructor: {\n        value: Wrapper,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n    return _setPrototypeOf(Wrapper, Class);\n  };\n\n  return _wrapNativeSuper(Class);\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n\n  return arr2;\n}\n\nfunction _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it;\n\n  if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) {\n    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n      return function () {\n        if (i >= o.length) return {\n          done: true\n        };\n        return {\n          done: false,\n          value: o[i++]\n        };\n      };\n    }\n\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  it = o[Symbol.iterator]();\n  return it.next.bind(it);\n}\n\n/**\r\n * A mobx-keystone error.\r\n */\n\nvar MobxKeystoneError = /*#__PURE__*/function (_Error) {\n  _inheritsLoose(MobxKeystoneError, _Error);\n\n  function MobxKeystoneError(msg) {\n    var _this;\n\n    _this = _Error.call(this, msg) || this; // Set the prototype explicitly.\n\n    Object.setPrototypeOf(_assertThisInitialized(_this), MobxKeystoneError.prototype);\n    return _this;\n  }\n\n  return MobxKeystoneError;\n}( /*#__PURE__*/_wrapNativeSuper(Error));\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction failure(msg) {\n  return new MobxKeystoneError(msg);\n}\nvar writableHiddenPropDescriptor = {\n  enumerable: false,\n  writable: true,\n  configurable: false,\n  value: undefined\n};\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction addHiddenProp(object, propName, value, writable) {\n  if (writable === void 0) {\n    writable = true;\n  }\n\n  if (writable) {\n    Object.defineProperty(object, propName, writableHiddenPropDescriptor);\n    object[propName] = value;\n  } else {\n    Object.defineProperty(object, propName, {\n      enumerable: false,\n      writable: writable,\n      configurable: true,\n      value: value\n    });\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction makePropReadonly(object, propName, enumerable) {\n  var propDesc = Object.getOwnPropertyDescriptor(object, propName);\n\n  if (propDesc) {\n    propDesc.enumerable = enumerable;\n\n    if (propDesc.get) {\n      delete propDesc.set;\n    } else {\n      propDesc.writable = false;\n    }\n\n    Object.defineProperty(object, propName, propDesc);\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction isPlainObject(value) {\n  if (!isObject(value)) return false;\n  var proto = Object.getPrototypeOf(value);\n  return proto === Object.prototype || proto === null;\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction isObject(value) {\n  return value !== null && typeof value === \"object\";\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction isPrimitive(value) {\n  switch (typeof value) {\n    case \"number\":\n    case \"string\":\n    case \"boolean\":\n    case \"undefined\":\n    case \"bigint\":\n      return true;\n  }\n\n  return value === null;\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction debugFreeze(value) {\n  if (inDevMode()) {\n    Object.freeze(value);\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction deleteFromArray(array, value) {\n  var index = array.indexOf(value);\n\n  if (index >= 0) {\n    array.splice(index, 1);\n    return true;\n  }\n\n  return false;\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction isMap(val) {\n  return val instanceof Map || isObservableMap(val);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction isSet(val) {\n  return val instanceof Set || isObservableSet(val);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction isArray(val) {\n  return Array.isArray(val) || isObservableArray(val);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction inDevMode() {\n  return process.env.NODE_ENV !== \"production\";\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertIsObject(value, argName) {\n  if (!isObject(value)) {\n    throw failure(argName + \" must be an object\");\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertIsPlainObject(value, argName) {\n  if (!isPlainObject(value)) {\n    throw failure(argName + \" must be a plain object\");\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertIsObservableObject(value, argName) {\n  if (!isObservableObject(value)) {\n    throw failure(argName + \" must be an observable object\");\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertIsObservableArray(value, argName) {\n  if (!isObservableArray(value)) {\n    throw failure(argName + \" must be an observable array\");\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertIsMap(value, argName) {\n  if (!isMap(value)) {\n    throw failure(argName + \" must be a map\");\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertIsSet(value, argName) {\n  if (!isSet(value)) {\n    throw failure(argName + \" must be a set\");\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertIsFunction(value, argName) {\n  if (typeof value !== \"function\") {\n    throw failure(argName + \" must be a function\");\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertIsPrimitive(value, argName) {\n  if (!isPrimitive(value)) {\n    throw failure(argName + \" must be a primitive\");\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertIsString(value, argName) {\n  if (typeof value !== \"string\") {\n    throw failure(argName + \" must be a string\");\n  }\n}\nvar decoratorsSymbol = /*#__PURE__*/Symbol(\"decorators\");\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction addLateInitializationFunction(target, fn) {\n  var decoratorsArray = target[decoratorsSymbol];\n\n  if (!decoratorsArray) {\n    decoratorsArray = [];\n    addHiddenProp(target, decoratorsSymbol, decoratorsArray);\n  }\n\n  decoratorsArray.push(fn);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction decorateWrapMethodOrField(decoratorName, data, wrap) {\n  var target = data.target,\n      propertyKey = data.propertyKey,\n      baseDescriptor = data.baseDescriptor;\n\n  var addFieldDecorator = function addFieldDecorator() {\n    addLateInitializationFunction(target, function (instance) {\n      instance[propertyKey] = wrap(data, instance[propertyKey]);\n    });\n  };\n\n  if (baseDescriptor) {\n    if (baseDescriptor.get !== undefined) {\n      throw failure(\"@\" + decoratorName + \" cannot be used with getters\");\n    }\n\n    if (baseDescriptor.value) {\n      // babel / typescript - method decorator\n      // @action method() { }\n      return {\n        enumerable: false,\n        writable: true,\n        configurable: true,\n        value: wrap(data, baseDescriptor.value)\n      };\n    } else {\n      // babel - field decorator: @action method = () => {}\n      addFieldDecorator();\n    }\n  } else {\n    // typescript - field decorator\n    addFieldDecorator();\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction runLateInitializationFunctions(instance) {\n  var fns = instance[decoratorsSymbol];\n\n  if (fns) {\n    for (var _iterator = _createForOfIteratorHelperLoose(fns), _step; !(_step = _iterator()).done;) {\n      var fn = _step.value;\n      fn(instance);\n    }\n  }\n}\nvar warningsAlreadyDisplayed = /*#__PURE__*/new Set();\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction logWarning(type, msg, uniqueKey) {\n  if (uniqueKey) {\n    if (warningsAlreadyDisplayed.has(uniqueKey)) {\n      return;\n    }\n\n    warningsAlreadyDisplayed.add(uniqueKey);\n  }\n\n  msg = \"[mobx-keystone] \" + msg;\n\n  switch (type) {\n    case \"warn\":\n      console.warn(msg);\n      break;\n\n    case \"error\":\n      console.error(msg);\n      break;\n\n    default:\n      throw failure(\"unknown log type - \" + type);\n  }\n}\nvar notMemoized = /*#__PURE__*/Symbol(\"notMemoized\");\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction lateVal(getter) {\n  var memoized = notMemoized;\n\n  var fn = function fn() {\n    if (memoized === notMemoized) {\n      memoized = getter.apply(void 0, arguments);\n    }\n\n    return memoized;\n  };\n\n  return fn;\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction lazy(valueGen) {\n  var inited = false;\n  var val;\n  return function () {\n    if (!inited) {\n      val = valueGen();\n      inited = true;\n    }\n\n    return val;\n  };\n} // just to ensure import * is kept properly\n\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nvar mobx6 = {\n  // eslint-disable-next-line no-useless-concat\n  makeObservable: mobx[\"makeObservable\" + \"\"]\n};\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction getMobxVersion() {\n  if (mobx6.makeObservable) {\n    return 6;\n  } else {\n    return 5;\n  }\n}\n\nvar chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\";\nfunction toBase64(input) {\n  if (typeof global === \"object\" && typeof global.Buffer === \"function\") {\n    // node\n    return Buffer.from(input).toString(\"base64\");\n  }\n\n  if (typeof btoa === \"function\") {\n    // browser\n    return btoa(input);\n  }\n\n  var str = String(input);\n  var output = \"\";\n\n  for ( // initialize result and counter\n  var block = 0, charCode, idx = 0, map = chars; // if the next str index does not exist:\n  //   change the mapping table to \"=\"\n  //   check if d has no fractional digits\n  str.charAt(idx | 0) || (map = \"=\", idx % 1); // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n  output += map.charAt(63 & block >> 8 - idx % 1 * 8)) {\n    charCode = str.charCodeAt(idx += 3 / 4);\n\n    if (charCode > 0xff) {\n      throw new Error(\"the string to be encoded contains characters outside of the Latin1 range.\");\n    }\n\n    block = block << 8 | charCode;\n  }\n\n  return output;\n}\n\n/**\r\n * Model auto type-checking mode.\r\n */\n\nvar ModelAutoTypeCheckingMode;\n\n(function (ModelAutoTypeCheckingMode) {\n  /**\r\n   * Auto type check models only in dev mode\r\n   */\n  ModelAutoTypeCheckingMode[\"DevModeOnly\"] = \"devModeOnly\";\n  /**\r\n   * Auto type check models no matter the current environment\r\n   */\n\n  ModelAutoTypeCheckingMode[\"AlwaysOn\"] = \"alwaysOn\";\n  /**\r\n   * Do not auto type check models no matter the current environment\r\n   */\n\n  ModelAutoTypeCheckingMode[\"AlwaysOff\"] = \"alwaysOff\";\n})(ModelAutoTypeCheckingMode || (ModelAutoTypeCheckingMode = {}));\n\nvar localId = 0;\nvar localBaseId = /*#__PURE__*/shortenUuid( /*#__PURE__*/v4());\n\nfunction defaultModelIdGenerator() {\n  // we use base 36 for local id since it is short and fast\n  var id = localId.toString(36) + \"-\" + localBaseId;\n  localId++;\n  return id;\n} // defaults\n\n\nvar globalConfig = {\n  modelAutoTypeChecking: ModelAutoTypeCheckingMode.DevModeOnly,\n  modelIdGenerator: defaultModelIdGenerator,\n  allowUndefinedArrayElements: false,\n  showDuplicateModelNameWarnings: true\n};\n/**\r\n * Partially sets the current global config.\r\n *\r\n * @param config Partial object with the new configurations. Options not included in the object won't be changed.\r\n */\n\nfunction setGlobalConfig(config) {\n  globalConfig = Object.freeze(_extends({}, globalConfig, config));\n}\n/**\r\n * Returns the current global config object.\r\n *\r\n * @returns\r\n */\n\nfunction getGlobalConfig() {\n  return globalConfig;\n}\n/**\r\n * @ignore\r\n * @internal\r\n *\r\n * Returns if the auto type checking for models is enabled.\r\n *\r\n * @returns\r\n */\n\nfunction isModelAutoTypeCheckingEnabled() {\n  switch (getGlobalConfig().modelAutoTypeChecking) {\n    case ModelAutoTypeCheckingMode.DevModeOnly:\n      return inDevMode();\n\n    case ModelAutoTypeCheckingMode.AlwaysOff:\n      return false;\n\n    case ModelAutoTypeCheckingMode.AlwaysOn:\n      return true;\n\n    default:\n      throw failure(\"invalid 'modelAutoTypeChecking' config value - \" + globalConfig.modelAutoTypeChecking);\n  }\n}\n\nfunction shortenUuid(uuid) {\n  // remove non-hex chars\n  var hex = uuid.split(\"-\").join(\"\"); // convert to base64\n\n  var hexMatch = hex.match(/\\w{2}/g);\n  var str = String.fromCharCode.apply(null, hexMatch.map(function (a) {\n    return parseInt(a, 16);\n  }));\n  return toBase64(str);\n}\n\n/**\r\n * @ignore\r\n */\n\nvar noDefaultValue = /*#__PURE__*/Symbol(\"noDefaultValue\");\nfunction prop(arg1, arg2) {\n  var def;\n  var opts = {};\n  var hasDefaultValue = false;\n\n  if (arguments.length >= 2) {\n    // default, options\n    def = arg1;\n    hasDefaultValue = true;\n    opts = _extends({}, arg2);\n  } else if (arguments.length === 1) {\n    // default | options\n    if (isObject(arg1)) {\n      // options\n      opts = _extends({}, arg1);\n    } else {\n      // default\n      def = arg1;\n      hasDefaultValue = true;\n    }\n  }\n\n  var isDefFn = typeof def === \"function\";\n  return {\n    $propValueType: null,\n    $propCreationValueType: null,\n    $isOptional: null,\n    $instanceValueType: null,\n    $instanceCreationValueType: null,\n    defaultFn: hasDefaultValue && isDefFn ? def : noDefaultValue,\n    defaultValue: hasDefaultValue && !isDefFn ? def : noDefaultValue,\n    typeChecker: undefined,\n    transform: undefined,\n    options: opts\n  };\n}\n\n/**\r\n * Creates a prop transform, useful to transform property data into another kind of data.\r\n *\r\n * For example, to transform from a number timestamp into a date:\r\n * ```ts\r\n * const asDate = propTransform({\r\n *   propToData(prop: number) {\r\n *     return new Date(prop)\r\n *   },\r\n *   dataToProp(data: Date) {\r\n *     return +data\r\n *   }\r\n * })\r\n *\r\n * @model(\"myApp/MyModel\")\r\n * class MyModel extends Model({\r\n *   timestamp: prop<number>()\r\n * }) {\r\n *   @asDate(\"timestamp\")\r\n *   date!: Date\r\n * }\r\n *\r\n * const date: Date = myModel.date\r\n * // inside some model action\r\n * myModel.date = new Date()\r\n * ```\r\n *\r\n * @typename TProp Property value type.\r\n * @typename TData Data value type.\r\n * @param transform Transform to apply.\r\n * @returns A decorator that can be used to decorate model class fields.\r\n */\n\nfunction propTransform(transform) {\n  var parametrizedDecorator = function parametrizedDecorator(boundPropName) {\n    var decorator = function decorator(target, propertyKey) {\n      addLateInitializationFunction(target, function (instance) {\n        // make the field a getter setter\n        Object.defineProperty(instance, propertyKey, {\n          get: function get() {\n            var memoTransform = memoTransformCache.getOrCreateMemoTransform(this, propertyKey, transform);\n            return memoTransform.propToData(this.$[boundPropName]);\n          },\n          set: function set(value) {\n            var memoTransform = memoTransformCache.getOrCreateMemoTransform(this, propertyKey, transform);\n            this.$[boundPropName] = memoTransform.dataToProp(value);\n            return true;\n          }\n        });\n      });\n    };\n\n    return decorator;\n  };\n\n  parametrizedDecorator.propToData = transform.propToData.bind(transform);\n  parametrizedDecorator.dataToProp = transform.dataToProp.bind(transform);\n  return parametrizedDecorator;\n}\n\nvar MemoTransformCache = /*#__PURE__*/function () {\n  function MemoTransformCache() {\n    this.cache = new WeakMap();\n  }\n\n  var _proto = MemoTransformCache.prototype;\n\n  _proto.getOrCreateMemoTransform = function getOrCreateMemoTransform(target, propName, baseTransform) {\n    var transformsPerProperty = this.cache.get(target);\n\n    if (!transformsPerProperty) {\n      transformsPerProperty = new Map();\n      this.cache.set(target, transformsPerProperty);\n    }\n\n    var memoTransform = transformsPerProperty.get(propName);\n\n    if (!memoTransform) {\n      memoTransform = toMemoPropTransform(baseTransform, function (newPropValue) {\n        target.$[propName] = newPropValue;\n      });\n      transformsPerProperty.set(propName, memoTransform);\n    }\n\n    return memoTransform;\n  };\n\n  return MemoTransformCache;\n}();\n/**\r\n * @ignore\r\n * @internal\r\n */\n\n\nvar memoTransformCache = /*#__PURE__*/new MemoTransformCache();\nvar valueNotMemoized = /*#__PURE__*/Symbol(\"valueNotMemoized\");\n\nfunction toMemoPropTransform(transform, propSetter) {\n  var lastPropValue = valueNotMemoized;\n  var lastDataValue = valueNotMemoized;\n  return {\n    isMemoPropTransform: true,\n    propToData: function propToData(propValue) {\n      if (lastPropValue !== propValue) {\n        lastDataValue = transform.propToData(propValue, propSetter);\n        lastPropValue = propValue;\n      }\n\n      return lastDataValue;\n    },\n    dataToProp: function dataToProp(newDataValue) {\n      // clear caches in this case\n      lastPropValue = valueNotMemoized;\n      lastDataValue = valueNotMemoized;\n      return transform.dataToProp(newDataValue);\n    }\n  };\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\n\nfunction transformedProp(prop, transform, transformDefault) {\n  if (prop.transform) {\n    throw failure(\"a property cannot have more than one transform\");\n  }\n\n  var p = _extends({}, prop, {\n    transform: transform\n  }); // transform defaults if needed\n\n\n  if (transformDefault) {\n    if (p.defaultValue !== noDefaultValue) {\n      var originalDefaultValue = p.defaultValue;\n      p.defaultValue = transform.dataToProp(originalDefaultValue);\n    }\n\n    if (p.defaultFn !== noDefaultValue) {\n      var originalDefaultFn = p.defaultFn;\n\n      p.defaultFn = function () {\n        return transform.dataToProp(originalDefaultFn());\n      };\n    }\n  }\n\n  return p;\n}\n\n/**\r\n * @ignore\r\n */\n\nvar objectParents = /*#__PURE__*/new WeakMap();\n/**\r\n * @ignore\r\n */\n\nvar objectParentsAtoms = /*#__PURE__*/new WeakMap();\n/**\r\n * @ignore\r\n */\n\nfunction parentPathEquals(parentPath1, parentPath2, comparePath) {\n  if (comparePath === void 0) {\n    comparePath = true;\n  }\n\n  if (!parentPath1 && !parentPath2) return true;\n  if (!parentPath1 || !parentPath2) return false;\n  var parentEquals = parentPath1.parent === parentPath2.parent;\n  if (!parentEquals) return false;\n  return comparePath ? parentPath1.path === parentPath2.path : true;\n}\n\nfunction createParentPathAtom(obj) {\n  var atom = objectParentsAtoms.get(obj);\n\n  if (!atom) {\n    atom = createAtom(\"parentAtom\");\n    objectParentsAtoms.set(obj, atom);\n  }\n\n  return atom;\n}\n/**\r\n * @ignore\r\n */\n\n\nfunction reportParentPathObserved(node) {\n  createParentPathAtom(node).reportObserved();\n}\n/**\r\n * @ignore\r\n */\n\nfunction reportParentPathChanged(node) {\n  createParentPathAtom(node).reportChanged();\n}\n/**\r\n * @ignore\r\n */\n\nvar dataObjectParent = /*#__PURE__*/new WeakMap();\n/**\r\n * @ignore\r\n */\n\nfunction dataToModelNode(node) {\n  var modelNode = dataObjectParent.get(node);\n  return modelNode != null ? modelNode : node;\n}\n/**\r\n * @ignore\r\n */\n\nfunction modelToDataNode(node) {\n  return isModel(node) ? node.$ : node;\n}\n\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nvar tweakedObjects = /*#__PURE__*/new WeakMap();\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction isTweakedObject(value, canBeDataObject) {\n  if (!canBeDataObject && dataObjectParent.has(value)) {\n    return false;\n  }\n\n  return tweakedObjects.has(value);\n}\n/**\r\n * Checks if a given object is now a tree node.\r\n *\r\n * @param value Value to check.\r\n * @returns true if it is a tree node, false otherwise.\r\n */\n\nfunction isTreeNode(value) {\n  return !isPrimitive(value) && isTweakedObject(value, false);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertTweakedObject(treeNode, argName, canBeDataObject) {\n  if (canBeDataObject === void 0) {\n    canBeDataObject = false;\n  }\n\n  if (!canBeDataObject && dataObjectParent.has(treeNode)) {\n    throw failure(argName + \" must be the model object instance instead of the '$' sub-object\");\n  }\n\n  if (isPrimitive(treeNode) || !isTweakedObject(treeNode, true)) {\n    throw failure(argName + \" must be a tree node (usually a model or a shallow / deep child part of a model 'data' object)\");\n  }\n}\n/**\r\n * Asserts a given object is now a tree node, or throws otherwise.\r\n *\r\n * @param value Value to check.\r\n * @param argName Argument name, part of the thrown error description.\r\n */\n\nfunction assertIsTreeNode(value, argName) {\n  if (argName === void 0) {\n    argName = \"argument\";\n  }\n\n  assertTweakedObject(value, argName, false);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nvar runningWithoutSnapshotOrPatches = false;\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction runWithoutSnapshotOrPatches(fn) {\n  var old = runningWithoutSnapshotOrPatches;\n  runningWithoutSnapshotOrPatches = true;\n\n  try {\n    runInAction(function () {\n      fn();\n    });\n  } finally {\n    runningWithoutSnapshotOrPatches = old;\n  }\n}\n\n/**\r\n * Key where model snapshots will store model type metadata.\r\n */\nvar modelTypeKey = \"$modelType\";\n/**\r\n * Key where model snapshots will store model internal IDs metadata.\r\n */\n\nvar modelIdKey = \"$modelId\";\n/**\r\n * @internal\r\n * Returns if a given key is a reserved key in model snapshots.\r\n *\r\n * @param key\r\n * @returns\r\n */\n\nfunction isReservedModelKey(key) {\n  return key === modelTypeKey || key === modelIdKey;\n}\n\nvar defaultObservableSetOptions = {\n  deep: false\n};\nvar objectChildren = /*#__PURE__*/new WeakMap();\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction initializeObjectChildren(node) {\n  if (objectChildren.has(node)) {\n    return;\n  }\n\n  objectChildren.set(node, {\n    shallow: observable.set(undefined, defaultObservableSetOptions),\n    deep: new Set(),\n    deepByModelTypeAndId: new Map(),\n    deepDirty: true,\n    deepAtom: createAtom(\"deepChildrenAtom\")\n  });\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction getObjectChildren(node) {\n  return objectChildren.get(node).shallow;\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction getDeepObjectChildren(node) {\n  var obj = objectChildren.get(node);\n\n  if (obj.deepDirty) {\n    updateDeepObjectChildren(node);\n  }\n\n  obj.deepAtom.reportObserved();\n  return {\n    deep: obj.deep,\n    deepByModelTypeAndId: obj.deepByModelTypeAndId\n  };\n}\n\nfunction addNodeToDeepLists(node, deep, deepByModelTypeAndId) {\n  deep.add(node);\n\n  if (isModel(node)) {\n    deepByModelTypeAndId.set(byModelTypeAndIdKey(node[modelTypeKey], node[modelIdKey]), node);\n  }\n}\n\nvar updateDeepObjectChildren = /*#__PURE__*/action(function (node) {\n  var obj = objectChildren.get(node);\n\n  if (!obj.deepDirty) {\n    return {\n      deep: obj.deep,\n      deepByModelTypeAndId: obj.deepByModelTypeAndId\n    };\n  }\n\n  var deep = new Set();\n  var deepByModelTypeAndId = new Map();\n  var childrenIter = getObjectChildren(node).values();\n  var ch = childrenIter.next();\n\n  while (!ch.done) {\n    addNodeToDeepLists(ch.value, deep, deepByModelTypeAndId);\n    var ret = updateDeepObjectChildren(ch.value).deep;\n    var retIter = ret.values();\n    var retCur = retIter.next();\n\n    while (!retCur.done) {\n      addNodeToDeepLists(retCur.value, deep, deepByModelTypeAndId);\n      retCur = retIter.next();\n    }\n\n    ch = childrenIter.next();\n  }\n\n  obj.deep = deep;\n  obj.deepByModelTypeAndId = deepByModelTypeAndId;\n  obj.deepDirty = false;\n  obj.deepAtom.reportChanged();\n  return {\n    deep: deep,\n    deepByModelTypeAndId: deepByModelTypeAndId\n  };\n});\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nvar addObjectChild = /*#__PURE__*/action(function (node, child) {\n  var obj = objectChildren.get(node);\n  obj.shallow.add(child);\n  invalidateDeepChildren(node);\n});\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nvar removeObjectChild = /*#__PURE__*/action(function (node, child) {\n  var obj = objectChildren.get(node);\n  obj.shallow[\"delete\"](child);\n  invalidateDeepChildren(node);\n});\n\nfunction invalidateDeepChildren(node) {\n  var obj = objectChildren.get(node);\n\n  if (!obj.deepDirty) {\n    obj.deepDirty = true;\n    obj.deepAtom.reportChanged();\n  }\n\n  var parent = fastGetParent(node);\n\n  if (parent) {\n    invalidateDeepChildren(parent);\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\n\nfunction byModelTypeAndIdKey(modelType, modelId) {\n  return modelType + \" \" + modelId;\n}\n\n/**\r\n * Returns the parent of the target plus the path from the parent to the target, or undefined if it has no parent.\r\n *\r\n * @typeparam T Parent object type.\r\n * @param value Target object.\r\n * @returns\r\n */\n\nfunction getParentPath(value) {\n  assertTweakedObject(value, \"value\");\n  return fastGetParentPath(value);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction fastGetParentPath(value) {\n  reportParentPathObserved(value);\n  return objectParents.get(value);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction fastGetParentPathIncludingDataObjects(value) {\n  var parentModel = dataObjectParent.get(value);\n\n  if (parentModel) {\n    return {\n      parent: parentModel,\n      path: \"$\"\n    };\n  }\n\n  var parentPath = fastGetParentPath(value);\n\n  if (parentPath && isModel(parentPath.parent)) {\n    return {\n      parent: parentPath.parent.$,\n      path: parentPath.path\n    };\n  }\n\n  return parentPath;\n}\n/**\r\n * Returns the parent object of the target object, or undefined if there's no parent.\r\n *\r\n * @typeparam T Parent object type.\r\n * @param value Target object.\r\n * @returns\r\n */\n\nfunction getParent(value) {\n  assertTweakedObject(value, \"value\");\n  return fastGetParent(value);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction fastGetParent(value) {\n  var parentPath = fastGetParentPath(value);\n  return parentPath ? parentPath.parent : undefined;\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction fastGetParentIncludingDataObjects(value) {\n  var parentPath = fastGetParentPathIncludingDataObjects(value);\n  return parentPath ? parentPath.parent : undefined;\n}\n/**\r\n * Returns if a given object is a model interim data object (`$`).\r\n *\r\n * @param value Object to check.\r\n * @returns true if it is, false otherwise.\r\n */\n\nfunction isModelDataObject(value) {\n  assertTweakedObject(value, \"value\", true);\n  return fastIsModelDataObject(value);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction fastIsModelDataObject(value) {\n  return dataObjectParent.has(value);\n}\n/**\r\n * Returns the root of the target plus the path from the root to get to the target.\r\n *\r\n * @typeparam T Root object type.\r\n * @param value Target object.\r\n * @returns\r\n */\n\nfunction getRootPath(value) {\n  assertTweakedObject(value, \"value\");\n  return fastGetRootPath(value);\n} // we use computeds so they are cached whenever possible\n\nvar computedsGetRootPath = /*#__PURE__*/new WeakMap();\n\nfunction internalGetRootPath(value) {\n  var rootPath = {\n    root: value,\n    path: [],\n    pathObjects: [value]\n  };\n  var parentPath;\n\n  while (parentPath = fastGetParentPath(rootPath.root)) {\n    rootPath.root = parentPath.parent;\n    rootPath.path.unshift(parentPath.path);\n    rootPath.pathObjects.unshift(parentPath.parent);\n  }\n\n  return rootPath;\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\n\nfunction fastGetRootPath(value) {\n  var computedGetRootPathForNode = computedsGetRootPath.get(value);\n\n  if (!computedGetRootPathForNode) {\n    computedGetRootPathForNode = computed(function () {\n      return internalGetRootPath(value);\n    });\n    computedsGetRootPath.set(value, computedGetRootPathForNode);\n  }\n\n  return computedGetRootPathForNode.get();\n}\n/**\r\n * Returns the root of the target object, or itself if the target is a root.\r\n *\r\n * @typeparam T Root object type.\r\n * @param value Target object.\r\n * @returns\r\n */\n\nfunction getRoot(value) {\n  assertTweakedObject(value, \"value\");\n  return fastGetRoot(value);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction fastGetRoot(value) {\n  return fastGetRootPath(value).root;\n}\n/**\r\n * Returns if a given object is a root object.\r\n *\r\n * @param value Target object.\r\n * @returns\r\n */\n\nfunction isRoot(value) {\n  assertTweakedObject(value, \"value\");\n  return !fastGetParent(value);\n}\n/**\r\n * Returns if the target is a \"child\" of the tree of the given \"parent\" object.\r\n *\r\n * @param child Target object.\r\n * @param parent Parent object.\r\n * @returns\r\n */\n\nfunction isChildOfParent(child, parent) {\n  assertTweakedObject(child, \"child\");\n  assertTweakedObject(parent, \"parent\");\n  return getDeepObjectChildren(parent).deep.has(child);\n}\n/**\r\n * Returns if the target is a \"parent\" that has in its tree the given \"child\" object.\r\n *\r\n * @param parent Target object.\r\n * @param child Child object.\r\n * @returns\r\n */\n\nfunction isParentOfChild(parent, child) {\n  return isChildOfParent(child, parent);\n}\nvar unresolved = {\n  resolved: false\n};\n/**\r\n * Tries to resolve a path from an object.\r\n *\r\n * @typeparam T Returned value type.\r\n * @param pathRootObject Object that serves as path root.\r\n * @param path Path as an string or number array.\r\n * @returns An object with `{ resolved: true, value: T }` or `{ resolved: false }`.\r\n */\n\nfunction resolvePath(pathRootObject, path) {\n  // unit tests rely on this to work with any object\n  // assertTweakedObject(pathRootObject, \"pathRootObject\")\n  var current = modelToDataNode(pathRootObject);\n  var len = path.length;\n\n  for (var i = 0; i < len; i++) {\n    if (!isObject(current)) {\n      return unresolved;\n    }\n\n    var p = path[i]; // check just to avoid mobx warnings about trying to access out of bounds index\n\n    if (isArray(current) && +p >= current.length) {\n      return unresolved;\n    }\n\n    current = modelToDataNode(current[p]);\n  }\n\n  return {\n    resolved: true,\n    value: dataToModelNode(current)\n  };\n}\n/**\r\n * @ignore\r\n */\n\nvar skipIdChecking = /*#__PURE__*/Symbol(\"skipIdChecking\");\n/**\r\n * @ignore\r\n *\r\n * Tries to resolve a path from an object while checking ids.\r\n *\r\n * @typeparam T Returned value type.\r\n * @param pathRootObject Object that serves as path root.\r\n * @param path Path as an string or number array.\r\n * @param pathIds An array of ids of the models that must be checked, null if not a model or `skipIdChecking` to skip it.\r\n * @returns An object with `{ resolved: true, value: T }` or `{ resolved: false }`.\r\n */\n\nfunction resolvePathCheckingIds(pathRootObject, path, pathIds) {\n  // unit tests rely on this to work with any object\n  // assertTweakedObject(pathRootObject, \"pathRootObject\")\n  var current = modelToDataNode(pathRootObject); // root id is never checked\n\n  var len = path.length;\n\n  for (var i = 0; i < len; i++) {\n    if (!isObject(current)) {\n      return {\n        resolved: false\n      };\n    }\n\n    var p = path[i]; // check just to avoid mobx warnings about trying to access out of bounds index\n\n    if (isArray(current) && +p >= current.length) {\n      return {\n        resolved: false\n      };\n    }\n\n    var currentMaybeModel = current[p];\n    current = modelToDataNode(currentMaybeModel);\n    var expectedId = pathIds[i];\n\n    if (expectedId !== skipIdChecking) {\n      var currentId = isModel(currentMaybeModel) ? currentMaybeModel[modelIdKey] : null;\n\n      if (expectedId !== currentId) {\n        return {\n          resolved: false\n        };\n      }\n    }\n  }\n\n  return {\n    resolved: true,\n    value: dataToModelNode(current)\n  };\n}\n/**\r\n * Gets the path to get from a parent to a given child.\r\n * Returns an empty array if the child is actually the given parent or undefined if the child is not a child of the parent.\r\n *\r\n * @param fromParent\r\n * @param toChild\r\n * @returns\r\n */\n\nfunction getParentToChildPath(fromParent, toChild) {\n  assertTweakedObject(fromParent, \"fromParent\");\n  assertTweakedObject(toChild, \"toChild\");\n\n  if (fromParent === toChild) {\n    return [];\n  }\n\n  var path = [];\n  var current = toChild;\n  var parentPath;\n\n  while (parentPath = fastGetParentPath(current)) {\n    path.unshift(parentPath.path);\n    current = parentPath.parent;\n\n    if (current === fromParent) {\n      return path;\n    }\n  }\n\n  return undefined;\n}\n\nvar snapshots = /*#__PURE__*/new WeakMap();\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction getInternalSnapshot(value) {\n  return snapshots.get(value);\n}\n\nfunction getInternalSnapshotParent(sn, parentPath) {\n  return untracked(function () {\n    if (!parentPath) {\n      return undefined;\n    }\n\n    var parentSn = getInternalSnapshot(parentPath.parent);\n\n    if (!parentSn) {\n      return undefined;\n    }\n\n    return sn ? {\n      parentSnapshot: parentSn,\n      parentPath: parentPath\n    } : undefined;\n  });\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\n\nvar unsetInternalSnapshot = /*#__PURE__*/action(\"unsetInternalSnapshot\", function (value) {\n  var oldSn = getInternalSnapshot(value);\n\n  if (oldSn) {\n    snapshots[\"delete\"](value);\n    oldSn.atom.reportChanged();\n  }\n});\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nvar setInternalSnapshot = /*#__PURE__*/action(\"setInternalSnapshot\", function (value, standard) {\n  var oldSn = getInternalSnapshot(value); // do not actually update if not needed\n\n  if (oldSn && oldSn.standard === standard) {\n    return;\n  }\n\n  debugFreeze(standard);\n  var sn;\n\n  if (oldSn) {\n    sn = oldSn;\n    sn.standard = standard;\n  } else {\n    sn = {\n      standard: standard,\n      atom: createAtom(\"snapshot\")\n    };\n    snapshots.set(value, sn);\n  }\n\n  sn.atom.reportChanged(); // also update parent(s) snapshot(s) if needed\n\n  var parent = getInternalSnapshotParent(oldSn, fastGetParentPath(value));\n\n  if (parent) {\n    var parentSnapshot = parent.parentSnapshot,\n        parentPath = parent.parentPath; // might be false in the cases where the parent has not yet been created\n\n    if (parentSnapshot) {\n      var path = parentPath.path; // patches for parent changes should not be emitted\n\n      var parentStandardSn = parentSnapshot.standard;\n\n      if (parentStandardSn[path] !== sn.standard) {\n        if (Array.isArray(parentStandardSn)) {\n          parentStandardSn = parentStandardSn.slice();\n        } else {\n          parentStandardSn = Object.assign({}, parentStandardSn);\n        }\n\n        parentStandardSn[path] = sn.standard;\n        setInternalSnapshot(parentPath.parent, parentStandardSn);\n      }\n    }\n  }\n});\n/**\r\n * @ignore\r\n */\n\nfunction reportInternalSnapshotObserved(sn) {\n  sn.atom.reportObserved();\n}\n\n/**\r\n * Retrieves an immutable snapshot for a data structure.\r\n * Since returned snapshots are immutable they will respect shallow equality, this is,\r\n * if no changes are made then the snapshot will be kept the same.\r\n *\r\n * @typeparam T Object type.\r\n * @param nodeOrPrimitive Data structure, including primtives.\r\n * @returns The snapshot.\r\n */\n\nfunction getSnapshot(nodeOrPrimitive) {\n  if (isPrimitive(nodeOrPrimitive)) {\n    return nodeOrPrimitive;\n  }\n\n  assertTweakedObject(nodeOrPrimitive, \"nodeOrPrimitive\");\n  var snapshot = getInternalSnapshot(nodeOrPrimitive);\n\n  if (!snapshot) {\n    throw failure(\"getSnapshot is not supported for this kind of object\");\n  }\n\n  reportInternalSnapshotObserved(snapshot);\n  return snapshot.standard;\n}\n\nvar modelDataTypeCheckerSymbol = /*#__PURE__*/Symbol(\"modelDataTypeChecker\");\nvar modelUnwrappedClassSymbol = /*#__PURE__*/Symbol(\"modelUnwrappedClass\");\n\n/**\r\n * Returns the associated data type for run-time checking (if any) to a model instance or class.\r\n *\r\n * @param modelClassOrInstance Model class or instance.\r\n * @returns The associated data type, or undefined if none.\r\n */\n\nfunction getModelDataType(modelClassOrInstance) {\n  if (isModel(modelClassOrInstance)) {\n    return modelClassOrInstance.constructor[modelDataTypeCheckerSymbol];\n  } else if (isModelClass(modelClassOrInstance)) {\n    return modelClassOrInstance[modelDataTypeCheckerSymbol];\n  } else {\n    throw failure(\"modelClassOrInstance must be a model class or instance\");\n  }\n}\n\n/**\r\n * @ignore\r\n */\n\nvar modelInfoByName = {};\n/**\r\n * @ignore\r\n */\n\nvar modelInfoByClass = /*#__PURE__*/new Map();\n/**\r\n * @ignore\r\n */\n\nfunction getModelInfoForName(name) {\n  return modelInfoByName[name];\n}\n\nvar modelPropertiesSymbol = /*#__PURE__*/Symbol(\"modelProperties\");\n/**\r\n * @ignore\r\n * @internal\r\n *\r\n * Gets the info related to a model class properties.\r\n *\r\n * @param modelClass\r\n */\n\nfunction getInternalModelClassPropsInfo(modelClass) {\n  return modelClass[modelPropertiesSymbol];\n}\n/**\r\n * @ignore\r\n * @internal\r\n *\r\n * Sets the info related to a model class properties.\r\n *\r\n * @param modelClass\r\n */\n\nfunction setInternalModelClassPropsInfo(modelClass, props) {\n  modelClass[modelPropertiesSymbol] = props;\n}\n\n/**\r\n * A type checking error.\r\n */\n\nvar TypeCheckError = /*#__PURE__*/function () {\n  /**\r\n   * Creates an instance of TypeError.\r\n   * @param path Sub-path where the error occured.\r\n   * @param expectedTypeName Name of the expected type.\r\n   * @param actualValue Actual value.\r\n   */\n  function TypeCheckError(path, expectedTypeName, actualValue) {\n    this.path = void 0;\n    this.expectedTypeName = void 0;\n    this.actualValue = void 0;\n    this.path = path;\n    this.expectedTypeName = expectedTypeName;\n    this.actualValue = actualValue;\n  }\n  /**\r\n   * Throws the type check error as an actual error.\r\n   *\r\n   * @param typeCheckedValue Usually the value where the type check was invoked.\r\n   */\n\n\n  var _proto = TypeCheckError.prototype;\n\n  _proto[\"throw\"] = function _throw(typeCheckedValue) {\n    var msg = \"TypeCheckError: \";\n    var rootPath = [];\n\n    if (isTweakedObject(typeCheckedValue, true)) {\n      rootPath = getRootPath(typeCheckedValue).path;\n    }\n\n    msg += \"[/\" + [].concat(rootPath, this.path).join(\"/\") + \"] \";\n    msg += \"Expected: \" + this.expectedTypeName;\n    throw failure(msg);\n  };\n\n  return TypeCheckError;\n}();\n\nvar emptyPath = [];\nvar typeCheckersWithCachedResultsOfObject = /*#__PURE__*/new WeakMap();\n/**\r\n * @ignore\r\n */\n\nfunction invalidateCachedTypeCheckerResult(obj) {\n  // we need to invalidate it for the object and all its parents\n  var current = obj;\n\n  while (current) {\n    var set = typeCheckersWithCachedResultsOfObject.get(current);\n\n    if (set) {\n      for (var _iterator = _createForOfIteratorHelperLoose(set), _step; !(_step = _iterator()).done;) {\n        var typeChecker = _step.value;\n        typeChecker.invalidateCachedResult(current);\n      }\n\n      typeCheckersWithCachedResultsOfObject[\"delete\"](current);\n    }\n\n    current = fastGetParentIncludingDataObjects(current);\n  }\n}\n/**\r\n * @ignore\r\n */\n\nvar TypeChecker = /*#__PURE__*/function () {\n  var _proto = TypeChecker.prototype;\n\n  _proto.createCacheIfNeeded = function createCacheIfNeeded() {\n    if (!this.checkResultCache) {\n      this.checkResultCache = new WeakMap();\n    }\n\n    return this.checkResultCache;\n  };\n\n  _proto.setCachedResult = function setCachedResult(obj, newCacheValue) {\n    this.createCacheIfNeeded().set(obj, newCacheValue); // register this type checker as listener of that object changes\n\n    var typeCheckerSet = typeCheckersWithCachedResultsOfObject.get(obj);\n\n    if (!typeCheckerSet) {\n      typeCheckerSet = new Set();\n      typeCheckersWithCachedResultsOfObject.set(obj, typeCheckerSet);\n    }\n\n    typeCheckerSet.add(this);\n  };\n\n  _proto.invalidateCachedResult = function invalidateCachedResult(obj) {\n    if (this.checkResultCache) {\n      this.checkResultCache[\"delete\"](obj);\n    }\n  };\n\n  _proto.getCachedResult = function getCachedResult(obj) {\n    return this.checkResultCache ? this.checkResultCache.get(obj) : undefined;\n  };\n\n  _proto.check = function check(value, path) {\n    if (this.unchecked) {\n      return null;\n    }\n\n    if (!isTweakedObject(value, true)) {\n      return this._check(value, path);\n    } // optimized checking with cached values\n\n\n    var cachedResult = this.getCachedResult(value);\n\n    if (cachedResult === undefined) {\n      // we set the path empty since the result could be used for paths other than this base\n      cachedResult = this._check(value, emptyPath);\n      this.setCachedResult(value, cachedResult);\n    }\n\n    if (cachedResult) {\n      return new TypeCheckError([].concat(path, cachedResult.path), cachedResult.expectedTypeName, cachedResult.actualValue);\n    } else {\n      return null;\n    }\n  };\n\n  _createClass(TypeChecker, [{\n    key: \"typeInfo\",\n    get: function get() {\n      return this._cachedTypeInfoGen(this);\n    }\n  }]);\n\n  function TypeChecker(_check, getTypeName, typeInfoGen) {\n    this._check = void 0;\n    this.getTypeName = void 0;\n    this.checkResultCache = void 0;\n    this.unchecked = void 0;\n    this._cachedTypeInfoGen = void 0;\n    this._check = _check;\n    this.getTypeName = getTypeName;\n    this.unchecked = !_check;\n    this._cachedTypeInfoGen = lateVal(typeInfoGen);\n  }\n\n  return TypeChecker;\n}();\nvar lateTypeCheckerSymbol = /*#__PURE__*/Symbol(\"lateTypeCheker\");\n/**\r\n * @ignore\r\n */\n\nfunction lateTypeChecker(fn, typeInfoGen) {\n  var cached;\n\n  var ltc = function ltc() {\n    if (cached) {\n      return cached;\n    }\n\n    cached = fn();\n    return cached;\n  };\n\n  ltc[lateTypeCheckerSymbol] = true;\n  var cachedTypeInfoGen = lateVal(typeInfoGen);\n  Object.defineProperty(ltc, \"typeInfo\", {\n    enumerable: true,\n    configurable: true,\n    get: function get() {\n      return cachedTypeInfoGen(ltc);\n    }\n  });\n  return ltc;\n}\n/**\r\n * @ignore\r\n */\n\nfunction isLateTypeChecker(ltc) {\n  return typeof ltc === \"function\" && ltc[lateTypeCheckerSymbol];\n}\n/**\r\n * Type info base class.\r\n */\n\nvar TypeInfo = function TypeInfo(thisType) {\n  this.thisType = void 0;\n  this.thisType = thisType;\n};\n/**\r\n * Gets the type info of a given type.\r\n *\r\n * @param type Type to get the info from.\r\n * @returns The type info.\r\n */\n\nfunction getTypeInfo(type) {\n  var stdType = resolveStandardType(type);\n  var typeInfo = stdType.typeInfo;\n\n  if (!typeInfo) {\n    throw failure(\"type info not found for \" + type);\n  }\n\n  return typeInfo;\n}\n\n/**\r\n * A refinement over a given type. This allows you to do extra checks\r\n * over models, ensure numbers are integers, etc.\r\n *\r\n * Example:\r\n * ```ts\r\n * const integerType = types.refinement(types.number, (n) => {\r\n *   return Number.isInteger(n)\r\n * }, \"integer\")\r\n *\r\n * const sumModelType = types.refinement(types.model<Sum>(Sum), (sum) => {\r\n *   // imagine that for some reason sum includes a number 'a', a number 'b'\r\n *   // and the result\r\n *\r\n *   const rightResult = sum.a + sum.b === sum.result\r\n *\r\n *   // simple mode that will just return that the whole model is incorrect\r\n *   return rightResult\r\n *\r\n *   // this will return that the result field is wrong\r\n *   return rightResult ? null : new TypeCheckError([\"result\"], \"a+b\", sum.result)\r\n * })\r\n * ```\r\n *\r\n * @template T Base type.\r\n * @param baseType Base type.\r\n * @param checkFn Function that will receive the data (if it passes the base type\r\n * check) and return null or false if there were no errors or either a TypeCheckError instance or\r\n * true if there were.\r\n * @returns\r\n */\n\nfunction typesRefinement(baseType, checkFn, typeName) {\n  var typeInfoGen = function typeInfoGen(t) {\n    return new RefinementTypeInfo(t, resolveStandardType(baseType), checkFn, typeName);\n  };\n\n  return lateTypeChecker(function () {\n    var baseChecker = resolveTypeChecker(baseType);\n\n    var getTypeName = function getTypeName() {\n      for (var _len = arguments.length, recursiveTypeCheckers = new Array(_len), _key = 0; _key < _len; _key++) {\n        recursiveTypeCheckers[_key] = arguments[_key];\n      }\n\n      var baseTypeName = baseChecker.getTypeName.apply(baseChecker, recursiveTypeCheckers.concat([baseChecker]));\n      var refinementName = typeName || \"refinementOf\";\n      return refinementName + \"<\" + baseTypeName + \">\";\n    };\n\n    var thisTc = new TypeChecker(function (data, path) {\n      var baseErr = baseChecker.check(data, path);\n\n      if (baseErr) {\n        return baseErr;\n      }\n\n      var refinementErr = checkFn(data);\n\n      if (refinementErr === true) {\n        return null;\n      } else if (refinementErr === false) {\n        return new TypeCheckError(path, getTypeName(thisTc), data);\n      } else {\n        return refinementErr != null ? refinementErr : null;\n      }\n    }, getTypeName, typeInfoGen);\n    return thisTc;\n  }, typeInfoGen);\n}\n/**\r\n * `types.refinement` type info.\r\n */\n\nvar RefinementTypeInfo = /*#__PURE__*/function (_TypeInfo) {\n  _inheritsLoose(RefinementTypeInfo, _TypeInfo);\n\n  _createClass(RefinementTypeInfo, [{\n    key: \"baseTypeInfo\",\n    get: function get() {\n      return getTypeInfo(this.baseType);\n    }\n  }]);\n\n  function RefinementTypeInfo(thisType, baseType, checkFunction, typeName) {\n    var _this;\n\n    _this = _TypeInfo.call(this, thisType) || this;\n    _this.baseType = void 0;\n    _this.checkFunction = void 0;\n    _this.typeName = void 0;\n    _this.baseType = baseType;\n    _this.checkFunction = checkFunction;\n    _this.typeName = typeName;\n    return _this;\n  }\n\n  return RefinementTypeInfo;\n}(TypeInfo);\n\n/**\r\n * A type that represents a certain value of a primitive (for example an *exact* number or string).\r\n *\r\n * Example\r\n * ```ts\r\n * const hiType = types.literal(\"hi\") // the string with value \"hi\"\r\n * const number5Type = types.literal(5) // the number with value 5\r\n * ```\r\n *\r\n * @typeparam T Literal value type.\r\n * @param literal Literal value.\r\n * @returns\r\n */\n\nfunction typesLiteral(literal) {\n  assertIsPrimitive(literal, \"literal\");\n  var typeName;\n\n  switch (literal) {\n    case undefined:\n      typeName = \"undefined\";\n      break;\n\n    case null:\n      typeName = \"null\";\n      break;\n\n    default:\n      typeName = JSON.stringify(literal);\n      break;\n  }\n\n  var typeInfoGen = function typeInfoGen(t) {\n    return new LiteralTypeInfo(t, literal);\n  };\n\n  return new TypeChecker(function (value, path) {\n    return value === literal ? null : new TypeCheckError(path, typeName, value);\n  }, function () {\n    return typeName;\n  }, typeInfoGen);\n}\n/**\r\n * `types.literal` type info.\r\n */\n\nvar LiteralTypeInfo = /*#__PURE__*/function (_TypeInfo) {\n  _inheritsLoose(LiteralTypeInfo, _TypeInfo);\n\n  function LiteralTypeInfo(thisType, literal) {\n    var _this;\n\n    _this = _TypeInfo.call(this, thisType) || this;\n    _this.literal = void 0;\n    _this.literal = literal;\n    return _this;\n  }\n\n  return LiteralTypeInfo;\n}(TypeInfo);\n/**\r\n * A type that represents the value undefined.\r\n * Syntactic sugar for `types.literal(undefined)`.\r\n *\r\n * ```ts\r\n * types.undefined\r\n * ```\r\n */\n\nvar typesUndefined = /*#__PURE__*/typesLiteral(undefined);\n/**\r\n * A type that represents the value null.\r\n * Syntactic sugar for `types.literal(null)`.\r\n *\r\n * ```ts\r\n * types.null\r\n * ```\r\n */\n\nvar typesNull = /*#__PURE__*/typesLiteral(null);\n/**\r\n * A type that represents any boolean value.\r\n *\r\n * ```ts\r\n * types.boolean\r\n * ```\r\n */\n\nvar typesBoolean = /*#__PURE__*/new TypeChecker(function (value, path) {\n  return typeof value === \"boolean\" ? null : new TypeCheckError(path, \"boolean\", value);\n}, function () {\n  return \"boolean\";\n}, function (t) {\n  return new BooleanTypeInfo(t);\n});\n/**\r\n * `types.boolean` type info.\r\n */\n\nvar BooleanTypeInfo = /*#__PURE__*/function (_TypeInfo2) {\n  _inheritsLoose(BooleanTypeInfo, _TypeInfo2);\n\n  function BooleanTypeInfo() {\n    return _TypeInfo2.apply(this, arguments) || this;\n  }\n\n  return BooleanTypeInfo;\n}(TypeInfo);\n/**\r\n * A type that represents any number value.\r\n *\r\n * ```ts\r\n * types.number\r\n * ```\r\n */\n\nvar typesNumber = /*#__PURE__*/new TypeChecker(function (value, path) {\n  return typeof value === \"number\" ? null : new TypeCheckError(path, \"number\", value);\n}, function () {\n  return \"number\";\n}, function (t) {\n  return new NumberTypeInfo(t);\n});\n/**\r\n * `types.number` type info.\r\n */\n\nvar NumberTypeInfo = /*#__PURE__*/function (_TypeInfo3) {\n  _inheritsLoose(NumberTypeInfo, _TypeInfo3);\n\n  function NumberTypeInfo() {\n    return _TypeInfo3.apply(this, arguments) || this;\n  }\n\n  return NumberTypeInfo;\n}(TypeInfo);\n/**\r\n * A type that represents any string value.\r\n *\r\n * ```ts\r\n * types.string\r\n * ```\r\n */\n\nvar typesString = /*#__PURE__*/new TypeChecker(function (value, path) {\n  return typeof value === \"string\" ? null : new TypeCheckError(path, \"string\", value);\n}, function () {\n  return \"string\";\n}, function (t) {\n  return new StringTypeInfo(t);\n});\n/**\r\n * `types.string` type info.\r\n */\n\nvar StringTypeInfo = /*#__PURE__*/function (_TypeInfo4) {\n  _inheritsLoose(StringTypeInfo, _TypeInfo4);\n\n  function StringTypeInfo() {\n    return _TypeInfo4.apply(this, arguments) || this;\n  }\n\n  return StringTypeInfo;\n}(TypeInfo);\n/**\r\n * A type that represents any integer number value.\r\n * Syntactic sugar for `types.refinement(types.number, n => Number.isInteger(n), \"integer\")`\r\n *\r\n * ```ts\r\n * types.integer\r\n * ```\r\n */\n\nvar typesInteger = /*#__PURE__*/typesRefinement(typesNumber, function (n) {\n  return Number.isInteger(n);\n}, \"integer\");\n/**\r\n * A type that represents any string value other than \"\".\r\n * Syntactic sugar for `types.refinement(types.string, s => s !== \"\", \"nonEmpty\")`\r\n *\r\n * ```ts\r\n * types.nonEmptyString\r\n * ```\r\n */\n\nvar typesNonEmptyString = /*#__PURE__*/typesRefinement(typesString, function (s) {\n  return s !== \"\";\n}, \"nonEmpty\");\n\n/**\r\n * @ignore\r\n */\n\nfunction resolveTypeChecker(v) {\n  var next = v;\n\n  while (true) {\n    if (next instanceof TypeChecker) {\n      return next;\n    } else if (v === String) {\n      return typesString;\n    } else if (v === Number) {\n      return typesNumber;\n    } else if (v === Boolean) {\n      return typesBoolean;\n    } else if (v === null) {\n      return typesNull;\n    } else if (v === undefined) {\n      return typesUndefined;\n    } else if (isLateTypeChecker(next)) {\n      next = next();\n    } else {\n      throw failure(\"type checker could not be resolved\");\n    }\n  }\n}\n/**\r\n * @ignore\r\n */\n\nfunction resolveStandardType(v) {\n  if (v instanceof TypeChecker || isLateTypeChecker(v)) {\n    return v;\n  } else if (v === String) {\n    return typesString;\n  } else if (v === Number) {\n    return typesNumber;\n  } else if (v === Boolean) {\n    return typesBoolean;\n  } else if (v === null) {\n    return typesNull;\n  } else if (v === undefined) {\n    return typesUndefined;\n  } else {\n    throw failure(\"standard type could not be resolved\");\n  }\n}\n\nvar cachedModelTypeChecker = /*#__PURE__*/new WeakMap();\n/**\r\n * A type that represents a model. The type referenced in the model decorator will be used for type checking.\r\n *\r\n * Example:\r\n * ```ts\r\n * const someModelType = types.model<SomeModel>(SomeModel)\r\n * // or for recursive models\r\n * const someModelType = types.model<SomeModel>(() => SomeModel)\r\n * ```\r\n *\r\n * @typeparam M Model type.\r\n * @param modelClass Model class.\r\n * @returns\r\n */\n\nfunction typesModel(modelClass) {\n  // if we type it any stronger then recursive defs and so on stop working\n  if (!isModelClass(modelClass) && typeof modelClass === \"function\") {\n    // resolve later\n    var typeInfoGen = function typeInfoGen(t) {\n      return new ModelTypeInfo(t, modelClass());\n    };\n\n    return lateTypeChecker(function () {\n      return typesModel(modelClass());\n    }, typeInfoGen);\n  } else {\n    var modelClazz = modelClass;\n    assertIsModelClass(modelClazz, \"modelClass\");\n    var cachedTypeChecker = cachedModelTypeChecker.get(modelClazz);\n\n    if (cachedTypeChecker) {\n      return cachedTypeChecker;\n    }\n\n    var _typeInfoGen = function _typeInfoGen(t) {\n      return new ModelTypeInfo(t, modelClazz);\n    };\n\n    var tc = lateTypeChecker(function () {\n      var modelInfo = modelInfoByClass.get(modelClazz);\n      var typeName = \"Model(\" + modelInfo.name + \")\";\n      return new TypeChecker(function (value, path) {\n        if (!(value instanceof modelClazz)) {\n          return new TypeCheckError(path, typeName, value);\n        }\n\n        var dataTypeChecker = getModelDataType(value);\n\n        if (!dataTypeChecker) {\n          throw failure(\"type checking cannot be performed over model of type '\" + modelInfo.name + \"' at path \" + path.join(\"/\") + \" since that model type has no data type declared, consider adding a data type or using types.unchecked() instead\");\n        }\n\n        var resolvedTc = resolveTypeChecker(dataTypeChecker);\n\n        if (!resolvedTc.unchecked) {\n          return resolvedTc.check(value.$, path);\n        }\n\n        return null;\n      }, function () {\n        return typeName;\n      }, _typeInfoGen);\n    }, _typeInfoGen);\n    cachedModelTypeChecker.set(modelClazz, tc);\n    return tc;\n  }\n}\n/**\r\n * `types.model` type info.\r\n */\n\nvar ModelTypeInfo = /*#__PURE__*/function (_TypeInfo) {\n  _inheritsLoose(ModelTypeInfo, _TypeInfo);\n\n  _createClass(ModelTypeInfo, [{\n    key: \"props\",\n    get: function get() {\n      return this._props();\n    }\n  }, {\n    key: \"modelType\",\n    get: function get() {\n      var modelInfo = modelInfoByClass.get(this.modelClass);\n      return modelInfo.name;\n    }\n  }]);\n\n  function ModelTypeInfo(thisType, modelClass) {\n    var _this;\n\n    _this = _TypeInfo.call(this, thisType) || this;\n    _this.modelClass = void 0;\n    _this._props = lateVal(function () {\n      var objSchema = getInternalModelClassPropsInfo(_this.modelClass);\n      var propTypes = {};\n      Object.keys(objSchema).forEach(function (propName) {\n        var propData = objSchema[propName];\n        var type = propData.typeChecker;\n        var typeInfo;\n\n        if (type) {\n          typeInfo = getTypeInfo(type);\n        }\n\n        var hasDefault = false;\n        var defaultValue;\n\n        if (propData.defaultFn !== noDefaultValue) {\n          defaultValue = propData.defaultFn;\n          hasDefault = true;\n        } else if (propData.defaultValue !== noDefaultValue) {\n          defaultValue = propData.defaultValue;\n          hasDefault = true;\n        }\n\n        propTypes[propName] = {\n          type: type,\n          typeInfo: typeInfo,\n          hasDefault: hasDefault,\n          \"default\": defaultValue\n        };\n      });\n      return propTypes;\n    });\n    _this.modelClass = modelClass;\n    return _this;\n  }\n\n  return ModelTypeInfo;\n}(TypeInfo);\n\n/**\r\n * Checks if a value conforms to a given type.\r\n *\r\n * @typename T Type.\r\n * @param type Type to check for.\r\n * @param value Value to check.\r\n * @returns A TypeError if the check fails or null if no error.\r\n */\n\nfunction typeCheck(type, value) {\n  var typeChecker = resolveTypeChecker(type);\n\n  if (typeChecker.unchecked) {\n    return null;\n  } else {\n    return typeChecker.check(value, []);\n  }\n}\n\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction canWrite() {\n  return !getActionProtection() || !!getCurrentActionContext();\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertCanWrite() {\n  if (!canWrite()) {\n    throw failure(\"data changes must be performed inside model actions\");\n  }\n}\nvar actionProtection = true;\n/**\r\n * @ignore\r\n * @internal\r\n *\r\n * Gets if the action protection is currently enabled or not.\r\n *\r\n * @returns\r\n */\n\nfunction getActionProtection() {\n  return actionProtection;\n} // base case\n\nfunction runUnprotected(arg1, arg2) {\n  var name = typeof arg1 === \"string\" ? arg1 : undefined;\n  var fn = typeof arg1 === \"string\" ? arg2 : arg1;\n\n  var innerAction = function innerAction() {\n    var oldActionProtection = actionProtection;\n    actionProtection = false;\n\n    try {\n      return fn();\n    } finally {\n      actionProtection = oldActionProtection;\n      tryRunPendingActions();\n    }\n  };\n\n  if (name) {\n    return action(name, innerAction)();\n  } else {\n    return action(innerAction)();\n  }\n}\n\nvar pendingActions = [];\n\nfunction isActionRunning() {\n  return !getActionProtection() || getCurrentActionContext();\n}\n/**\r\n * @ignore\r\n */\n\n\nfunction enqueuePendingAction(action) {\n  // delay action until all current actions are finished\n  if (isActionRunning()) {\n    pendingActions.push(action);\n  } else {\n    action();\n  }\n}\n/**\r\n * @ignore\r\n */\n\nfunction tryRunPendingActions() {\n  if (isActionRunning()) {\n    return false;\n  }\n\n  while (pendingActions.length > 0) {\n    var nextAction = pendingActions.shift();\n    nextAction();\n  }\n\n  return true;\n}\n\n/**\r\n * A hook action.\r\n */\nvar HookAction;\n\n(function (HookAction) {\n  /**\r\n   * onInit hook\r\n   */\n  HookAction[\"OnInit\"] = \"$$onInit\";\n  /**\r\n   * onAttachedToRootStore hook\r\n   */\n\n  HookAction[\"OnAttachedToRootStore\"] = \"$$onAttachedToRootStore\";\n  /**\r\n   * disposer for onAttachedToRootStore hook\r\n   */\n\n  HookAction[\"OnAttachedToRootStoreDisposer\"] = \"$$onAttachedToRootStoreDisposer\";\n})(HookAction || (HookAction = {}));\n\nvar hookActionValues = /*#__PURE__*/new Set( /*#__PURE__*/Object.values(HookAction));\n/**\r\n * Returns if a given action name corresponds to a hook, this is, one of:\r\n * - onInit() hook\r\n * - onAttachedToRootStore() hook\r\n * - disposer returned by a onAttachedToRootStore() hook\r\n *\r\n * @param actionName Action name to check.\r\n * @returns true if it is a hook, false otherwise.\r\n */\n\nfunction isHookAction(actionName) {\n  return hookActionValues.has(actionName);\n}\n\nvar perObjectActionMiddlewares = /*#__PURE__*/new WeakMap();\nvar perObjectActionMiddlewaresIterator = /*#__PURE__*/new WeakMap();\n/**\r\n * @ignore\r\n * @internal\r\n *\r\n * Gets the current action middlewares to be run over a given object as an iterable object.\r\n *\r\n * @returns\r\n */\n\nfunction getActionMiddlewares(obj) {\n  // when we call a middleware we will call the middlewares of that object plus all parent objects\n  // the parent object middlewares are run last\n  // since an array like [a, b, c] will be called like c(b(a())) this means that we need to put\n  // the parent object ones at the end of the array\n  var iterable = perObjectActionMiddlewaresIterator.get(obj);\n\n  if (!iterable) {\n    var _iterable;\n\n    iterable = (_iterable = {}, _iterable[Symbol.iterator] = function () {\n      var current = obj;\n\n      function getCurrentIterator() {\n        var objMwares = current ? perObjectActionMiddlewares.get(current) : undefined;\n\n        if (!objMwares || objMwares.length <= 0) {\n          return undefined;\n        }\n\n        return objMwares[Symbol.iterator]();\n      }\n\n      function findNextIterator() {\n        var nextIter;\n\n        while (current && !nextIter) {\n          current = fastGetParent(current);\n          nextIter = getCurrentIterator();\n        }\n\n        return nextIter;\n      }\n\n      var iter = getCurrentIterator();\n\n      if (!iter) {\n        iter = findNextIterator();\n      }\n\n      var iterator = {\n        next: function next() {\n          if (!iter) {\n            return {\n              value: undefined,\n              done: true\n            };\n          }\n\n          var result = iter.next();\n\n          if (!result.done) {\n            return result;\n          }\n\n          iter = findNextIterator();\n          return this.next();\n        }\n      };\n      return iterator;\n    }, _iterable);\n    perObjectActionMiddlewaresIterator.set(obj, iterable);\n  }\n\n  return iterable;\n}\n/**\r\n * Adds a global action middleware to be run when an action is performed.\r\n * It is usually preferable to use `onActionMiddleware` instead to limit it to a given tree and only to topmost level actions\r\n * or `actionTrackingMiddleware` for a simplified middleware.\r\n *\r\n * @param mware Action middleware to be run.\r\n * @returns A disposer to cancel the middleware. Note that if you don't plan to do an early disposal of the middleware\r\n * calling this function becomes optional.\r\n */\n\nfunction addActionMiddleware(mware) {\n  assertIsObject(mware, \"middleware\");\n  var middleware = mware.middleware,\n      filter = mware.filter,\n      subtreeRoot = mware.subtreeRoot;\n  assertTweakedObject(subtreeRoot, \"middleware.subtreeRoot\");\n  assertIsFunction(middleware, \"middleware.middleware\");\n\n  if (filter && typeof filter !== \"function\") {\n    throw failure(\"middleware.filter must be a function or undefined\");\n  } // reminder: never turn middlewares into actions or else\n  // reactions will not be picked up by the undo manager\n\n\n  if (subtreeRoot) {\n    var targetFilter = function targetFilter(ctx) {\n      return ctx.target === subtreeRoot || isChildOfParent(ctx.target, subtreeRoot);\n    };\n\n    if (!filter) {\n      filter = targetFilter;\n    } else {\n      var customFilter = filter;\n\n      filter = function filter(ctx) {\n        return targetFilter(ctx) && customFilter(ctx);\n      };\n    }\n  }\n\n  var actualMware = {\n    middleware: middleware,\n    filter: filter\n  };\n  var objMwares = perObjectActionMiddlewares.get(subtreeRoot);\n\n  if (!objMwares) {\n    objMwares = [actualMware];\n    perObjectActionMiddlewares.set(subtreeRoot, objMwares);\n  } else {\n    objMwares.push(actualMware);\n  }\n\n  return function () {\n    deleteFromArray(objMwares, actualMware);\n  };\n}\n\n/**\r\n * @ignore\r\n */\n\nvar modelActionSymbol = /*#__PURE__*/Symbol(\"modelAction\");\n/**\r\n * @ignore\r\n */\n\nfunction wrapInAction(_ref) {\n  var name = _ref.name,\n      fn = _ref.fn,\n      actionType = _ref.actionType,\n      overrideContext = _ref.overrideContext,\n      _ref$isFlowFinisher = _ref.isFlowFinisher,\n      isFlowFinisher = _ref$isFlowFinisher === void 0 ? false : _ref$isFlowFinisher;\n  // we need to make only inner actions actual mobx actions\n  // so reactions (e.g. reference detaching) are picked up in the\n  // right context\n  fn = action(name, fn);\n\n  var wrappedAction = function wrappedAction() {\n    var _fn;\n\n    var target = this;\n\n    if (inDevMode()) {\n      assertTweakedObject(target, \"wrappedAction\");\n    }\n\n    var parentContext = getCurrentActionContext();\n    var context = {\n      actionName: name,\n      type: actionType,\n      target: target,\n      args: Array.from(arguments),\n      parentContext: parentContext,\n      data: {},\n      rootContext: undefined\n    };\n\n    if (overrideContext) {\n      overrideContext(context);\n    }\n\n    if (!context.rootContext) {\n      if (context.previousAsyncStepContext) {\n        context.rootContext = context.previousAsyncStepContext.rootContext;\n      } else if (context.parentContext) {\n        context.rootContext = context.parentContext.rootContext;\n      } else {\n        context.rootContext = context;\n      }\n    }\n\n    setCurrentActionContext(context);\n\n    var mwareFn = (_fn = fn).bind.apply(_fn, [target].concat(Array.prototype.slice.call(arguments)));\n\n    var mwareIter = getActionMiddlewares(target)[Symbol.iterator]();\n    var mwareCur = mwareIter.next();\n\n    while (!mwareCur.done) {\n      var mware = mwareCur.value;\n      var filterPassed = mware.filter ? mware.filter(context) : true;\n\n      if (filterPassed) {\n        mwareFn = mware.middleware.bind(undefined, context, mwareFn);\n      }\n\n      mwareCur = mwareIter.next();\n    }\n\n    try {\n      var ret = mwareFn();\n\n      if (isFlowFinisher) {\n        var flowFinisher = ret;\n        var value = flowFinisher.value;\n\n        if (flowFinisher.resolution === \"accept\") {\n          flowFinisher.accepter(value);\n        } else {\n          flowFinisher.rejecter(value);\n        }\n\n        return value; // not sure if this is even needed\n      } else {\n        return ret;\n      }\n    } finally {\n      setCurrentActionContext(context.parentContext);\n      tryRunPendingActions();\n    }\n  };\n\n  wrappedAction[modelActionSymbol] = true;\n  return wrappedAction;\n}\n/**\r\n * @ignore\r\n */\n\nfunction wrapModelMethodInActionIfNeeded(model, propertyKey, name) {\n  var fn = model[propertyKey];\n\n  if (isModelAction(fn)) {\n    return;\n  }\n\n  var wrappedFn = wrapInAction({\n    name: name,\n    fn: fn,\n    actionType: ActionContextActionType.Sync\n  });\n  var proto = Object.getPrototypeOf(model);\n  var protoFn = proto[propertyKey];\n\n  if (protoFn === fn) {\n    proto[propertyKey] = wrappedFn;\n  } else {\n    model[propertyKey] = wrappedFn;\n  }\n}\n\n/**\r\n * Mode for the `walkTree` method.\r\n */\n\nvar WalkTreeMode;\n\n(function (WalkTreeMode) {\n  /**\r\n   * The walk will be done parent (roots) first, then children.\r\n   */\n  WalkTreeMode[\"ParentFirst\"] = \"parentFirst\";\n  /**\r\n   * The walk will be done children (leafs) first, then parents.\r\n   */\n\n  WalkTreeMode[\"ChildrenFirst\"] = \"childrenFirst\";\n})(WalkTreeMode || (WalkTreeMode = {}));\n/**\r\n * Walks a tree, running the predicate function for each node.\r\n * If the predicate function returns something other than undefined,\r\n * then the walk will be stopped and the function will return the returned value.\r\n *\r\n * @typeparam T Returned object type, defaults to void.\r\n * @param target Subtree root object.\r\n * @param predicate Function that will be run for each node of the tree.\r\n * @param mode Mode to walk the tree, as defined in `WalkTreeMode`.\r\n * @returns\r\n */\n\n\nfunction walkTree(target, predicate, mode) {\n  assertTweakedObject(target, \"target\");\n\n  if (mode === WalkTreeMode.ParentFirst) {\n    var recurse = function recurse(child) {\n      return walkTreeParentFirst(child, predicate, recurse);\n    };\n\n    return walkTreeParentFirst(target, predicate, recurse);\n  } else {\n    var _recurse = function _recurse(child) {\n      return walkTreeChildrenFirst(child, predicate, _recurse);\n    };\n\n    return walkTreeChildrenFirst(target, predicate, _recurse);\n  }\n}\n\nfunction walkTreeParentFirst(target, rootPredicate, recurse) {\n  var ret = rootPredicate(target);\n\n  if (ret !== undefined) {\n    return ret;\n  }\n\n  var childrenIter = getObjectChildren(target).values();\n  var ch = childrenIter.next();\n\n  while (!ch.done) {\n    var _ret = recurse(ch.value);\n\n    if (_ret !== undefined) {\n      return _ret;\n    }\n\n    ch = childrenIter.next();\n  }\n\n  return undefined;\n}\n\nfunction walkTreeChildrenFirst(target, rootPredicate, recurse) {\n  var childrenIter = getObjectChildren(target).values();\n  var ch = childrenIter.next();\n\n  while (!ch.done) {\n    var _ret2 = recurse(ch.value);\n\n    if (_ret2 !== undefined) {\n      return _ret2;\n    }\n\n    ch = childrenIter.next();\n  }\n\n  var ret = rootPredicate(target);\n\n  if (ret !== undefined) {\n    return ret;\n  }\n\n  return undefined;\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\n\nfunction computedWalkTreeAggregate(predicate) {\n  var computedFns = new WeakMap();\n\n  var getComputedTreeResult = function getComputedTreeResult(tree) {\n    var cmpted = computedFns.get(tree);\n\n    if (!cmpted) {\n      cmpted = computed(function () {\n        return walkTreeAggregate(tree, predicate, recurse);\n      });\n      computedFns.set(tree, cmpted);\n    }\n\n    return cmpted.get();\n  };\n\n  var recurse = function recurse(ch) {\n    return getComputedTreeResult(ch);\n  };\n\n  return {\n    walk: function walk(target) {\n      return getComputedTreeResult(target);\n    }\n  };\n}\n\nfunction walkTreeAggregate(target, rootPredicate, recurse) {\n  var map;\n  var rootVal = rootPredicate(target);\n  var childrenMap = getObjectChildren(target);\n  var childrenIter = childrenMap.values();\n  var ch = childrenIter.next(); // small optimization, if there is only one child and this\n  // object provides no value we can just reuse the child ones\n\n  if (rootVal === undefined && childrenMap.size === 1) {\n    return recurse(ch.value);\n  }\n\n  while (!ch.done) {\n    var childMap = recurse(ch.value);\n\n    if (childMap) {\n      if (!map) {\n        map = new Map();\n      } // add child map keys/values to own map\n\n\n      var mapIter = childMap.keys();\n      var mapCur = mapIter.next();\n\n      while (!mapCur.done) {\n        var key = mapCur.value;\n        var val = childMap.get(key);\n        map.set(key, val);\n        mapCur = mapIter.next();\n      }\n    }\n\n    ch = childrenIter.next();\n  } // add it at the end so parent resolutions have higher\n  // priority than child ones\n\n\n  if (rootVal !== undefined) {\n    if (!map) {\n      map = new Map();\n    }\n\n    map.set(rootVal, target);\n  }\n\n  return map;\n}\n\nvar onAttachedDisposers = /*#__PURE__*/new WeakMap();\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nvar attachToRootStore = /*#__PURE__*/action(\"attachToRootStore\", function (rootStore, child) {\n  // we use an array to ensure they will get called even if the actual hook modifies the tree\n  var childrenToCall = [];\n  walkTree(child, function (ch) {\n    if (ch instanceof BaseModel && ch.onAttachedToRootStore) {\n      wrapModelMethodInActionIfNeeded(ch, \"onAttachedToRootStore\", HookAction.OnAttachedToRootStore);\n      childrenToCall.push(ch);\n    }\n  }, WalkTreeMode.ParentFirst);\n  var childrenToCallLen = childrenToCall.length;\n\n  for (var i = 0; i < childrenToCallLen; i++) {\n    var ch = childrenToCall[i];\n    var disposer = ch.onAttachedToRootStore(rootStore);\n\n    if (disposer) {\n      onAttachedDisposers.set(ch, disposer);\n    }\n  }\n});\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nvar detachFromRootStore = /*#__PURE__*/action(\"detachFromRootStore\", function (child) {\n  // we use an array to ensure they will get called even if the actual hook modifies the tree\n  var disposersToCall = [];\n  walkTree(child, function (ch) {\n    var disposer = onAttachedDisposers.get(ch);\n\n    if (disposer) {\n      // wrap disposer in action\n      var disposerAction = wrapInAction({\n        name: HookAction.OnAttachedToRootStoreDisposer,\n        fn: disposer,\n        actionType: ActionContextActionType.Sync\n      }).bind(ch);\n      onAttachedDisposers[\"delete\"](ch);\n      disposersToCall.push(disposerAction);\n    }\n  }, WalkTreeMode.ChildrenFirst);\n  var disposersToCallLen = disposersToCall.length;\n\n  for (var i = 0; i < disposersToCallLen; i++) {\n    disposersToCall[i]();\n  }\n});\n\nvar rootStores = /*#__PURE__*/new WeakSet();\nvar rootStoreAtoms = /*#__PURE__*/new WeakMap();\n/**\r\n * Registers a model / tree node object as a root store tree.\r\n * Marking a model object as a root store tree serves several purposes:\r\n * - It allows the `onAttachedToRootStore` hook (plus disposer) to be invoked on models once they become part of this tree.\r\n *   These hooks can be used for example to attach effects and serve as some sort of initialization.\r\n * - It allows auto detachable references to work properly.\r\n *\r\n * @typeparam T Object type.\r\n * @param node Node object to register as root store.\r\n * @returns The same model object that was passed.\r\n */\n\nvar registerRootStore = /*#__PURE__*/action(\"registerRootStore\", function (node) {\n  assertTweakedObject(node, \"node\");\n\n  if (rootStores.has(node)) {\n    throw failure(\"object already registered as root store\");\n  }\n\n  if (!isRoot(node)) {\n    throw failure(\"a root store must not have a parent\");\n  }\n\n  rootStores.add(node);\n  attachToRootStore(node, node);\n  getOrCreateRootStoreAtom(node).reportChanged();\n  return node;\n});\n/**\r\n * Unregisters an object to mark it as no longer a root store.\r\n *\r\n * @param node Node object to unregister as root store.\r\n */\n\nvar unregisterRootStore = /*#__PURE__*/action(\"unregisterRootStore\", function (node) {\n  if (!isRootStore(node)) {\n    throw failure(\"not a root store\");\n  }\n\n  rootStores[\"delete\"](node);\n  detachFromRootStore(node);\n  getOrCreateRootStoreAtom(node).reportChanged();\n});\n/**\r\n * Checks if a given object is marked as a root store.\r\n *\r\n * @param node Object.\r\n * @returns\r\n */\n\nfunction isRootStore(node) {\n  assertTweakedObject(node, \"node\");\n  return fastIsRootStore(node);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction fastIsRootStore(node) {\n  getOrCreateRootStoreAtom(node).reportObserved();\n  return rootStores.has(node);\n}\n/**\r\n * Gets the root store of a given tree child, or undefined if none.\r\n *\r\n * @typeparam T Root store type.\r\n * @param node Target to find the root store for.\r\n * @returns\r\n */\n\nfunction getRootStore(node) {\n  assertTweakedObject(node, \"node\");\n  return fastGetRootStore(node);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction fastGetRootStore(node) {\n  var root = fastGetRoot(node);\n  return fastIsRootStore(root) ? root : undefined;\n}\n\nfunction getOrCreateRootStoreAtom(node) {\n  var atom = rootStoreAtoms.get(node);\n\n  if (!atom) {\n    atom = createAtom(\"rootStore\");\n    rootStoreAtoms.set(node, atom);\n  }\n\n  return atom;\n}\n\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nvar setParent = /*#__PURE__*/action(\"setParent\", function (value, parentPath, indexChangeAllowed, isDataObject) {\n  if (isPrimitive(value)) {\n    return;\n  }\n\n  if (inDevMode()) {\n    if (typeof value === \"function\" || typeof value === \"symbol\") {\n      throw failure(\"assertion failed: value cannot be a function or a symbol\");\n    }\n\n    if (!isTweakedObject(value, true)) {\n      throw failure(\"assertion failed: value is not ready to take a parent\");\n    }\n\n    if (parentPath) {\n      if (!isTweakedObject(parentPath.parent, true)) {\n        throw failure(\"assertion failed: parent is not ready to take children\");\n      }\n    }\n  }\n\n  if (isDataObject) {\n    dataObjectParent.set(value, parentPath.parent); // data object will proxy to use the actual parent model for child/parent stuff\n\n    return;\n  }\n\n  initializeObjectChildren(value); // make sure the new parent actually points to models when we give model data objs\n\n  if (parentPath) {\n    var actualParent = dataToModelNode(parentPath.parent);\n\n    if (parentPath.parent !== actualParent) {\n      parentPath = {\n        parent: actualParent,\n        path: parentPath.path\n      };\n    }\n  }\n\n  var oldParentPath = fastGetParentPath(value);\n\n  if (parentPathEquals(oldParentPath, parentPath)) {\n    return;\n  }\n\n  if (isRootStore(value)) {\n    throw failure(\"root stores cannot be attached to any parents\");\n  }\n\n  if (oldParentPath && parentPath) {\n    if (oldParentPath.parent === parentPath.parent && indexChangeAllowed) {\n      // just changing the index\n      objectParents.set(value, parentPath);\n      reportParentPathChanged(value);\n      return;\n    } else {\n      throw failure(\"an object cannot be assigned a new parent when it already has one\");\n    }\n  }\n\n  var removeFromOldParent = function removeFromOldParent() {\n    if (oldParentPath != null && oldParentPath.parent) {\n      removeObjectChild(oldParentPath.parent, value);\n    }\n  };\n\n  var attachToNewParent = function attachToNewParent() {\n    var _parentPath;\n\n    objectParents.set(value, parentPath);\n\n    if ((_parentPath = parentPath) != null && _parentPath.parent) {\n      addObjectChild(parentPath.parent, value);\n    }\n\n    reportParentPathChanged(value);\n  };\n\n  if (value instanceof BaseModel) {\n    var oldRoot = fastGetRoot(value);\n    var oldRootStore = isRootStore(oldRoot) ? oldRoot : undefined;\n    removeFromOldParent();\n    attachToNewParent();\n    var newRoot = fastGetRoot(value);\n    var newRootStore = isRootStore(newRoot) ? newRoot : undefined; // invoke model root store events\n\n    if (oldRootStore !== newRootStore && (oldRootStore || newRootStore)) {\n      enqueuePendingAction(function () {\n        if (oldRootStore) {\n          detachFromRootStore(value);\n        }\n\n        if (newRootStore) {\n          attachToRootStore(newRootStore, value);\n        }\n      });\n    }\n  } else {\n    removeFromOldParent();\n    attachToNewParent();\n  }\n});\n\n/**\r\n * @ignore\r\n */\n\nfunction tweakModel(value, parentPath) {\n  tweakedObjects.set(value, undefined);\n  setParent(value, parentPath, false, false); // nothing to do for models, data is already proxified and its parent is set\n  // for snapshots we will use its \"$\" object snapshot directly\n\n  return value;\n}\n\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nvar InternalPatchRecorder = /*#__PURE__*/function () {\n  function InternalPatchRecorder() {\n    this.patches = void 0;\n    this.invPatches = void 0;\n  }\n\n  var _proto = InternalPatchRecorder.prototype;\n\n  _proto.record = function record(patches, invPatches) {\n    this.patches = patches;\n    this.invPatches = invPatches;\n  };\n\n  _proto.emit = function emit(obj) {\n    emitPatch(obj, this.patches, this.invPatches, true);\n  };\n\n  return InternalPatchRecorder;\n}();\nvar patchListeners = /*#__PURE__*/new WeakMap();\nvar globalPatchListeners = [];\n/**\r\n * Adds a listener that will be called every time a patch is generated for the tree of the given target object.\r\n *\r\n * @param subtreeRoot Subtree root object of the patch listener.\r\n * @param listener The listener function that will be called everytime a patch is generated for the object or its children.\r\n * @returns A disposer to stop listening to patches.\r\n */\n\nfunction onPatches(subtreeRoot, listener) {\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\");\n  assertIsFunction(listener, \"listener\");\n\n  if (!isAction(listener)) {\n    listener = action(listener.name || \"onPatchesListener\", listener);\n  }\n\n  var listenersForObject = patchListeners.get(subtreeRoot);\n\n  if (!listenersForObject) {\n    listenersForObject = [];\n    patchListeners.set(subtreeRoot, listenersForObject);\n  }\n\n  listenersForObject.push(listener);\n  return function () {\n    deleteFromArray(listenersForObject, listener);\n  };\n}\n/**\r\n * Adds a listener that will be called every time a patch is generated anywhere.\r\n * Usually prefer using `onPatches`.\r\n *\r\n * @param listener The listener function that will be called everytime a patch is generated anywhere.\r\n * @returns A disposer to stop listening to patches.\r\n */\n\nfunction onGlobalPatches(listener) {\n  assertIsFunction(listener, \"listener\");\n\n  if (!isAction(listener)) {\n    listener = action(listener.name || \"onGlobalPatchesListener\", listener);\n  }\n\n  globalPatchListeners.push(listener);\n  return function () {\n    deleteFromArray(globalPatchListeners, listener);\n  };\n}\n\nfunction emitPatch(obj, patches, inversePatches, emitGlobally) {\n  if (patches.length <= 0 && inversePatches.length <= 0) {\n    return;\n  } // first emit global listeners\n\n\n  if (emitGlobally) {\n    for (var i = 0; i < globalPatchListeners.length; i++) {\n      var listener = globalPatchListeners[i];\n      listener(obj, patches, inversePatches);\n    }\n  } // then per subtree listeners\n\n\n  var listenersForObject = patchListeners.get(obj);\n\n  if (listenersForObject) {\n    for (var _i = 0; _i < listenersForObject.length; _i++) {\n      var _listener = listenersForObject[_i];\n\n      _listener(patches, inversePatches);\n    }\n  } // and also emit subtree listeners all the way to the root\n\n\n  var parentPath = fastGetParentPath(obj);\n\n  if (parentPath) {\n    // tweak patches so they include the child path\n    var childPath = parentPath.path;\n    var newPatches = patches.map(function (p) {\n      return addPathToPatch(p, childPath);\n    });\n    var newInversePatches = inversePatches.map(function (p) {\n      return addPathToPatch(p, childPath);\n    }); // false to avoid emitting global patches again for the same change\n\n    emitPatch(parentPath.parent, newPatches, newInversePatches, false);\n  }\n}\n\nfunction addPathToPatch(patch, path) {\n  return _extends({}, patch, {\n    path: [path].concat(patch.path)\n  });\n}\n\n/**\r\n * Should freeze and plain json checks be done when creating the frozen object?\r\n */\n\nvar FrozenCheckMode;\n\n(function (FrozenCheckMode) {\n  /** Only when in dev mode */\n  FrozenCheckMode[\"DevModeOnly\"] = \"devModeOnly\";\n  /** Always */\n\n  FrozenCheckMode[\"On\"] = \"on\";\n  /** Never */\n\n  FrozenCheckMode[\"Off\"] = \"off\";\n})(FrozenCheckMode || (FrozenCheckMode = {}));\n/**\r\n * @ignore\r\n */\n\n\nvar frozenKey = \"$frozen\";\n/**\r\n * A class that contains frozen data.\r\n * Use `frozen` to create an instance of this class.\r\n *\r\n * @typeparam T Data type.\r\n */\n\nvar Frozen =\n/**\r\n * Frozen data, deeply immutable.\r\n */\n\n/**\r\n * Creates an instance of Frozen.\r\n * Do not use directly, use `frozen` instead.\r\n *\r\n * @param dataToFreeze\r\n * @param checkMode\r\n */\nfunction Frozen(dataToFreeze, checkMode) {\n  if (checkMode === void 0) {\n    checkMode = FrozenCheckMode.DevModeOnly;\n  }\n\n  this.data = void 0;\n  var check = checkMode === FrozenCheckMode.On || checkMode === FrozenCheckMode.DevModeOnly && inDevMode();\n\n  if (check) {\n    checkDataIsSerializableAndFreeze(dataToFreeze);\n  }\n\n  this.data = dataToFreeze;\n\n  if (check) {\n    Object.freeze(this.data);\n  }\n\n  tweak(this, undefined);\n};\n/**\r\n * Marks some data as frozen. Frozen data becomes immutable (at least in dev mode), and is not enhanced\r\n * with capabilities such as getting the parent of the objects (except for the root object), it is not\r\n * made deeply observable (though the root object is observable by reference), etc.\r\n * On the other hand, this means it will be much faster to create/access. Use this for big data pieces\r\n * that are unlikely to change unless all of them change (for example lists of points for a polygon, etc).\r\n *\r\n * Note that data passed to frozen must be serializable to JSON, this is:\r\n * - primitive, plain object, or array\r\n * - without cycles\r\n *\r\n * @param data\r\n * @param checkMode\r\n */\n\nfunction frozen(data, checkMode) {\n  if (checkMode === void 0) {\n    checkMode = FrozenCheckMode.DevModeOnly;\n  }\n\n  return new Frozen(data, checkMode);\n}\n\nfunction checkDataIsSerializableAndFreeze(data) {\n  // TODO: detect cycles and throw if present?\n  // primitives are ok\n  if (isPrimitive(data)) {\n    return;\n  }\n\n  if (Array.isArray(data)) {\n    var arrLen = data.length;\n\n    for (var i = 0; i < arrLen; i++) {\n      var v = data[i];\n\n      if (v === undefined && !getGlobalConfig().allowUndefinedArrayElements) {\n        throw failure(\"undefined is not supported inside arrays since it is not serializable in JSON, consider using null instead\");\n      }\n\n      checkDataIsSerializableAndFreeze(v);\n    }\n\n    Object.freeze(data);\n    return;\n  }\n\n  if (isPlainObject(data)) {\n    var dataKeys = Object.keys(data);\n    var dataKeysLen = dataKeys.length;\n\n    for (var _i = 0; _i < dataKeysLen; _i++) {\n      var k = dataKeys[_i];\n      var _v = data[k];\n      checkDataIsSerializableAndFreeze(k);\n      checkDataIsSerializableAndFreeze(_v);\n    }\n\n    Object.freeze(data);\n    return;\n  }\n\n  throw failure(\"frozen data must be plainly serializable to JSON, but \" + data + \" is not\");\n}\n/**\r\n * @ignore\r\n * @internal\r\n *\r\n * Checks if an snapshot is an snapshot for a frozen data.\r\n *\r\n * @param snapshot\r\n * @returns\r\n */\n\n\nfunction isFrozenSnapshot(snapshot) {\n  return isPlainObject(snapshot) && !!snapshot[frozenKey];\n}\n\n/**\r\n * Iterates through all the parents (from the nearest until the root)\r\n * until one of them matches the given predicate.\r\n * If the predicate is matched it will return the found node.\r\n * If none is found it will return undefined.\r\n *\r\n * @typeparam T Parent object type.\r\n * @param child Target object.\r\n * @param predicate Function that will be run for every parent of the target object, from immediate parent to the root.\r\n * @param maxDepth Max depth, or 0 for infinite.\r\n * @returns\r\n */\n\nfunction findParent(child, predicate, maxDepth) {\n  if (maxDepth === void 0) {\n    maxDepth = 0;\n  }\n\n  var foundParentPath = findParentPath(child, predicate, maxDepth);\n  return foundParentPath ? foundParentPath.parent : undefined;\n}\n/**\r\n * Iterates through all the parents (from the nearest until the root)\r\n * until one of them matches the given predicate.\r\n * If the predicate is matched it will return the found node plus the\r\n * path to get from the parent to the child.\r\n * If none is found it will return undefined.\r\n *\r\n * @typeparam T Parent object type.\r\n * @param child Target object.\r\n * @param predicate Function that will be run for every parent of the target object, from immediate parent to the root.\r\n * @param maxDepth Max depth, or 0 for infinite.\r\n * @returns\r\n */\n\nfunction findParentPath(child, predicate, maxDepth) {\n  if (maxDepth === void 0) {\n    maxDepth = 0;\n  }\n\n  assertTweakedObject(child, \"child\");\n  var path = [];\n  var current = child;\n  var depth = 0;\n  var parentPath;\n\n  while (parentPath = fastGetParentPath(current)) {\n    path.unshift(parentPath.path);\n    current = parentPath.parent;\n\n    if (predicate(current)) {\n      return {\n        parent: current,\n        path: path\n      };\n    }\n\n    depth++;\n\n    if (maxDepth > 0 && depth === maxDepth) {\n      break;\n    }\n  }\n\n  return undefined;\n}\n\n/**\r\n * A built-in action.\r\n */\nvar BuiltInAction;\n\n(function (BuiltInAction) {\n  /**\r\n   * applyPatches\r\n   */\n  BuiltInAction[\"ApplyPatches\"] = \"$$applyPatches\";\n  /**\r\n   * applySnapshot\r\n   */\n\n  BuiltInAction[\"ApplySnapshot\"] = \"$$applySnapshot\";\n  /**\r\n   * detach\r\n   */\n\n  BuiltInAction[\"Detach\"] = \"$$detach\";\n  /**\r\n   * applySet\r\n   */\n\n  BuiltInAction[\"ApplySet\"] = \"$$applySet\";\n  /**\r\n   * applyDelete\r\n   */\n\n  BuiltInAction[\"ApplyDelete\"] = \"$$applyDelete\";\n  /**\r\n   * applyMethodCall\r\n   */\n\n  BuiltInAction[\"ApplyMethodCall\"] = \"$$applyMethodCall\";\n})(BuiltInAction || (BuiltInAction = {}));\n\nvar builtInActionValues = /*#__PURE__*/new Set( /*#__PURE__*/Object.values(BuiltInAction));\n/**\r\n * Returns if a given action name is a built-in action, this is, one of:\r\n * - applyPatches()\r\n * - applySnapshot()\r\n * - detach()\r\n *\r\n * @param actionName Action name to check.\r\n * @returns true if it is a built-in action, false otherwise.\r\n */\n\nfunction isBuiltInAction(actionName) {\n  return builtInActionValues.has(actionName);\n}\n\n/**\r\n * Detaches a given object from a tree.\r\n * If the parent is an object / model, detaching will delete the property.\r\n * If the parent is an array detaching will remove the node by splicing it.\r\n * If there's no parent it will throw.\r\n *\r\n * @param node Object to be detached.\r\n */\n\nfunction detach(node) {\n  assertTweakedObject(node, \"node\");\n  wrappedInternalDetach().call(node);\n}\nvar wrappedInternalDetach = /*#__PURE__*/lazy(function () {\n  return wrapInAction({\n    name: BuiltInAction.Detach,\n    fn: internalDetach,\n    actionType: ActionContextActionType.Sync\n  });\n});\n\nfunction internalDetach() {\n  var node = this;\n  var parentPath = fastGetParentPathIncludingDataObjects(node);\n  if (!parentPath) return;\n  var parent = parentPath.parent,\n      path = parentPath.path;\n\n  if (isObservableArray(parent)) {\n    parent.splice(+path, 1);\n  } else if (isObservableObject(parent)) {\n    remove(parent, \"\" + path);\n  } else {\n    throw failure(\"parent must be an observable object or an observable array\");\n  }\n}\n\n/**\r\n * Returns all the children objects (this is, excluding primitives) of an object.\r\n *\r\n * @param node Object to get the list of children from.\r\n * @param [options] An optional object with the `deep` option (defaults to false) to true to get\r\n * the children deeply or false to get them shallowly.\r\n * @returns A readonly observable set with the children.\r\n */\n\nfunction getChildrenObjects(node, options) {\n  assertTweakedObject(node, \"node\");\n\n  if (!options || !options.deep) {\n    return getObjectChildren(node);\n  } else {\n    return getDeepObjectChildren(node).deep;\n  }\n}\n\n/**\r\n * Runs a callback everytime a new object is attached to a given node.\r\n * The callback can optionally return a disposer which will be run when the child is detached.\r\n *\r\n * The optional options parameter accepts and object with the following options:\r\n * - `deep: boolean` (default: `false`) - true if the callback should be run for all children deeply\r\n * or false if it it should only run for shallow children.\r\n * - `fireForCurrentChildren: boolean` (default: `true`) - true if the callback should be immediately\r\n * called for currently attached children, false if only for future attachments.\r\n *\r\n * Returns a disposer, which has a boolean parameter which should be true if pending detachment\r\n * callbacks should be run or false otherwise.\r\n *\r\n * @param target Function that returns the object whose children should be tracked.\r\n * @param fn Callback called when a child is attached to the target object.\r\n * @param [options]\r\n * @returns\r\n */\n\nfunction onChildAttachedTo(target, fn, options) {\n  assertIsFunction(target, \"target\");\n  assertIsFunction(fn, \"fn\");\n\n  var opts = _extends({\n    deep: false,\n    runForCurrentChildren: true\n  }, options);\n\n  var detachDisposers = new WeakMap();\n\n  var runDetachDisposer = function runDetachDisposer(n) {\n    var detachDisposer = detachDisposers.get(n);\n\n    if (detachDisposer) {\n      detachDisposers[\"delete\"](n);\n      detachDisposer();\n    }\n  };\n\n  var addDetachDisposer = function addDetachDisposer(n, disposer) {\n    if (disposer) {\n      detachDisposers.set(n, disposer);\n    }\n  };\n\n  var getChildrenObjectOpts = {\n    deep: opts.deep\n  };\n\n  var getCurrentChildren = function getCurrentChildren() {\n    var t = target();\n    assertTweakedObject(t, \"target()\");\n    var children = getChildrenObjects(t, getChildrenObjectOpts);\n    var set = new Set();\n    var iter = children.values();\n    var cur = iter.next();\n\n    while (!cur.done) {\n      set.add(cur.value);\n      cur = iter.next();\n    }\n\n    return set;\n  };\n\n  var currentChildren = opts.runForCurrentChildren ? new Set() : getCurrentChildren();\n  var disposer = reaction(function () {\n    return getCurrentChildren();\n  }, function (newChildren) {\n    var disposersToRun = []; // find dead\n\n    var currentChildrenIter = currentChildren.values();\n    var currentChildrenCur = currentChildrenIter.next();\n\n    while (!currentChildrenCur.done) {\n      var n = currentChildrenCur.value;\n\n      if (!newChildren.has(n)) {\n        currentChildren[\"delete\"](n); // we should run it in inverse order\n\n        disposersToRun.push(n);\n      }\n\n      currentChildrenCur = currentChildrenIter.next();\n    }\n\n    if (disposersToRun.length > 0) {\n      for (var i = disposersToRun.length - 1; i >= 0; i--) {\n        runDetachDisposer(disposersToRun[i]);\n      }\n    } // find new\n\n\n    var newChildrenIter = newChildren.values();\n    var newChildrenCur = newChildrenIter.next();\n\n    while (!newChildrenCur.done) {\n      var _n = newChildrenCur.value;\n\n      if (!currentChildren.has(_n)) {\n        currentChildren.add(_n);\n        addDetachDisposer(_n, fn(_n));\n      }\n\n      newChildrenCur = newChildrenIter.next();\n    }\n  }, {\n    fireImmediately: true\n  });\n  return function (runDetachDisposers) {\n    disposer();\n\n    if (runDetachDisposers) {\n      var currentChildrenIter = currentChildren.values();\n      var currentChildrenCur = currentChildrenIter.next();\n\n      while (!currentChildrenCur.done) {\n        var n = currentChildrenCur.value;\n        runDetachDisposer(n);\n        currentChildrenCur = currentChildrenIter.next();\n      }\n    }\n\n    currentChildren.clear();\n  };\n}\n\n/**\r\n * Deserializers a data structure from its snapshot form.\r\n *\r\n * @typeparam T Object type.\r\n * @param snapshot Snapshot, even if a primitive.\r\n * @param [options] Options.\r\n * @returns The deserialized object.\r\n */\n\nvar fromSnapshot = function fromSnapshot(snapshot, options) {\n  var opts = _extends({\n    generateNewIds: false,\n    overrideRootModelId: undefined\n  }, options);\n\n  var ctx = {\n    options: opts\n  };\n  ctx.snapshotToInitialData = snapshotToInitialData.bind(undefined, ctx);\n  return internalFromSnapshot(snapshot, ctx);\n};\nfromSnapshot = /*#__PURE__*/action(\"fromSnapshot\", fromSnapshot);\n\nfunction internalFromSnapshot(sn, ctx) {\n  if (isPrimitive(sn)) {\n    return sn;\n  }\n\n  if (isMap(sn)) {\n    throw failure(\"a snapshot must not contain maps\");\n  }\n\n  if (isSet(sn)) {\n    throw failure(\"a snapshot must not contain sets\");\n  }\n\n  if (isArray(sn)) {\n    return fromArraySnapshot(sn, ctx);\n  }\n\n  if (isFrozenSnapshot(sn)) {\n    return frozen(sn.data);\n  }\n\n  if (isModelSnapshot(sn)) {\n    return fromModelSnapshot(sn, ctx);\n  }\n\n  if (isPlainObject(sn)) {\n    return fromPlainObjectSnapshot(sn, ctx);\n  }\n\n  throw failure(\"unsupported snapshot - \" + sn);\n}\n\nfunction fromArraySnapshot(sn, ctx) {\n  var arr = observable.array([], observableOptions);\n  var ln = sn.length;\n\n  for (var i = 0; i < ln; i++) {\n    arr.push(internalFromSnapshot(sn[i], ctx));\n  }\n\n  return tweakArray(arr, undefined, true);\n}\n\nfunction fromModelSnapshot(sn, ctx) {\n  var type = sn[modelTypeKey];\n\n  if (!type) {\n    throw failure(\"a model snapshot must contain a type key (\" + modelTypeKey + \"), but none was found\");\n  }\n\n  var modelInfo = getModelInfoForName(type);\n\n  if (!modelInfo) {\n    throw failure(\"model with name \\\"\" + type + \"\\\" not found in the registry\");\n  }\n\n  if (!sn[modelIdKey]) {\n    throw failure(\"a model snapshot must contain an id key (\" + modelIdKey + \"), but none was found\");\n  }\n\n  return new modelInfo[\"class\"](undefined, {\n    snapshotInitialData: {\n      unprocessedSnapshot: sn,\n      snapshotToInitialData: ctx.snapshotToInitialData\n    },\n    generateNewIds: ctx.options.generateNewIds\n  });\n}\n\nfunction snapshotToInitialData(ctx, processedSn) {\n  var initialData = observable.object({}, undefined, observableOptions);\n  var processedSnKeys = Object.keys(processedSn);\n  var processedSnKeysLen = processedSnKeys.length;\n\n  for (var i = 0; i < processedSnKeysLen; i++) {\n    var k = processedSnKeys[i];\n\n    if (!isReservedModelKey(k)) {\n      var v = processedSn[k];\n      set(initialData, k, internalFromSnapshot(v, ctx));\n    }\n  }\n\n  return initialData;\n}\n\nfunction fromPlainObjectSnapshot(sn, ctx) {\n  var plainObj = observable.object({}, undefined, observableOptions);\n  var snKeys = Object.keys(sn);\n  var snKeysLen = snKeys.length;\n\n  for (var i = 0; i < snKeysLen; i++) {\n    var k = snKeys[i];\n    var v = sn[k];\n    set(plainObj, k, internalFromSnapshot(v, ctx));\n  }\n\n  return tweakPlainObject(plainObj, undefined, undefined, true, false);\n}\n\nvar observableOptions = {\n  deep: false\n};\n\n/**\r\n * @ignore\r\n */\n\nfunction reconcileSnapshot(value, sn, modelPool) {\n  if (isPrimitive(sn)) {\n    return sn;\n  }\n\n  if (isArray(sn)) {\n    return reconcileArraySnapshot(value, sn, modelPool);\n  }\n\n  if (isFrozenSnapshot(sn)) {\n    return reconcileFrozenSnapshot(value, sn);\n  }\n\n  if (isModelSnapshot(sn)) {\n    return reconcileModelSnapshot(value, sn, modelPool);\n  }\n\n  if (isPlainObject(sn)) {\n    return reconcilePlainObjectSnapshot(value, sn, modelPool);\n  }\n\n  if (isMap(sn)) {\n    throw failure(\"a snapshot must not contain maps\");\n  }\n\n  if (isSet(sn)) {\n    throw failure(\"a snapshot must not contain sets\");\n  }\n\n  throw failure(\"unsupported snapshot - \" + sn);\n}\n\nfunction reconcileArraySnapshot(value, sn, modelPool) {\n  if (!isArray(value)) {\n    // no reconciliation possible\n    return fromSnapshot(sn);\n  } // remove excess items\n\n\n  if (value.length > sn.length) {\n    value.splice(sn.length, value.length - sn.length);\n  } // reconcile present items\n\n\n  for (var i = 0; i < value.length; i++) {\n    var oldValue = value[i];\n    var newValue = reconcileSnapshot(oldValue, sn[i], modelPool);\n    detachIfNeeded(newValue, oldValue, modelPool);\n    set(value, i, newValue);\n  } // add excess items\n\n\n  for (var _i = value.length; _i < sn.length; _i++) {\n    value.push(reconcileSnapshot(undefined, sn[_i], modelPool));\n  }\n\n  return value;\n}\n\nfunction reconcileFrozenSnapshot(value, sn) {\n  // reconciliation is only possible if the target is a Frozen instance with the same data (by ref)\n  // in theory we could compare the JSON representation of both datas or do a deep comparison, but that'd be too slow\n  if (value instanceof Frozen && value.data === sn.data) {\n    return value;\n  }\n\n  return frozen(sn.data);\n}\n\nfunction reconcileModelSnapshot(value, sn, modelPool) {\n  var type = sn[modelTypeKey];\n  var modelInfo = getModelInfoForName(type);\n\n  if (!modelInfo) {\n    throw failure(\"model with name \\\"\" + type + \"\\\" not found in the registry\");\n  }\n\n  var id = sn[modelIdKey]; // try to use model from pool if possible\n\n  var modelInPool = modelPool.findModelForSnapshot(sn);\n\n  if (modelInPool) {\n    value = modelInPool;\n  }\n\n  if (!(value instanceof modelInfo[\"class\"]) || value[modelTypeKey] !== type || value[modelIdKey] !== id) {\n    // different kind of model / model instance, no reconciliation possible\n    return fromSnapshot(sn);\n  }\n\n  var modelObj = value;\n  var processedSn = sn;\n\n  if (modelObj.fromSnapshot) {\n    processedSn = modelObj.fromSnapshot(sn);\n  }\n\n  var data = modelObj.$; // remove excess props\n\n  var dataKeys = Object.keys(data);\n  var dataKeysLen = dataKeys.length;\n\n  for (var i = 0; i < dataKeysLen; i++) {\n    var k = dataKeys[i];\n\n    if (!(k in processedSn)) {\n      remove(data, k);\n    }\n  } // reconcile the rest\n\n\n  var processedSnKeys = Object.keys(processedSn);\n  var processedSnKeysLen = processedSnKeys.length;\n\n  for (var _i2 = 0; _i2 < processedSnKeysLen; _i2++) {\n    var _k = processedSnKeys[_i2];\n\n    if (!isReservedModelKey(_k)) {\n      var v = processedSn[_k];\n      var oldValue = data[_k];\n      var newValue = reconcileSnapshot(oldValue, v, modelPool);\n      detachIfNeeded(newValue, oldValue, modelPool);\n      set(data, _k, newValue);\n    }\n  }\n\n  return modelObj;\n}\n\nfunction reconcilePlainObjectSnapshot(value, sn, modelPool) {\n  // plain obj\n  if (!isPlainObject(value) && !isObservableObject(value)) {\n    // no reconciliation possible\n    return fromSnapshot(sn);\n  }\n\n  var plainObj = value; // remove excess props\n\n  var plainObjKeys = Object.keys(plainObj);\n  var plainObjKeysLen = plainObjKeys.length;\n\n  for (var i = 0; i < plainObjKeysLen; i++) {\n    var k = plainObjKeys[i];\n\n    if (!(k in sn)) {\n      remove(plainObj, k);\n    }\n  } // reconcile the rest\n\n\n  var snKeys = Object.keys(sn);\n  var snKeysLen = snKeys.length;\n\n  for (var _i3 = 0; _i3 < snKeysLen; _i3++) {\n    var _k2 = snKeys[_i3];\n    var v = sn[_k2];\n    var oldValue = plainObj[_k2];\n    var newValue = reconcileSnapshot(oldValue, v, modelPool);\n    detachIfNeeded(newValue, oldValue, modelPool);\n    set(plainObj, _k2, newValue);\n  }\n\n  return plainObj;\n}\n\nfunction detachIfNeeded(newValue, oldValue, modelPool) {\n  // edge case for when we are swapping models around the tree\n  if (newValue === oldValue) {\n    // already where it should be\n    return;\n  }\n\n  if (isModel(newValue) && modelPool.findModelByTypeAndId(newValue[modelTypeKey], newValue[modelIdKey])) {\n    var parentPath = fastGetParentPathIncludingDataObjects(newValue);\n\n    if (parentPath) {\n      set(parentPath.parent, parentPath.path, null);\n    }\n  }\n}\n\nvar ModelPool = /*#__PURE__*/function () {\n  function ModelPool(root) {\n    var _dataObjectParent$get;\n\n    this.pool = void 0;\n    // make sure we don't use the sub-data $ object\n    root = (_dataObjectParent$get = dataObjectParent.get(root)) != null ? _dataObjectParent$get : root;\n    this.pool = getDeepObjectChildren(root).deepByModelTypeAndId;\n  }\n\n  var _proto = ModelPool.prototype;\n\n  _proto.findModelByTypeAndId = function findModelByTypeAndId(modelType, modelId) {\n    return this.pool.get(byModelTypeAndIdKey(modelType, modelId));\n  };\n\n  _proto.findModelForSnapshot = function findModelForSnapshot(sn) {\n    if (!isModelSnapshot(sn)) {\n      return undefined;\n    }\n\n    return this.findModelByTypeAndId(sn[modelTypeKey], sn[modelIdKey]);\n  };\n\n  return ModelPool;\n}();\n\n/**\r\n * Applies the given patches to the given target object.\r\n *\r\n * @param node Target object.\r\n * @param patches List of patches to apply.\r\n * @param reverse Whether patches are applied in reverse order.\r\n */\n\nfunction applyPatches(node, patches, reverse) {\n  if (reverse === void 0) {\n    reverse = false;\n  }\n\n  assertTweakedObject(node, \"node\");\n\n  if (patches.length <= 0) {\n    return;\n  }\n\n  wrappedInternalApplyPatches().call(node, patches, reverse);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction internalApplyPatches(patches, reverse) {\n  if (reverse === void 0) {\n    reverse = false;\n  }\n\n  var obj = this;\n  var modelPool = new ModelPool(obj);\n\n  if (reverse) {\n    var i = patches.length;\n\n    while (i--) {\n      var p = patches[i];\n\n      if (!isArray(p)) {\n        applySinglePatch(obj, p, modelPool);\n      } else {\n        var j = p.length;\n\n        while (j--) {\n          applySinglePatch(obj, p[j], modelPool);\n        }\n      }\n    }\n  } else {\n    var len = patches.length;\n\n    for (var _i = 0; _i < len; _i++) {\n      var _p = patches[_i];\n\n      if (!isArray(_p)) {\n        applySinglePatch(obj, _p, modelPool);\n      } else {\n        var len2 = _p.length;\n\n        for (var _j = 0; _j < len2; _j++) {\n          applySinglePatch(obj, _p[_j], modelPool);\n        }\n      }\n    }\n  }\n}\nvar wrappedInternalApplyPatches = /*#__PURE__*/lazy(function () {\n  return wrapInAction({\n    name: BuiltInAction.ApplyPatches,\n    fn: internalApplyPatches,\n    actionType: ActionContextActionType.Sync\n  });\n});\n\nfunction applySinglePatch(obj, patch, modelPool) {\n  var _pathArrayToObjectAnd = pathArrayToObjectAndProp(obj, patch.path),\n      target = _pathArrayToObjectAnd.target,\n      prop = _pathArrayToObjectAnd.prop;\n\n  if (isArray(target)) {\n    switch (patch.op) {\n      case \"add\":\n        {\n          var index = +prop; // reconcile from the pool if possible\n\n          var newValue = reconcileSnapshot(undefined, patch.value, modelPool);\n          target.splice(index, 0, newValue);\n          break;\n        }\n\n      case \"remove\":\n        {\n          var _index = +prop; // no reconciliation, removing\n\n\n          target.splice(_index, 1);\n          break;\n        }\n\n      case \"replace\":\n        {\n          if (prop === \"length\") {\n            target.length = patch.value;\n          } else {\n            var _index2 = +prop; // try to reconcile\n\n\n            var _newValue = reconcileSnapshot(target[_index2], patch.value, modelPool);\n\n            set(target, _index2, _newValue);\n          }\n\n          break;\n        }\n\n      default:\n        throw failure(\"unsupported patch operation: \" + patch.op);\n    }\n  } else {\n    switch (patch.op) {\n      case \"add\":\n        {\n          // reconcile from the pool if possible\n          var _newValue2 = reconcileSnapshot(undefined, patch.value, modelPool);\n\n          set(target, prop, _newValue2);\n          break;\n        }\n\n      case \"remove\":\n        {\n          // no reconciliation, removing\n          remove(target, prop);\n          break;\n        }\n\n      case \"replace\":\n        {\n          // try to reconcile\n          // we don't need to tweak the pool since reconcileSnapshot will do that for us\n          var _newValue3 = reconcileSnapshot(target[prop], patch.value, modelPool);\n\n          set(target, prop, _newValue3);\n          break;\n        }\n\n      default:\n        throw failure(\"unsupported patch operation: \" + patch.op);\n    }\n  }\n}\n\nfunction pathArrayToObjectAndProp(obj, path) {\n  if (inDevMode()) {\n    if (!isArray(path)) {\n      throw failure(\"invalid path: \" + path);\n    }\n  }\n\n  var target = modelToDataNode(obj);\n\n  if (path.length === 0) {\n    return {\n      target: target\n    };\n  }\n\n  for (var i = 0; i <= path.length - 2; i++) {\n    target = modelToDataNode(target[path[i]]);\n  }\n\n  return {\n    target: target,\n    prop: path[path.length - 1]\n  };\n}\n\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction runTypeCheckingAfterChange(obj, patchRecorder) {\n  // invalidate type check cached result\n  invalidateCachedTypeCheckerResult(obj);\n\n  if (isModelAutoTypeCheckingEnabled()) {\n    var parentModelWithTypeChecker = findNearestParentModelWithTypeChecker(obj);\n\n    if (parentModelWithTypeChecker) {\n      var err = parentModelWithTypeChecker.typeCheck();\n\n      if (err) {\n        // quietly apply inverse patches (do not generate patches, snapshots, actions, etc)\n        runWithoutSnapshotOrPatches(function () {\n          internalApplyPatches.call(obj, patchRecorder.invPatches, true);\n        }); // at the end of apply patches it will be type checked again and its result cached once more\n\n        err[\"throw\"](parentModelWithTypeChecker);\n      }\n    }\n  }\n}\n/**\r\n * @ignore\r\n *\r\n * Finds the closest parent model that has a type checker defined.\r\n *\r\n * @param child\r\n * @returns\r\n */\n\nfunction findNearestParentModelWithTypeChecker(child) {\n  // child might be .$, so we need to check the parent model in that case\n  var actualChild = dataToModelNode(child);\n\n  if (child !== actualChild) {\n    child = actualChild;\n\n    if (isModel(child) && !!getModelDataType(child)) {\n      return child;\n    }\n  }\n\n  return findParent(child, function (parent) {\n    return isModel(parent) && !!getModelDataType(parent);\n  });\n}\n\n/**\r\n * @ignore\r\n */\n\nfunction tweakArray(value, parentPath, doNotTweakChildren) {\n  var originalArr = value;\n  var arrLn = originalArr.length;\n  var tweakedArr = isObservableArray(originalArr) ? originalArr : observable.array([], observableOptions$1);\n\n  if (tweakedArr !== originalArr) {\n    tweakedArr.length = originalArr.length;\n  }\n\n  var interceptDisposer;\n  var observeDisposer;\n\n  var untweak = function untweak() {\n    interceptDisposer();\n    observeDisposer();\n  };\n\n  tweakedObjects.set(tweakedArr, untweak);\n  setParent(tweakedArr, parentPath, false, false);\n  var standardSn = [];\n  standardSn.length = arrLn; // substitute initial values by proxied values\n\n  for (var i = 0; i < arrLn; i++) {\n    var v = originalArr[i];\n\n    if (isPrimitive(v)) {\n      if (!doNotTweakChildren) {\n        set(tweakedArr, i, v);\n      }\n\n      standardSn[i] = v;\n    } else {\n      var path = {\n        parent: tweakedArr,\n        path: i\n      };\n      var tweakedValue = void 0;\n\n      if (doNotTweakChildren) {\n        tweakedValue = v;\n        setParent(tweakedValue, path, false, false);\n      } else {\n        tweakedValue = tweak(v, path);\n        set(tweakedArr, i, tweakedValue);\n      }\n\n      var valueSn = getInternalSnapshot(tweakedValue);\n      standardSn[i] = valueSn.standard;\n    }\n  }\n\n  setInternalSnapshot(tweakedArr, standardSn);\n  interceptDisposer = intercept(tweakedArr, interceptArrayMutation.bind(undefined, tweakedArr));\n  observeDisposer = observe(tweakedArr, arrayDidChange);\n  return tweakedArr;\n}\n\nfunction arrayDidChange(change\n/*IArrayDidChange*/\n) {\n  var arr = change.object;\n\n  var _getInternalSnapshot = getInternalSnapshot(arr),\n      oldSnapshot = _getInternalSnapshot.standard;\n\n  var patchRecorder = new InternalPatchRecorder();\n  var newSnapshot = oldSnapshot.slice();\n\n  switch (change.type) {\n    case \"splice\":\n      {\n        var index = change.index;\n        var addedCount = change.addedCount;\n        var removedCount = change.removedCount;\n        var addedItems = [];\n        addedItems.length = addedCount;\n\n        for (var i = 0; i < addedCount; i++) {\n          var v = change.added[i];\n\n          if (isPrimitive(v)) {\n            addedItems[i] = v;\n          } else {\n            addedItems[i] = getInternalSnapshot(v).standard;\n          }\n        }\n\n        var oldLen = oldSnapshot.length;\n        newSnapshot.splice.apply(newSnapshot, [index, removedCount].concat(addedItems));\n        var patches = [];\n        var invPatches = []; // optimization: if we add as many as we remove then replace instead\n\n        if (addedCount === removedCount) {\n          for (var _i = 0; _i < addedCount; _i++) {\n            var realIndex = index + _i;\n            var newVal = newSnapshot[realIndex];\n            var oldVal = oldSnapshot[realIndex];\n\n            if (newVal !== oldVal) {\n              var path = [realIndex]; // replace 0, 1, 2...\n\n              patches.push({\n                op: \"replace\",\n                path: path,\n                value: newVal\n              }); // replace ...2, 1, 0 since inverse patches are applied in reverse\n\n              invPatches.push({\n                op: \"replace\",\n                path: path,\n                value: oldVal\n              });\n            }\n          }\n        } else {\n          var interimLen = oldLen - removedCount; // first remove items\n\n          if (removedCount > 0) {\n            // optimization, when removing from the end set the length instead\n            var removeUsingSetLength = index >= interimLen;\n\n            if (removeUsingSetLength) {\n              patches.push({\n                op: \"replace\",\n                path: [\"length\"],\n                value: interimLen\n              });\n            }\n\n            for (var _i2 = removedCount - 1; _i2 >= 0; _i2--) {\n              var _realIndex = index + _i2;\n\n              var _path = [_realIndex];\n\n              if (!removeUsingSetLength) {\n                // remove ...2, 1, 0\n                patches.push({\n                  op: \"remove\",\n                  path: _path\n                });\n              } // add 0, 1, 2... since inverse patches are applied in reverse\n\n\n              invPatches.push({\n                op: \"add\",\n                path: _path,\n                value: oldSnapshot[_realIndex]\n              });\n            }\n          } // then add items\n\n\n          if (addedCount > 0) {\n            // optimization, for inverse patches, when adding from the end set the length to restore instead\n            var restoreUsingSetLength = index >= interimLen;\n\n            if (restoreUsingSetLength) {\n              invPatches.push({\n                op: \"replace\",\n                path: [\"length\"],\n                value: interimLen\n              });\n            }\n\n            for (var _i3 = 0; _i3 < addedCount; _i3++) {\n              var _realIndex2 = index + _i3;\n\n              var _path2 = [_realIndex2]; // add 0, 1, 2...\n\n              patches.push({\n                op: \"add\",\n                path: _path2,\n                value: newSnapshot[_realIndex2]\n              }); // remove ...2, 1, 0 since inverse patches are applied in reverse\n\n              if (!restoreUsingSetLength) {\n                invPatches.push({\n                  op: \"remove\",\n                  path: _path2\n                });\n              }\n            }\n          }\n        }\n\n        patchRecorder.record(patches, invPatches);\n      }\n      break;\n\n    case \"update\":\n      {\n        var k = change.index;\n        var val = change.newValue;\n        var _oldVal = newSnapshot[k];\n\n        if (isPrimitive(val)) {\n          newSnapshot[k] = val;\n        } else {\n          var valueSn = getInternalSnapshot(val);\n          newSnapshot[k] = valueSn.standard;\n        }\n\n        var _path3 = [k];\n        patchRecorder.record([{\n          op: \"replace\",\n          path: _path3,\n          value: newSnapshot[k]\n        }], [{\n          op: \"replace\",\n          path: _path3,\n          value: _oldVal\n        }]);\n      }\n      break;\n  }\n\n  runTypeCheckingAfterChange(arr, patchRecorder);\n\n  if (!runningWithoutSnapshotOrPatches) {\n    setInternalSnapshot(arr, newSnapshot);\n    patchRecorder.emit(arr);\n  }\n}\n\nvar undefinedInsideArrayErrorMsg = \"undefined is not supported inside arrays since it is not serializable in JSON, consider using null instead\"; // TODO: remove array parameter and just use change.object once mobx update event is fixed\n\nfunction interceptArrayMutation(array, change) {\n  assertCanWrite();\n\n  switch (change.type) {\n    case \"splice\":\n      {\n        if (inDevMode() && !getGlobalConfig().allowUndefinedArrayElements) {\n          var len = change.added.length;\n\n          for (var i = 0; i < len; i++) {\n            var v = change.added[i];\n\n            if (v === undefined) {\n              throw failure(undefinedInsideArrayErrorMsg);\n            }\n          }\n        }\n\n        for (var _i4 = 0; _i4 < change.removedCount; _i4++) {\n          var removedValue = change.object[change.index + _i4];\n          tweak(removedValue, undefined);\n          tryUntweak(removedValue);\n        }\n\n        for (var _i5 = 0; _i5 < change.added.length; _i5++) {\n          change.added[_i5] = tweak(change.added[_i5], {\n            parent: change.object,\n            path: change.index + _i5\n          });\n        } // we might also need to update the parent of the next indexes\n\n\n        var oldNextIndex = change.index + change.removedCount;\n        var newNextIndex = change.index + change.added.length;\n\n        if (oldNextIndex !== newNextIndex) {\n          for (var _i6 = oldNextIndex, j = newNextIndex; _i6 < change.object.length; _i6++, j++) {\n            setParent(change.object[_i6], {\n              parent: change.object,\n              path: j\n            }, true, false);\n          }\n        }\n      }\n      break;\n\n    case \"update\":\n      if (inDevMode() && !getGlobalConfig().allowUndefinedArrayElements && change.newValue === undefined) {\n        throw failure(undefinedInsideArrayErrorMsg);\n      } // TODO: should be change.object, but mobx is bugged and doesn't send the proxy\n\n\n      var oldVal = array[change.index];\n      tweak(oldVal, undefined); // set old prop obj parent to undefined\n\n      tryUntweak(oldVal);\n      change.newValue = tweak(change.newValue, {\n        parent: array,\n        path: change.index\n      });\n      break;\n  }\n\n  return change;\n}\n\nvar observableOptions$1 = {\n  deep: false\n};\n\n/**\r\n * @ingore\r\n */\n\nfunction tweakFrozen(frozenObj, parentPath) {\n  var _setInternalSnapshot;\n\n  tweakedObjects.set(frozenObj, undefined);\n  setParent(frozenObj, parentPath, false, false); // we DON'T want data proxified, but the snapshot is the data itself\n\n  setInternalSnapshot(frozenObj, (_setInternalSnapshot = {}, _setInternalSnapshot[frozenKey] = true, _setInternalSnapshot.data = frozenObj.data, _setInternalSnapshot));\n  return frozenObj;\n}\n\n/**\r\n * Turns an object (array, plain object) into a tree node,\r\n * which then can accept calls to `getParent`, `getSnapshot`, etc.\r\n * If a tree node is passed it will return the passed argument directly.\r\n *\r\n * @param value Object to turn into a tree node.\r\n * @returns The object as a tree node.\r\n */\n\nfunction toTreeNode(value) {\n  if (!isObject(value)) {\n    throw failure(\"only objects can be turned into tree nodes\");\n  }\n\n  if (!isTweakedObject(value, true)) {\n    return tweak(value, undefined);\n  }\n\n  return value;\n}\n/**\r\n * @ignore\r\n */\n\nfunction internalTweak(value, parentPath) {\n  if (isPrimitive(value)) {\n    return value;\n  }\n\n  if (isTweakedObject(value, true)) {\n    setParent(value, parentPath, false, false);\n    return value;\n  }\n\n  if (isModel(value)) {\n    return tweakModel(value, parentPath);\n  }\n\n  if (isArray(value)) {\n    return tweakArray(value, parentPath, false);\n  } // plain object\n\n\n  if (isObservableObject(value) || isPlainObject(value)) {\n    return tweakPlainObject(value, parentPath, undefined, false, false);\n  }\n\n  if (value instanceof Frozen) {\n    return tweakFrozen(value, parentPath);\n  } // unsupported\n\n\n  if (isMap(value)) {\n    throw failure(\"maps are not directly supported. consider applying 'transformObjectAsMap' over a '{[k: string]: V}' property, or 'transformArrayAsMap' over a '[string, V][]' property instead.\");\n  } // unsupported\n\n\n  if (isSet(value)) {\n    throw failure(\"sets are not directly supported. consider applying 'transformArrayAsSet' over a 'V[]' property instead.\");\n  }\n\n  throw failure(\"tweak can only work over models, observable objects/arrays, or primitives, but got \" + value + \" instead\");\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\n\nvar tweak = /*#__PURE__*/action(\"tweak\", internalTweak);\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction tryUntweak(value) {\n  if (isPrimitive(value)) {\n    return true;\n  }\n\n  if (inDevMode()) {\n    if (fastGetParent(value)) {\n      throw failure(\"assertion error: object cannot be untweaked while it has a parent\");\n    }\n  }\n\n  var untweaker = tweakedObjects.get(value);\n\n  if (!untweaker) {\n    return false;\n  } // we have to make a copy since it will be changed\n  // we have to iterate ourselves since it seems like babel does not do downlevel iteration\n\n\n  var children = [];\n  var childrenIter = getObjectChildren(value).values();\n  var childrenCur = childrenIter.next();\n\n  while (!childrenCur.done) {\n    children.push(childrenCur.value);\n    childrenCur = childrenIter.next();\n  }\n\n  for (var i = 0; i < children.length; i++) {\n    var v = children[i];\n    setParent(v, undefined, false, false);\n  }\n\n  untweaker();\n  tweakedObjects[\"delete\"](value);\n  unsetInternalSnapshot(value);\n  return true;\n}\n\n/**\r\n * @ignore\r\n */\n\nfunction tweakPlainObject(value, parentPath, snapshotModelType, doNotTweakChildren, isDataObject) {\n  var originalObj = value;\n  var tweakedObj = isObservableObject(originalObj) ? originalObj : observable.object({}, undefined, observableOptions$2);\n  var interceptDisposer;\n  var observeDisposer;\n\n  var untweak = function untweak() {\n    interceptDisposer();\n    observeDisposer();\n  };\n\n  tweakedObjects.set(tweakedObj, untweak);\n  setParent(tweakedObj, parentPath, false, isDataObject);\n  var standardSn = {}; // substitute initial values by tweaked values\n\n  var originalObjKeys = Object.keys(originalObj);\n  var originalObjKeysLen = originalObjKeys.length;\n\n  for (var i = 0; i < originalObjKeysLen; i++) {\n    var k = originalObjKeys[i];\n    var v = originalObj[k];\n\n    if (isPrimitive(v)) {\n      if (!doNotTweakChildren) {\n        set(tweakedObj, k, v);\n      }\n\n      standardSn[k] = v;\n    } else {\n      var path = {\n        parent: tweakedObj,\n        path: k\n      };\n      var tweakedValue = void 0;\n\n      if (doNotTweakChildren) {\n        tweakedValue = v;\n        setParent(tweakedValue, path, false, false);\n      } else {\n        tweakedValue = tweak(v, path);\n        set(tweakedObj, k, tweakedValue);\n      }\n\n      var valueSn = getInternalSnapshot(tweakedValue);\n      standardSn[k] = valueSn.standard;\n    }\n  }\n\n  if (snapshotModelType) {\n    standardSn[modelTypeKey] = snapshotModelType;\n  }\n\n  setInternalSnapshot(isDataObject ? dataToModelNode(tweakedObj) : tweakedObj, standardSn);\n  interceptDisposer = intercept(tweakedObj, interceptObjectMutation);\n  observeDisposer = observe(tweakedObj, objectDidChange);\n  return tweakedObj;\n}\nvar observableOptions$2 = {\n  deep: false\n};\n\nfunction objectDidChange(change) {\n  var obj = change.object;\n  var actualNode = dataToModelNode(obj);\n\n  var _getInternalSnapshot = getInternalSnapshot(actualNode),\n      standardSn = _getInternalSnapshot.standard;\n\n  var patchRecorder = new InternalPatchRecorder();\n  standardSn = Object.assign({}, standardSn);\n\n  switch (change.type) {\n    case \"add\":\n    case \"update\":\n      {\n        var k = change.name;\n        var val = change.newValue;\n        var oldVal = standardSn[k];\n\n        if (isPrimitive(val)) {\n          standardSn[k] = val;\n        } else {\n          var valueSn = getInternalSnapshot(val);\n          standardSn[k] = valueSn.standard;\n        }\n\n        var path = [k];\n\n        if (change.type === \"add\") {\n          patchRecorder.record([{\n            op: \"add\",\n            path: path,\n            value: standardSn[k]\n          }], [{\n            op: \"remove\",\n            path: path\n          }]);\n        } else {\n          patchRecorder.record([{\n            op: \"replace\",\n            path: path,\n            value: standardSn[k]\n          }], [{\n            op: \"replace\",\n            path: path,\n            value: oldVal\n          }]);\n        }\n      }\n      break;\n\n    case \"remove\":\n      {\n        var _k = change.name;\n        var _oldVal = standardSn[_k];\n        delete standardSn[_k];\n        var _path = [_k];\n        patchRecorder.record([{\n          op: \"remove\",\n          path: _path\n        }], [{\n          op: \"add\",\n          path: _path,\n          value: _oldVal\n        }]);\n      }\n      break;\n  }\n\n  runTypeCheckingAfterChange(obj, patchRecorder);\n\n  if (!runningWithoutSnapshotOrPatches) {\n    setInternalSnapshot(actualNode, standardSn);\n    patchRecorder.emit(actualNode);\n  }\n}\n\nfunction interceptObjectMutation(change) {\n  assertCanWrite();\n\n  if (typeof change.name === \"symbol\") {\n    throw failure(\"symbol properties are not supported\");\n  }\n\n  switch (change.type) {\n    case \"add\":\n      change.newValue = tweak(change.newValue, {\n        parent: change.object,\n        path: \"\" + change.name\n      });\n      break;\n\n    case \"remove\":\n      {\n        var oldVal = change.object[change.name];\n        tweak(oldVal, undefined);\n        tryUntweak(oldVal);\n        break;\n      }\n\n    case \"update\":\n      {\n        var _oldVal2 = change.object[change.name];\n        tweak(_oldVal2, undefined);\n        tryUntweak(_oldVal2);\n        change.newValue = tweak(change.newValue, {\n          parent: change.object,\n          path: \"\" + change.name\n        });\n        break;\n      }\n  }\n\n  return change;\n}\n\n/**\r\n * @internal\r\n * @ignore\r\n */\nvar modelInitializersSymbol = /*#__PURE__*/Symbol(\"modelInitializers\");\n/**\r\n * @internal\r\n * @ignore\r\n */\n\nfunction addModelClassInitializer(modelClass, init) {\n  var initializers = modelClass[modelInitializersSymbol];\n\n  if (!initializers) {\n    initializers = [];\n    modelClass[modelInitializersSymbol] = initializers;\n  }\n\n  initializers.push(init);\n}\n/**\r\n * @internal\r\n * @ignore\r\n */\n\nfunction getModelClassInitializers(modelClass) {\n  return modelClass[modelInitializersSymbol];\n}\n\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nvar internalNewModel = /*#__PURE__*/action(\"newModel\", function (origModelObj, initialData, options) {\n  var _modelClass = options.modelClass,\n      snapshotInitialData = options.snapshotInitialData,\n      generateNewIds = options.generateNewIds;\n  var modelClass = _modelClass;\n\n  if (inDevMode()) {\n    assertIsModelClass(modelClass, \"modelClass\");\n  }\n\n  var modelObj = origModelObj;\n  var modelInfo = modelInfoByClass.get(modelClass);\n\n  if (!modelInfo) {\n    throw failure(\"no model info for class \" + modelClass.name + \" could be found - did you forget to add the @model decorator?\");\n  }\n\n  var id;\n\n  if (snapshotInitialData) {\n    var sn = snapshotInitialData.unprocessedSnapshot;\n\n    if (generateNewIds) {\n      id = getGlobalConfig().modelIdGenerator();\n    } else {\n      id = sn[modelIdKey];\n    }\n\n    if (modelObj.fromSnapshot) {\n      sn = modelObj.fromSnapshot(sn);\n    }\n\n    initialData = snapshotInitialData.snapshotToInitialData(sn);\n  } else {\n    // use symbol if provided\n    if (initialData[modelIdKey]) {\n      id = initialData[modelIdKey];\n    } else {\n      id = getGlobalConfig().modelIdGenerator();\n    }\n  }\n\n  modelObj[modelTypeKey] = modelInfo.name; // fill in defaults in initial data\n\n  var modelProps = getInternalModelClassPropsInfo(modelClass);\n  var modelPropsKeys = Object.keys(modelProps);\n\n  for (var i = 0; i < modelPropsKeys.length; i++) {\n    var k = modelPropsKeys[i];\n    var v = initialData[k];\n\n    if (v === undefined || v === null) {\n      var newValue = v;\n      var propData = modelProps[k];\n\n      if (propData.defaultFn !== noDefaultValue) {\n        newValue = propData.defaultFn();\n      } else if (propData.defaultValue !== noDefaultValue) {\n        newValue = propData.defaultValue;\n      }\n\n      set(initialData, k, newValue);\n    }\n  }\n\n  set(initialData, modelIdKey, id);\n  tweakModel(modelObj, undefined); // create observable data object with initial data\n\n  var obsData = tweakPlainObject(initialData, {\n    parent: modelObj,\n    path: \"$\"\n  }, modelObj[modelTypeKey], false, true); // link it, and make it readonly\n\n  modelObj.$ = obsData;\n\n  if (inDevMode()) {\n    makePropReadonly(modelObj, \"$\", true);\n  } // type check it if needed\n\n\n  if (isModelAutoTypeCheckingEnabled() && getModelDataType(modelClass)) {\n    var err = modelObj.typeCheck();\n\n    if (err) {\n      err[\"throw\"](modelObj);\n    }\n  } // run any extra initializers for the class as needed\n\n\n  var initializers = getModelClassInitializers(modelClass);\n\n  if (initializers) {\n    var len = initializers.length;\n\n    for (var _i = 0; _i < len; _i++) {\n      var init = initializers[_i];\n      init(modelObj);\n    }\n  }\n\n  return modelObj;\n});\n\n/**\r\n * @ignore\r\n */\n\nvar propsDataTypeSymbol = /*#__PURE__*/Symbol();\n/**\r\n * @ignore\r\n */\n\nvar propsCreationDataTypeSymbol = /*#__PURE__*/Symbol();\n/**\r\n * @ignore\r\n */\n\nvar instanceDataTypeSymbol = /*#__PURE__*/Symbol();\n/**\r\n * @ignore\r\n */\n\nvar instanceCreationDataTypeSymbol = /*#__PURE__*/Symbol();\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nvar modelInitializedSymbol = /*#__PURE__*/Symbol(\"modelInitialized\");\n/**\r\n * Base abstract class for models. Use `Model` instead when extending.\r\n *\r\n * Never override the constructor, use `onInit` or `onAttachedToRootStore` instead.\r\n *\r\n * @typeparam PropsData Props data type.\r\n * @typeparam CreationData Creation data type.\r\n * @typeparam InstanceData Instace data type.\r\n * @typeparam InstanceCreationData Instance creation data type.\r\n */\n\nvar BaseModel = /*#__PURE__*/function () {\n  var _proto = BaseModel.prototype;\n\n  // just to make typing work properly\n\n  /**\r\n   * Model type name.\r\n   */\n\n  /**\r\n   * Model internal id. Can be modified inside a model action.\r\n   */\n\n  /**\r\n   * Can be overriden to offer a reference id to be used in reference resolution.\r\n   * By default it will use `$modelId`.\r\n   */\n  _proto.getRefId = function getRefId() {\n    return this[modelIdKey];\n  }\n  /**\r\n   * Data part of the model, which is observable and will be serialized in snapshots.\r\n   * Use it if one of the data properties matches one of the model properties/functions.\r\n   * This also allows access to the backed values of transformed properties.\r\n   */\n  ;\n\n  /**\r\n   * Performs a type check over the model instance.\r\n   * For this to work a data type has to be declared in the model decorator.\r\n   *\r\n   * @returns A `TypeCheckError` or `null` if there is no error.\r\n   */\n  _proto.typeCheck = function typeCheck$1() {\n    var type = typesModel(this.constructor);\n    return typeCheck(type, this);\n  }\n  /**\r\n   * Creates an instance of Model.\r\n   */\n  ;\n\n  function BaseModel(data) {\n    this[propsDataTypeSymbol] = void 0;\n    this[propsCreationDataTypeSymbol] = void 0;\n    this[instanceDataTypeSymbol] = void 0;\n    this[instanceCreationDataTypeSymbol] = void 0;\n    this[modelTypeKey] = void 0;\n    this[modelIdKey] = void 0;\n    this.$ = void 0;\n    var initialData = data;\n    var _arguments$ = arguments[1],\n        snapshotInitialData = _arguments$.snapshotInitialData,\n        modelClass = _arguments$.modelClass,\n        propsWithTransforms = _arguments$.propsWithTransforms,\n        generateNewIds = _arguments$.generateNewIds;\n    Object.setPrototypeOf(this, modelClass.prototype);\n    var self = this; // let's always use the one from the prototype\n\n    delete self[modelIdKey]; // delete unnecessary props\n\n    delete self[propsDataTypeSymbol];\n    delete self[propsCreationDataTypeSymbol];\n    delete self[instanceDataTypeSymbol];\n    delete self[instanceCreationDataTypeSymbol];\n\n    if (!snapshotInitialData) {\n      // plain new\n      assertIsObject(initialData, \"initialData\"); // apply transforms to initial data if needed\n\n      var propsWithTransformsLen = propsWithTransforms.length;\n\n      if (propsWithTransformsLen > 0) {\n        initialData = Object.assign(initialData);\n\n        for (var i = 0; i < propsWithTransformsLen; i++) {\n          var propWithTransform = propsWithTransforms[i];\n          var propName = propWithTransform[0];\n          var propTransform = propWithTransform[1];\n          var memoTransform = memoTransformCache.getOrCreateMemoTransform(this, propName, propTransform);\n          initialData[propName] = memoTransform.dataToProp(initialData[propName]);\n        }\n      }\n\n      internalNewModel(this, observable.object(initialData, undefined, {\n        deep: false\n      }), {\n        modelClass: modelClass,\n        generateNewIds: true\n      });\n    } else {\n      // from snapshot\n      internalNewModel(this, undefined, {\n        modelClass: modelClass,\n        snapshotInitialData: snapshotInitialData,\n        generateNewIds: generateNewIds\n      });\n    }\n  }\n\n  _proto.toString = function toString(options) {\n    var finalOptions = _extends({\n      withData: true\n    }, options);\n\n    var firstPart = this.constructor.name + \"#\" + this[modelTypeKey];\n    return finalOptions.withData ? \"[\" + firstPart + \" \" + JSON.stringify(getSnapshot(this)) + \"]\" : \"[\" + firstPart + \"]\";\n  };\n\n  return BaseModel;\n}(); // these props will never be hoisted to this (except for model id)\n\n/**\r\n * @internal\r\n */\n\nvar baseModelPropNames = /*#__PURE__*/new Set([modelTypeKey, modelIdKey, \"onInit\", \"$\", \"getRefId\", \"onAttachedToRootStore\", \"fromSnapshot\", \"typeCheck\"]);\n/**\r\n * @deprecated Should not be needed anymore.\r\n *\r\n * Tricks Typescript into accepting abstract classes as a parameter for `ExtendedModel`.\r\n * Does nothing in runtime.\r\n *\r\n * @typeparam T Abstract model class type.\r\n * @param type Abstract model class.\r\n * @returns\r\n */\n\nfunction abstractModelClass(type) {\n  return type;\n}\n/**\r\n * Tricks Typescript into accepting a particular kind of generic class as a parameter for `ExtendedModel`.\r\n * Does nothing in runtime.\r\n *\r\n * @typeparam T Generic model class type.\r\n * @param type Generic model class.\r\n * @returns\r\n */\n\nfunction modelClass(type) {\n  return type;\n}\n/**\r\n * Add missing model metadata to a model creation snapshot to generate a proper model snapshot.\r\n * Usually used alongside `fromSnapshot`.\r\n *\r\n * @typeparam M Model type.\r\n * @param modelClass Model class.\r\n * @param snapshot Model creation snapshot without metadata.\r\n * @param [internalId] Model internal ID, or `undefined` to generate a new one.\r\n * @returns The model snapshot (including metadata).\r\n */\n\nfunction modelSnapshotInWithMetadata(modelClass, snapshot, internalId) {\n  var _extends2;\n\n  if (internalId === void 0) {\n    internalId = getGlobalConfig().modelIdGenerator();\n  }\n\n  assertIsModelClass(modelClass, \"modelClass\");\n  assertIsObject(snapshot, \"initialData\");\n  var modelInfo = modelInfoByClass.get(modelClass);\n  return _extends({}, snapshot, (_extends2 = {}, _extends2[modelTypeKey] = modelInfo.name, _extends2[modelIdKey] = internalId, _extends2));\n}\n/**\r\n * Add missing model metadata to a model output snapshot to generate a proper model snapshot.\r\n * Usually used alongside `applySnapshot`.\r\n *\r\n * @typeparam M Model type.\r\n * @param modelClass Model class.\r\n * @param snapshot Model output snapshot without metadata.\r\n * @param [internalId] Model internal ID, or `undefined` to generate a new one.\r\n * @returns The model snapshot (including metadata).\r\n */\n\nfunction modelSnapshotOutWithMetadata(modelClass, snapshot, internalId) {\n  var _extends3;\n\n  if (internalId === void 0) {\n    internalId = getGlobalConfig().modelIdGenerator();\n  }\n\n  assertIsModelClass(modelClass, \"modelClass\");\n  assertIsObject(snapshot, \"initialData\");\n  var modelInfo = modelInfoByClass.get(modelClass);\n  return _extends({}, snapshot, (_extends3 = {}, _extends3[modelTypeKey] = modelInfo.name, _extends3[modelIdKey] = internalId, _extends3));\n}\n\n/**\r\n * Checks if an object is a model instance.\r\n *\r\n * @param model\r\n * @returns\r\n */\n\nfunction isModel(model) {\n  return model instanceof BaseModel;\n}\n/**\r\n * @ignore\r\n * @internal\r\n *\r\n * Asserts something is actually a model.\r\n *\r\n * @param model\r\n * @param argName\r\n */\n\nfunction assertIsModel(model, argName, customErrMsg) {\n  if (customErrMsg === void 0) {\n    customErrMsg = \"must be a model instance\";\n  }\n\n  if (!isModel(model)) {\n    throw failure(argName + \" \" + customErrMsg);\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction isModelClass(modelClass) {\n  if (typeof modelClass !== \"function\") {\n    return false;\n  }\n\n  if (modelClass !== BaseModel && !(modelClass.prototype instanceof BaseModel)) {\n    return false;\n  }\n\n  return true;\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertIsModelClass(modelClass, argName) {\n  if (typeof modelClass !== \"function\") {\n    throw failure(argName + \" must be a class\");\n  }\n\n  if (modelClass !== BaseModel && !(modelClass.prototype instanceof BaseModel)) {\n    throw failure(argName + \" must extend Model\");\n  }\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction isModelSnapshot(sn) {\n  return isPlainObject(sn) && !!sn[modelTypeKey];\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction checkModelDecoratorArgs(fnName, target, propertyKey) {\n  if (typeof propertyKey !== \"string\") {\n    throw failure(fnName + \" cannot be used over symbol properties\");\n  }\n\n  var errMessage = fnName + \" must be used over model classes or instances\";\n\n  if (!target) {\n    throw failure(errMessage);\n  } // check target is a model object or extended class\n\n\n  if (!(target instanceof BaseModel) && target !== BaseModel && !(target.prototype instanceof BaseModel)) {\n    throw failure(errMessage);\n  }\n}\n\n/**\r\n * Returns if the given function is a model action or not.\r\n *\r\n * @param fn Function to check.\r\n * @returns\r\n */\n\nfunction isModelAction(fn) {\n  return typeof fn === \"function\" && !!fn[modelActionSymbol];\n}\n\nfunction checkModelActionArgs(target, propertyKey, value) {\n  if (typeof value !== \"function\") {\n    throw failure(\"modelAction has to be used over functions\");\n  }\n\n  checkModelDecoratorArgs(\"modelAction\", target, propertyKey);\n}\n/**\r\n * Decorator that turns a function into a model action.\r\n *\r\n * @param target\r\n * @param propertyKey\r\n * @param [baseDescriptor]\r\n * @returns\r\n */\n\n\nfunction modelAction(target, propertyKey, baseDescriptor) {\n  return decorateWrapMethodOrField(\"modelAction\", {\n    target: target,\n    propertyKey: propertyKey,\n    baseDescriptor: baseDescriptor\n  }, function (data, fn) {\n    if (isModelAction(fn)) {\n      return fn;\n    } else {\n      checkModelActionArgs(data.target, data.propertyKey, fn);\n      return wrapInAction({\n        name: data.propertyKey,\n        fn: fn,\n        actionType: ActionContextActionType.Sync\n      });\n    }\n  });\n}\n\nvar modelFlowSymbol = /*#__PURE__*/Symbol(\"modelFlow\");\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction flow(name, generator) {\n  // Implementation based on https://github.com/tj/co/blob/master/index.js\n  var flowFn = function flowFn() {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    var target = this;\n\n    if (inDevMode()) {\n      assertTweakedObject(target, \"flow\");\n    }\n\n    var previousAsyncStepContext;\n\n    var ctxOverride = function ctxOverride(stepType) {\n      return function (ctx) {\n        ctx.previousAsyncStepContext = previousAsyncStepContext;\n        ctx.spawnAsyncStepContext = previousAsyncStepContext ? previousAsyncStepContext.spawnAsyncStepContext : ctx;\n        ctx.asyncStepType = stepType;\n        ctx.args = args;\n        previousAsyncStepContext = ctx;\n      };\n    };\n\n    var generatorRun = false;\n    var gen = wrapInAction({\n      name: name,\n      fn: function fn() {\n        generatorRun = true;\n        return generator.apply(target, args);\n      },\n      actionType: ActionContextActionType.Async,\n      overrideContext: ctxOverride(ActionContextAsyncStepType.Spawn)\n    }).apply(target);\n\n    if (!generatorRun) {\n      // maybe it got overridden into a sync action\n      return gen instanceof Promise ? gen : Promise.resolve(gen);\n    } // use bound functions to fix es6 compilation\n\n\n    var genNext = gen.next.bind(gen);\n    var genThrow = gen[\"throw\"].bind(gen);\n    var promise = new Promise(function (resolve, reject) {\n      function onFulfilled(res) {\n        var ret;\n\n        try {\n          ret = wrapInAction({\n            name: name,\n            fn: genNext,\n            actionType: ActionContextActionType.Async,\n            overrideContext: ctxOverride(ActionContextAsyncStepType.Resume)\n          }).call(target, res);\n        } catch (e) {\n          wrapInAction({\n            name: name,\n            fn: function fn(err) {\n              // we use a flow finisher to allow middlewares to tweak the return value before resolution\n              return {\n                value: err,\n                resolution: \"reject\",\n                accepter: resolve,\n                rejecter: reject\n              };\n            },\n            actionType: ActionContextActionType.Async,\n            overrideContext: ctxOverride(ActionContextAsyncStepType.Throw),\n            isFlowFinisher: true\n          }).call(target, e);\n          return;\n        }\n\n        next(ret);\n      }\n\n      function onRejected(err) {\n        var ret;\n\n        try {\n          ret = wrapInAction({\n            name: name,\n            fn: genThrow,\n            actionType: ActionContextActionType.Async,\n            overrideContext: ctxOverride(ActionContextAsyncStepType.ResumeError)\n          }).call(target, err);\n        } catch (e) {\n          wrapInAction({\n            name: name,\n            fn: function fn(err) {\n              // we use a flow finisher to allow middlewares to tweak the return value before resolution\n              return {\n                value: err,\n                resolution: \"reject\",\n                accepter: resolve,\n                rejecter: reject\n              };\n            },\n            actionType: ActionContextActionType.Async,\n            overrideContext: ctxOverride(ActionContextAsyncStepType.Throw),\n            isFlowFinisher: true\n          }).call(target, e);\n          return;\n        }\n\n        next(ret);\n      }\n\n      function next(ret) {\n        if (ret && typeof ret.then === \"function\") {\n          // an async iterator\n          ret.then(next, reject);\n        } else if (ret.done) {\n          // done\n          wrapInAction({\n            name: name,\n            fn: function fn(val) {\n              // we use a flow finisher to allow middlewares to tweak the return value before resolution\n              return {\n                value: val,\n                resolution: \"accept\",\n                accepter: resolve,\n                rejecter: reject\n              };\n            },\n            actionType: ActionContextActionType.Async,\n            overrideContext: ctxOverride(ActionContextAsyncStepType.Return),\n            isFlowFinisher: true\n          }).call(target, ret.value);\n        } else {\n          // continue\n          Promise.resolve(ret.value).then(onFulfilled, onRejected);\n        }\n      }\n\n      onFulfilled(undefined); // kick off the process\n    });\n    return promise;\n  };\n\n  flowFn[modelFlowSymbol] = true;\n  return flowFn;\n}\n/**\r\n * Returns if the given function is a model flow or not.\r\n *\r\n * @param fn Function to check.\r\n * @returns\r\n */\n\nfunction isModelFlow(fn) {\n  return typeof fn === \"function\" && fn[modelFlowSymbol];\n}\n/**\r\n * Decorator that turns a function generator into a model flow.\r\n *\r\n * @param target\r\n * @param propertyKey\r\n * @param [baseDescriptor]\r\n * @returns\r\n */\n\nfunction modelFlow(target, propertyKey, baseDescriptor) {\n  return decorateWrapMethodOrField(\"modelFlow\", {\n    target: target,\n    propertyKey: propertyKey,\n    baseDescriptor: baseDescriptor\n  }, function (data, fn) {\n    if (isModelFlow(fn)) {\n      return fn;\n    } else {\n      checkModelFlowArgs(data.target, data.propertyKey, fn);\n      return flow(data.propertyKey, fn);\n    }\n  });\n}\n\nfunction checkModelFlowArgs(target, propertyKey, value) {\n  if (typeof value !== \"function\") {\n    throw failure(\"modelFlow has to be used over functions\");\n  }\n\n  checkModelDecoratorArgs(\"modelFlow\", target, propertyKey);\n}\n/**\r\n * Tricks the TS compiler into thinking that a model flow generator function can be awaited\r\n * (is a promise).\r\n *\r\n * @typeparam A Function arguments.\r\n * @typeparam R Return value.\r\n * @param fn Flow function.\r\n * @returns\r\n */\n\n\nfunction _async(fn) {\n  return fn;\n}\n/**\r\n * Makes a promise a flow, so it can be awaited with yield*.\r\n *\r\n * @typeparam T Promise return type.\r\n * @param promise Promise.\r\n * @returns\r\n */\n\nfunction _await(promise) {\n  return promiseGenerator.call(promise);\n}\n/*\r\nfunction* promiseGenerator<T>(\r\n  this: Promise<T>\r\n) {\r\n  const ret: T = yield this\r\n  return ret\r\n}\r\n*/\n// above code but compiled by TS for ES5\n// so we don't include a dependency to regenerator runtime\n\nvar __generator = function __generator(thisArg, body) {\n  var _ = {\n    label: 0,\n    sent: function sent() {\n      if (t[0] & 1) throw t[1];\n      return t[1];\n    },\n    trys: [],\n    ops: []\n  },\n      f,\n      y,\n      t,\n      g;\n  return g = {\n    next: verb(0),\n    \"throw\": verb(1),\n    \"return\": verb(2)\n  }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function () {\n    return this;\n  }), g;\n\n  function verb(n) {\n    return function (v) {\n      return step([n, v]);\n    };\n  }\n\n  function step(op) {\n    if (f) throw new TypeError(\"Generator is already executing.\");\n\n    while (_) {\n      try {\n        if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n        if (y = 0, t) op = [op[0] & 2, t.value];\n\n        switch (op[0]) {\n          case 0:\n          case 1:\n            t = op;\n            break;\n\n          case 4:\n            _.label++;\n            return {\n              value: op[1],\n              done: false\n            };\n\n          case 5:\n            _.label++;\n            y = op[1];\n            op = [0];\n            continue;\n\n          case 7:\n            op = _.ops.pop();\n\n            _.trys.pop();\n\n            continue;\n\n          default:\n            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {\n              _ = 0;\n              continue;\n            }\n\n            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {\n              _.label = op[1];\n              break;\n            }\n\n            if (op[0] === 6 && _.label < t[1]) {\n              _.label = t[1];\n              t = op;\n              break;\n            }\n\n            if (t && _.label < t[2]) {\n              _.label = t[2];\n\n              _.ops.push(op);\n\n              break;\n            }\n\n            if (t[2]) _.ops.pop();\n\n            _.trys.pop();\n\n            continue;\n        }\n\n        op = body.call(thisArg, _);\n      } catch (e) {\n        op = [6, e];\n        y = 0;\n      } finally {\n        f = t = 0;\n      }\n    }\n\n    if (op[0] & 5) throw op[1];\n    return {\n      value: op[0] ? op[1] : void 0,\n      done: true\n    };\n  }\n};\n\nfunction promiseGenerator() {\n  var ret;\n  return __generator(this, function (_a) {\n    switch (_a.label) {\n      case 0:\n        return [4\n        /*yield*/\n        , this];\n\n      case 1:\n        ret = _a.sent();\n        return [2\n        /*return*/\n        , ret];\n\n      default:\n        return;\n    }\n  });\n}\n\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction assertFnModelKeyNotInUse(fnModelObj, key) {\n  if (fnModelObj[key] !== undefined) {\n    throw failure(\"key '\" + key + \"' cannot be redeclared\");\n  }\n}\n\nvar fnModelActionRegistry = /*#__PURE__*/new Map();\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction getFnModelAction(actionName) {\n  return fnModelActionRegistry.get(actionName);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction extendFnModelActions(fnModelObj, namespace, actions) {\n  for (var _i = 0, _Object$entries = Object.entries(actions); _i < _Object$entries.length; _i++) {\n    var _Object$entries$_i = _Object$entries[_i],\n        name = _Object$entries$_i[0],\n        fn = _Object$entries$_i[1];\n    addActionToFnModel(fnModelObj, namespace, name, fn, false);\n  }\n\n  return fnModelObj;\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction addActionToFnModel(fnModelObj, namespace, name, fn, isFlow) {\n  assertFnModelKeyNotInUse(fnModelObj, name);\n  var fullActionName = namespace + \"::\" + name;\n  assertIsFunction(fn, fullActionName);\n\n  if (fnModelActionRegistry.has(fullActionName)) {\n    logWarning(\"warn\", \"an standalone action with name \\\"\" + fullActionName + \"\\\" already exists (if you are using hot-reloading you may safely ignore this warning)\", \"duplicateActionName - \" + name);\n  }\n\n  if (isModelAction(fn)) {\n    throw failure(\"the standalone action must not be previously marked as an action\");\n  }\n\n  if (isModelFlow(fn)) {\n    throw failure(\"the standalone action must not be previously marked as a flow action\");\n  }\n\n  var wrappedAction = isFlow ? flow(fullActionName, fn) : wrapInAction({\n    name: fullActionName,\n    fn: fn,\n    actionType: ActionContextActionType.Sync\n  });\n\n  fnModelObj[name] = function (target) {\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    return wrappedAction.apply(target, args);\n  };\n\n  fnModelActionRegistry.set(fullActionName, fnModelObj[name]);\n}\n\n/**\r\n * Applies a full snapshot over an object, reconciling it with the current contents of the object.\r\n *\r\n * @typeparam T Object type.\r\n * @param node Target object (model object, object or array).\r\n * @param snapshot Snapshot to apply.\r\n */\n\nfunction applySnapshot(node, snapshot) {\n  assertTweakedObject(node, \"node\");\n  assertIsObject(snapshot, \"snapshot\");\n  wrappedInternalApplySnapshot().call(node, snapshot);\n}\n\nfunction internalApplySnapshot(sn) {\n  var obj = this;\n\n  var reconcile = function reconcile() {\n    var modelPool = new ModelPool(obj);\n    var ret = reconcileSnapshot(obj, sn, modelPool);\n\n    if (inDevMode()) {\n      if (ret !== obj) {\n        throw failure(\"assertion error: reconciled object has to be the same\");\n      }\n    }\n  };\n\n  if (isArray(sn)) {\n    if (!isArray(obj)) {\n      throw failure(\"if the snapshot is an array the target must be an array too\");\n    }\n\n    return reconcile();\n  }\n\n  if (isFrozenSnapshot(sn)) {\n    throw failure(\"applySnapshot cannot be used over frozen objects\");\n  }\n\n  if (isModelSnapshot(sn)) {\n    var type = sn[modelTypeKey];\n    var modelInfo = getModelInfoForName(type);\n\n    if (!modelInfo) {\n      throw failure(\"model with name \\\"\" + type + \"\\\" not found in the registry\");\n    } // we don't check by actual instance since it might be a different one due to hot reloading\n\n\n    if (!isModel(obj)) {\n      // not a model instance, no reconciliation possible\n      throw failure(\"the target for a model snapshot must be a model instance\");\n    }\n\n    if (obj[modelTypeKey] !== type) {\n      // different kind of model, no reconciliation possible\n      throw failure(\"snapshot model type '\" + type + \"' does not match target model type '\" + obj[modelTypeKey] + \"'\");\n    }\n\n    var id = sn[modelIdKey];\n\n    if (obj[modelIdKey] !== id) {\n      // different id, no reconciliation possible\n      throw failure(\"snapshot model id '\" + id + \"' does not match target model id '\" + obj[modelIdKey] + \"'\");\n    }\n\n    return reconcile();\n  }\n\n  if (isPlainObject(sn)) {\n    if (!isPlainObject(obj) && !isObservableObject(obj)) {\n      // no reconciliation possible\n      throw failure(\"if the snapshot is an object the target must be an object too\");\n    }\n\n    return reconcile();\n  }\n\n  throw failure(\"unsupported snapshot - \" + sn);\n}\n\nvar wrappedInternalApplySnapshot = /*#__PURE__*/lazy(function () {\n  return wrapInAction({\n    name: BuiltInAction.ApplySnapshot,\n    fn: internalApplySnapshot,\n    actionType: ActionContextActionType.Sync\n  });\n});\n\n/**\r\n * Deletes an object field wrapped in an action.\r\n *\r\n * @param node  Target object.\r\n * @param fieldName Field name.\r\n */\n\nfunction applyDelete(node, fieldName) {\n  assertTweakedObject(node, \"node\");\n  wrappedInternalApplyDelete().call(node, fieldName);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction internalApplyDelete(fieldName) {\n  remove(this, \"\" + fieldName);\n}\nvar wrappedInternalApplyDelete = /*#__PURE__*/lazy(function () {\n  return wrapInAction({\n    name: BuiltInAction.ApplyDelete,\n    fn: internalApplyDelete,\n    actionType: ActionContextActionType.Sync\n  });\n});\n\n/**\r\n * Calls an object method wrapped in an action.\r\n *\r\n * @param node  Target object.\r\n * @param methodName Method name.\r\n */\n\nfunction applyMethodCall(node, methodName) {\n  assertTweakedObject(node, \"node\");\n\n  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n    args[_key - 2] = arguments[_key];\n  }\n\n  return wrappedInternalApplyMethodCall().call(node, methodName, args);\n}\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction internalApplyMethodCall(methodName, args) {\n  return this[methodName].apply(this, args);\n}\nvar wrappedInternalApplyMethodCall = /*#__PURE__*/lazy(function () {\n  return wrapInAction({\n    name: BuiltInAction.ApplyMethodCall,\n    fn: internalApplyMethodCall,\n    actionType: ActionContextActionType.Sync\n  });\n});\n\n/**\r\n * Sets an object field wrapped in an action.\r\n *\r\n * @param node  Target object.\r\n * @param fieldName Field name.\r\n * @param value Value to set.\r\n */\n\nfunction applySet(node, fieldName, value) {\n  assertTweakedObject(node, \"node\");\n  wrappedInternalApplySet().call(node, fieldName, value);\n}\n\nfunction internalApplySet(fieldName, value) {\n  // we need to check if it is a model since models can become observable objects\n  // (e.g. by having a computed value)\n  if (!isModel(this) && isObservable(this)) {\n    set(this, fieldName, value);\n  } else {\n    this[fieldName] = value;\n  }\n}\n\nvar wrappedInternalApplySet = /*#__PURE__*/lazy(function () {\n  return wrapInAction({\n    name: BuiltInAction.ApplySet,\n    fn: internalApplySet,\n    actionType: ActionContextActionType.Sync\n  });\n});\n\nvar _builtInActionToFunct;\nvar builtInActionToFunction = (_builtInActionToFunct = {}, _builtInActionToFunct[BuiltInAction.ApplySnapshot] = applySnapshot, _builtInActionToFunct[BuiltInAction.ApplyPatches] = applyPatches, _builtInActionToFunct[BuiltInAction.Detach] = detach, _builtInActionToFunct[BuiltInAction.ApplySet] = applySet, _builtInActionToFunct[BuiltInAction.ApplyDelete] = applyDelete, _builtInActionToFunct[BuiltInAction.ApplyMethodCall] = applyMethodCall, _builtInActionToFunct);\n/**\r\n * Applies (runs) an action over a target object.\r\n *\r\n * If you intend to apply serialized actions check one of the `applySerializedAction` methods instead.\r\n *\r\n * @param subtreeRoot Subtree root target object to run the action over.\r\n * @param call The action, usually as coming from `onActionMiddleware`.\r\n * @returns The return value of the action, if any.\r\n */\n\nfunction applyAction(subtreeRoot, call) {\n  if (call.serialized) {\n    throw failure(\"cannot apply a serialized action call, use one of the 'applySerializedAction' methods instead\");\n  }\n\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\"); // resolve path while checking ids\n\n  var _resolvePathCheckingI = resolvePathCheckingIds(subtreeRoot, call.targetPath, call.targetPathIds),\n      current = _resolvePathCheckingI.value,\n      resolved = _resolvePathCheckingI.resolved;\n\n  if (!resolved) {\n    throw failure(\"object at path \" + JSON.stringify(call.targetPath) + \" with ids \" + JSON.stringify(call.targetPathIds) + \" could not be resolved\");\n  }\n\n  assertTweakedObject(current, \"resolved \" + current, true);\n\n  if (isBuiltInAction(call.actionName)) {\n    var fnToCall = builtInActionToFunction[call.actionName];\n\n    if (!fnToCall) {\n      throw failure(\"assertion error: unknown built-in action - \" + call.actionName);\n    }\n\n    return fnToCall.apply(current, [current].concat(call.args));\n  } else if (isHookAction(call.actionName)) {\n    throw failure(\"calls to hooks (\" + call.actionName + \") cannot be applied\");\n  } else {\n    var standaloneAction = getFnModelAction(call.actionName);\n\n    if (standaloneAction) {\n      return standaloneAction.apply(current, call.args);\n    } else {\n      return current[call.actionName].apply(current, call.args);\n    }\n  }\n}\n\nvar cannotSerialize = /*#__PURE__*/Symbol(\"cannotSerialize\");\n\nvar arraySerializer = {\n  id: \"mobx-keystone/array\",\n  serialize: function serialize(value, _serialize) {\n    if (!isArray(value)) return cannotSerialize; // this will also transform observable arrays into non-observable ones\n\n    return value.map(_serialize);\n  },\n  deserialize: function deserialize(arr, _deserialize) {\n    return arr.map(_deserialize);\n  }\n};\n\nvar dateSerializer = {\n  id: \"mobx-keystone/dateAsTimestamp\",\n  serialize: function serialize(date) {\n    if (!(date instanceof Date)) return cannotSerialize;\n    return +date;\n  },\n  deserialize: function deserialize(timestamp) {\n    return new Date(timestamp);\n  }\n};\n\nvar mapSerializer = {\n  id: \"mobx-keystone/mapAsArray\",\n  serialize: function serialize(map, _serialize) {\n    if (!(map instanceof Map) && !isObservableMap(map)) return cannotSerialize;\n    var arr = [];\n    var iter = map.keys();\n    var cur = iter.next();\n\n    while (!cur.done) {\n      var k = cur.value;\n      var v = map.get(k);\n      arr.push([_serialize(k), _serialize(v)]);\n      cur = iter.next();\n    }\n\n    return arr;\n  },\n  deserialize: function deserialize(arr, _deserialize) {\n    var map = new Map();\n    var len = arr.length;\n\n    for (var i = 0; i < len; i++) {\n      var k = arr[i][0];\n      var v = arr[i][1];\n      map.set(_deserialize(k), _deserialize(v));\n    }\n\n    return map;\n  }\n};\n\n/**\r\n * @ignore\r\n */\n\nfunction rootPathToTargetPathIds(rootPath) {\n  var targetPathIds = [];\n\n  for (var i = 0; i < rootPath.path.length; i++) {\n    var targetObj = rootPath.pathObjects[i + 1]; // first is root, we don't care about its ID\n\n    var targetObjId = isModel(targetObj) ? targetObj[modelIdKey] : null;\n    targetPathIds.push(targetObjId);\n  }\n\n  return targetPathIds;\n}\n/**\r\n * @ignore\r\n */\n\nfunction pathToTargetPathIds(root, path) {\n  var targetPathIds = [];\n  var current = root; // we don't care about the root ID\n\n  for (var i = 0; i < path.length; i++) {\n    current = current[path[i]];\n    var targetObjId = isModel(current) ? current[modelIdKey] : null;\n    targetPathIds.push(targetObjId);\n  }\n\n  return targetPathIds;\n}\n\nvar objectPathSerializer = {\n  id: \"mobx-keystone/objectPath\",\n  serialize: function serialize(value, _, targetRoot) {\n    if (typeof value !== \"object\" || value === null || !isTweakedObject(value, false)) return cannotSerialize; // try to serialize a ref to its path if possible instead\n\n    if (targetRoot) {\n      var rootPath = fastGetRootPath(value);\n\n      if (rootPath.root === targetRoot) {\n        return {\n          targetPath: rootPath.path,\n          targetPathIds: rootPathToTargetPathIds(rootPath)\n        };\n      }\n    }\n\n    return cannotSerialize;\n  },\n  deserialize: function deserialize(ref, _, targetRoot) {\n    // try to resolve the node back\n    if (targetRoot) {\n      var result = resolvePathCheckingIds(targetRoot, ref.targetPath, ref.targetPathIds);\n\n      if (result.resolved) {\n        return result.value;\n      }\n    }\n\n    throw failure(\"object at path \" + JSON.stringify(ref.targetPath) + \" with ids \" + JSON.stringify(ref.targetPathIds) + \" could not be resolved\");\n  }\n};\n\nvar objectSnapshotSerializer = {\n  id: \"mobx-keystone/objectSnapshot\",\n  serialize: function serialize(value) {\n    if (typeof value !== \"object\" || value === null || !isTweakedObject(value, false)) return cannotSerialize;\n    return getSnapshot(value);\n  },\n  deserialize: function deserialize(snapshot) {\n    return fromSnapshot(snapshot);\n  }\n};\n\nvar plainObjectSerializer = {\n  id: \"mobx-keystone/plainObject\",\n  serialize: function serialize(value, _serialize) {\n    if (!isPlainObject(value) && !isObservableObject(value)) return cannotSerialize; // this will make observable objects non-observable ones\n\n    return mapObjectFields(value, _serialize);\n  },\n  deserialize: function deserialize(obj, serialize) {\n    return mapObjectFields(obj, serialize);\n  }\n};\n\nfunction mapObjectFields(originalObj, mapFn) {\n  var obj = {};\n  var keys = Object.keys(originalObj);\n  var len = keys.length;\n\n  for (var i = 0; i < len; i++) {\n    var k = keys[i];\n    var v = originalObj[k];\n    obj[k] = mapFn(v);\n  }\n\n  return obj;\n}\n\nvar setSerializer = {\n  id: \"mobx-keystone/setAsArray\",\n  serialize: function serialize(set, _serialize) {\n    if (!(set instanceof Set)) return cannotSerialize;\n    var arr = [];\n    var iter = set.keys();\n    var cur = iter.next();\n\n    while (!cur.done) {\n      var k = cur.value;\n      arr.push(_serialize(k));\n      cur = iter.next();\n    }\n\n    return arr;\n  },\n  deserialize: function deserialize(arr, _deserialize) {\n    var set = new Set();\n    var len = arr.length;\n\n    for (var i = 0; i < len; i++) {\n      var k = arr[i];\n      set.add(_deserialize(k));\n    }\n\n    return set;\n  }\n};\n\nvar serializersArray = [];\nvar serializersMap = /*#__PURE__*/new Map();\n/**\r\n * Registers a new action call argument serializers.\r\n * Serializers are called in the inverse order they are registered, meaning the\r\n * latest one registered will be called first.\r\n *\r\n * @param serializer Serializer to register.\r\n * @returns A disposer to unregister the serializer.\r\n */\n\nfunction registerActionCallArgumentSerializer(serializer) {\n  if (serializersArray.includes(serializer)) {\n    throw failure(\"action call argument serializer already registered\");\n  }\n\n  if (serializersMap.has(serializer.id)) {\n    throw failure(\"action call argument serializer with id '\" + serializer.id + \"' already registered\");\n  }\n\n  serializersArray.unshift(serializer);\n  serializersMap.set(serializer.id, serializer);\n  return function () {\n    var index = serializersArray.indexOf(serializer);\n\n    if (index >= 0) {\n      serializersArray.splice(index, 1);\n    }\n\n    serializersMap[\"delete\"](serializer.id);\n  };\n}\n/**\r\n * Transforms an action call argument by returning a `SerializedActionCallArgument`.\r\n * The following are supported out of the box:\r\n * - Primitives.\r\n * - Nodes that are under the same root node as the target root (when provided) will be serialized\r\n *   as a path.\r\n * - Nodes that are not under the same root node as the target root will be serialized as their snapshot.\r\n * - Arrays (observable or not).\r\n * - Dates.\r\n * - Maps (observable or not).\r\n * - Sets (observable or not).\r\n * - Plain objects (observable or not).\r\n *\r\n * If the value cannot be serialized it will throw an exception.\r\n *\r\n * @param argValue Argument value to be transformed into its serializable form.\r\n * @param [targetRoot] Target root node of the model where this action is being performed.\r\n * @returns The serializable form of the passed value.\r\n */\n\nfunction serializeActionCallArgument(argValue, targetRoot) {\n  if (isPrimitive(argValue)) {\n    return argValue;\n  }\n\n  var origValue = argValue;\n\n  var serialize = function serialize(v) {\n    return serializeActionCallArgument(v, targetRoot);\n  }; // try serializers\n\n\n  for (var i = 0; i < serializersArray.length; i++) {\n    var serializer = serializersArray[i];\n    var serializedValue = serializer.serialize(argValue, serialize, targetRoot);\n\n    if (serializedValue !== cannotSerialize) {\n      return {\n        $mobxKeystoneSerializer: serializer.id,\n        value: serializedValue\n      };\n    }\n  }\n\n  throw failure(\"serializeActionCallArgument could not serialize the given value: \" + origValue);\n}\n/**\r\n * Ensures that an action call is serializable by mapping the action arguments into its\r\n * serializable version by using `serializeActionCallArgument`.\r\n *\r\n * @param actionCall Action call to convert.\r\n * @param [targetRoot] Target root node of the model where this action is being performed.\r\n * @returns The serializable action call.\r\n */\n\nfunction serializeActionCall(actionCall, targetRoot) {\n  if (actionCall.serialized) {\n    throw failure(\"cannot serialize an already serialized action call\");\n  }\n\n  if (targetRoot !== undefined) {\n    assertTweakedObject(targetRoot, \"targetRoot\");\n  }\n\n  var serialize = function serialize(v) {\n    return serializeActionCallArgument(v, targetRoot);\n  };\n\n  return _extends({}, actionCall, {\n    serialized: true,\n    args: actionCall.args.map(serialize)\n  });\n}\n/**\r\n * Transforms an action call argument by returning its deserialized equivalent.\r\n *\r\n * @param argValue Argument value to be transformed into its deserialized form.\r\n * @param [targetRoot] Target root node of the model where this action is being performed.\r\n * @returns The deserialized form of the passed value.\r\n */\n\nfunction deserializeActionCallArgument(argValue, targetRoot) {\n  if (isPrimitive(argValue)) {\n    return argValue;\n  }\n\n  if (!isPlainObject(argValue) || typeof argValue.$mobxKeystoneSerializer !== \"string\") {\n    throw failure(\"invalid serialized action call argument\");\n  }\n\n  var serializerId = argValue.$mobxKeystoneSerializer;\n  var serializer = serializersMap.get(serializerId);\n\n  if (!serializer) {\n    throw failure(\"a serializer with id '\" + serializerId + \"' could not be found\");\n  }\n\n  var serializedValue = argValue;\n\n  var deserialize = function deserialize(v) {\n    return deserializeActionCallArgument(v, targetRoot);\n  };\n\n  return serializer.deserialize(serializedValue.value, deserialize, targetRoot);\n}\n/**\r\n * Ensures that an action call is deserialized by mapping the action arguments into its\r\n * deserialized version by using `deserializeActionCallArgument`.\r\n *\r\n * @param actionCall Action call to convert.\r\n * @param [targetRoot] Target root node of the model where this action is being performed.\r\n * @returns The deserialized action call.\r\n */\n\nfunction deserializeActionCall(actionCall, targetRoot) {\n  if (!actionCall.serialized) {\n    throw failure(\"cannot deserialize a non-serialized action call\");\n  }\n\n  if (targetRoot !== undefined) {\n    assertTweakedObject(targetRoot, \"targetRoot\");\n  }\n\n  var deserialize = function deserialize(v) {\n    return deserializeActionCallArgument(v, targetRoot);\n  };\n\n  var deserializedActionCall = _extends({}, actionCall, {\n    serialized: undefined,\n    args: actionCall.args.map(deserialize)\n  });\n\n  delete deserializedActionCall.serialized;\n  return deserializedActionCall;\n} // serializer registration (from low priority to high priority)\n\nregisterActionCallArgumentSerializer(plainObjectSerializer);\nregisterActionCallArgumentSerializer(setSerializer);\nregisterActionCallArgumentSerializer(mapSerializer);\nregisterActionCallArgumentSerializer(dateSerializer);\nregisterActionCallArgumentSerializer(arraySerializer);\nregisterActionCallArgumentSerializer(objectSnapshotSerializer);\nregisterActionCallArgumentSerializer(objectPathSerializer);\n\nfunction typesObjectHelper(objFn, frozen, typeInfoGen) {\n  assertIsFunction(objFn, \"objFn\");\n  return lateTypeChecker(function () {\n    var objectSchema = objFn();\n    assertIsObject(objectSchema, \"objectSchema\");\n    var schemaEntries = Object.entries(objectSchema);\n\n    var getTypeName = function getTypeName() {\n      var propsMsg = [];\n\n      for (var _len = arguments.length, recursiveTypeCheckers = new Array(_len), _key = 0; _key < _len; _key++) {\n        recursiveTypeCheckers[_key] = arguments[_key];\n      }\n\n      for (var _iterator = _createForOfIteratorHelperLoose(schemaEntries), _step; !(_step = _iterator()).done;) {\n        var _step$value = _step.value,\n            k = _step$value[0],\n            unresolvedTc = _step$value[1];\n        var tc = resolveTypeChecker(unresolvedTc);\n        var propTypename = \"...\";\n\n        if (!recursiveTypeCheckers.includes(tc)) {\n          propTypename = tc.getTypeName.apply(tc, recursiveTypeCheckers.concat([tc]));\n        }\n\n        propsMsg.push(k + \": \" + propTypename + \";\");\n      }\n\n      return \"{ \" + propsMsg.join(\" \") + \" }\";\n    };\n\n    var thisTc = new TypeChecker(function (obj, path) {\n      if (!isObject(obj) || frozen && !(obj instanceof Frozen)) return new TypeCheckError(path, getTypeName(thisTc), obj); // note: we allow excess properties when checking objects\n\n      for (var _iterator2 = _createForOfIteratorHelperLoose(schemaEntries), _step2; !(_step2 = _iterator2()).done;) {\n        var _step2$value = _step2.value,\n            k = _step2$value[0],\n            unresolvedTc = _step2$value[1];\n        var tc = resolveTypeChecker(unresolvedTc);\n        var objVal = obj[k];\n        var valueError = !tc.unchecked ? tc.check(objVal, [].concat(path, [k])) : null;\n\n        if (valueError) {\n          return valueError;\n        }\n      }\n\n      return null;\n    }, getTypeName, typeInfoGen);\n    return thisTc;\n  }, typeInfoGen);\n}\n/**\r\n * A type that represents a plain object.\r\n * Note that the parameter must be a function that returns an object. This is done so objects can support self / cross types.\r\n *\r\n * Example:\r\n * ```ts\r\n * // notice the ({ ... }), not just { ... }\r\n * const pointType = types.object(() => ({\r\n *   x: types.number,\r\n *   y: types.number\r\n * }))\r\n * ```\r\n *\r\n * @typeparam T Type.\r\n * @param objectFunction Function that generates an object with types.\r\n * @returns\r\n */\n\n\nfunction typesObject(objectFunction) {\n  // we can't type this function or else we won't be able to make it work recursively\n  var typeInfoGen = function typeInfoGen(t) {\n    return new ObjectTypeInfo(t, objectFunction);\n  };\n\n  return typesObjectHelper(objectFunction, false, typeInfoGen);\n}\n/**\r\n * `types.object` type info.\r\n */\n\nvar ObjectTypeInfo = /*#__PURE__*/function (_TypeInfo) {\n  _inheritsLoose(ObjectTypeInfo, _TypeInfo);\n\n  _createClass(ObjectTypeInfo, [{\n    key: \"props\",\n    // memoize to always return the same object\n    get: function get() {\n      return this._props();\n    }\n  }]);\n\n  function ObjectTypeInfo(thisType, _objTypeFn) {\n    var _this;\n\n    _this = _TypeInfo.call(this, thisType) || this;\n    _this._objTypeFn = void 0;\n    _this._props = lateVal(function () {\n      var objSchema = _this._objTypeFn();\n\n      var propTypes = {};\n      Object.keys(objSchema).forEach(function (propName) {\n        var type = resolveStandardType(objSchema[propName]);\n        propTypes[propName] = {\n          type: type,\n          typeInfo: getTypeInfo(type)\n        };\n      });\n      return propTypes;\n    });\n    _this._objTypeFn = _objTypeFn;\n    return _this;\n  }\n\n  return ObjectTypeInfo;\n}(TypeInfo);\n/**\r\n * A type that represents frozen data.\r\n *\r\n * Example:\r\n * ```ts\r\n * const frozenNumberType = types.frozen(types.number)\r\n * const frozenAnyType = types.frozen(types.unchecked<any>())\r\n * const frozenNumberArrayType = types.frozen(types.array(types.number))\r\n * const frozenUncheckedNumberArrayType = types.frozen(types.unchecked<number[]>())\r\n * ```\r\n *\r\n * @typeParam T Type.\r\n * @param dataType Type of the frozen data.\r\n * @returns\r\n */\n\nfunction typesFrozen(dataType) {\n  return typesObjectHelper(function () {\n    return {\n      data: dataType\n    };\n  }, true, function (t) {\n    return new FrozenTypeInfo(t, resolveStandardType(dataType));\n  });\n}\n/**\r\n * `types.frozen` type info.\r\n */\n\nvar FrozenTypeInfo = /*#__PURE__*/function (_TypeInfo2) {\n  _inheritsLoose(FrozenTypeInfo, _TypeInfo2);\n\n  _createClass(FrozenTypeInfo, [{\n    key: \"dataTypeInfo\",\n    get: function get() {\n      return getTypeInfo(this.dataType);\n    }\n  }]);\n\n  function FrozenTypeInfo(thisType, dataType) {\n    var _this2;\n\n    _this2 = _TypeInfo2.call(this, thisType) || this;\n    _this2.dataType = void 0;\n    _this2.dataType = dataType;\n    return _this2;\n  }\n\n  return FrozenTypeInfo;\n}(TypeInfo);\n\nvar unchecked = /*#__PURE__*/new TypeChecker(null, function () {\n  return \"any\";\n}, function (t) {\n  return new UncheckedTypeInfo(t);\n});\n/**\r\n * A type that represents a given value that won't be type checked.\r\n * This is basically a way to bail out of the runtime type checking system.\r\n *\r\n * Example:\r\n * ```ts\r\n * const uncheckedSomeModel = types.unchecked<SomeModel>()\r\n * const anyType = types.unchecked<any>()\r\n * const customUncheckedType = types.unchecked<(A & B) | C>()\r\n * ```\r\n *\r\n * @typeparam T Type of the value, or unkown if not given.\r\n * @returns\r\n */\n\nfunction typesUnchecked() {\n  return unchecked;\n}\n/**\r\n * `types.unchecked` type info.\r\n */\n\nvar UncheckedTypeInfo = /*#__PURE__*/function (_TypeInfo) {\n  _inheritsLoose(UncheckedTypeInfo, _TypeInfo);\n\n  function UncheckedTypeInfo() {\n    return _TypeInfo.apply(this, arguments) || this;\n  }\n\n  return UncheckedTypeInfo;\n}(TypeInfo);\n\n/**\r\n * Base abstract class for models that extends another model.\r\n *\r\n * @typeparam TProps New model properties type.\r\n * @typeparam TBaseModelClass Base class type.\r\n * @param baseModel Base model type.\r\n * @param modelProps Model properties.\r\n * @returns\r\n */\n\nfunction ExtendedModel(baseModel, modelProps) {\n  assertIsModelClass(baseModel, \"baseModel\"); // note that & Object is there to support abstract classes\n\n  return internalModel(modelProps, baseModel);\n}\n/**\r\n * Base abstract class for models.\r\n *\r\n * Never override the constructor, use `onInit` or `onAttachedToRootStore` instead.\r\n *\r\n * @typeparam TProps Model properties type.\r\n * @param modelProps Model properties.\r\n */\n\nfunction Model(modelProps) {\n  return internalModel(modelProps);\n}\n\nfunction internalModel(modelProps, baseModel) {\n  var _baseModel;\n\n  assertIsObject(modelProps, \"modelProps\");\n\n  if (baseModel) {\n    assertIsModelClass(baseModel, \"baseModel\"); // if the baseModel is wrapped with the model decorator get the original one\n\n    var unwrappedClass = baseModel[modelUnwrappedClassSymbol];\n\n    if (unwrappedClass) {\n      baseModel = unwrappedClass;\n      assertIsModelClass(baseModel, \"baseModel\");\n    }\n  }\n\n  var extraDescriptors = {};\n  var composedModelProps = modelProps;\n\n  if (baseModel) {\n    var oldModelProps = getInternalModelClassPropsInfo(baseModel);\n\n    for (var _i = 0, _Object$keys = Object.keys(oldModelProps); _i < _Object$keys.length; _i++) {\n      var oldModelPropKey = _Object$keys[_i];\n\n      if (modelProps[oldModelPropKey]) {\n        throw failure(\"extended model cannot redeclare base model property named '\" + oldModelPropKey + \"'\");\n      }\n\n      composedModelProps[oldModelPropKey] = oldModelProps[oldModelPropKey];\n    }\n  } else {\n    // define $modelId on the base\n    extraDescriptors[modelIdKey] = createModelPropDescriptor(modelIdKey, undefined, true);\n  } // create type checker if needed\n\n\n  var dataTypeChecker;\n\n  if (Object.values(composedModelProps).some(function (mp) {\n    return !!mp.typeChecker;\n  })) {\n    var typeCheckerObj = {};\n\n    for (var _i2 = 0, _Object$entries = Object.entries(composedModelProps); _i2 < _Object$entries.length; _i2++) {\n      var _Object$entries$_i = _Object$entries[_i2],\n          k = _Object$entries$_i[0],\n          mp = _Object$entries$_i[1];\n      typeCheckerObj[k] = !mp.typeChecker ? typesUnchecked() : mp.typeChecker;\n    }\n\n    dataTypeChecker = typesObject(function () {\n      return typeCheckerObj;\n    });\n  } // skip props that are on base model, these have to be accessed through $\n  // we only need to proxy new props, not old ones\n\n\n  for (var _iterator = _createForOfIteratorHelperLoose(Object.keys(modelProps).filter(function (mp) {\n    return !baseModelPropNames.has(mp);\n  })), _step; !(_step = _iterator()).done;) {\n    var modelPropName = _step.value;\n    extraDescriptors[modelPropName] = createModelPropDescriptor(modelPropName, modelProps[modelPropName], false);\n  }\n\n  var extraPropNames = Object.keys(extraDescriptors);\n  var extraPropNamesLen = extraPropNames.length;\n  var base = (_baseModel = baseModel) != null ? _baseModel : BaseModel;\n  var propsWithTransforms = Object.entries(modelProps).filter(function (_ref) {\n    var _propName = _ref[0],\n        prop = _ref[1];\n    return !!prop.transform;\n  }).map(function (_ref2) {\n    var propName = _ref2[0],\n        prop = _ref2[1];\n    return [propName, prop.transform];\n  }); // we use this weird hack rather than just class CustomBaseModel extends base {}\n  // in order to work around problems with ES5 classes extending ES6 classes\n  // see https://github.com/xaviergonz/mobx-keystone/issues/15\n\n  var CustomBaseModel = function (_base) {\n    _inheritsLoose$1(CustomBaseModel, _base);\n\n    function CustomBaseModel(initialData, constructorOptions) {\n      var _constructorOptions$m;\n\n      var baseModel = new base(initialData, _extends({}, constructorOptions, {\n        modelClass: (_constructorOptions$m = constructorOptions == null ? void 0 : constructorOptions.modelClass) != null ? _constructorOptions$m : this.constructor,\n        propsWithTransforms: propsWithTransforms\n      })); // make sure abstract classes do not override prototype props\n\n      for (var i = 0; i < extraPropNamesLen; i++) {\n        var extraPropName = extraPropNames[i];\n\n        if (Object.getOwnPropertyDescriptor(baseModel, extraPropName)) {\n          delete baseModel[extraPropName];\n        }\n      }\n\n      return baseModel;\n    }\n\n    return CustomBaseModel;\n  }(base);\n\n  var initializers = base[modelInitializersSymbol];\n\n  if (initializers) {\n    CustomBaseModel[modelInitializersSymbol] = initializers.slice();\n  }\n\n  setInternalModelClassPropsInfo(CustomBaseModel, composedModelProps);\n  CustomBaseModel[modelDataTypeCheckerSymbol] = dataTypeChecker;\n  Object.defineProperties(CustomBaseModel.prototype, extraDescriptors);\n  return CustomBaseModel;\n}\n\nfunction _inheritsLoose$1(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}\n\nfunction createModelPropDescriptor(modelPropName, modelProp, enumerable) {\n  return {\n    enumerable: enumerable,\n    configurable: true,\n    get: function get() {\n      return getModelInstanceDataField(this, modelProp, modelPropName);\n    },\n    set: function set(v) {\n      // hack to only permit setting these values once fully constructed\n      // this is to ignore abstract properties being set by babel\n      // see https://github.com/xaviergonz/mobx-keystone/issues/18\n      if (!this[modelInitializedSymbol]) {\n        return;\n      }\n\n      setModelInstanceDataField(this, modelProp, modelPropName, v);\n    }\n  };\n}\n\nfunction getModelInstanceDataField(model, modelProp, modelPropName) {\n  var transform = modelProp ? modelProp.transform : undefined;\n\n  if (transform) {\n    // no need to use get since these vars always get on the initial $\n    var memoTransform = memoTransformCache.getOrCreateMemoTransform(model, modelPropName, transform);\n    return memoTransform.propToData(model.$[modelPropName]);\n  } else {\n    // no need to use get since these vars always get on the initial $\n    return model.$[modelPropName];\n  }\n}\n\nfunction setModelInstanceDataField(model, modelProp, modelPropName, value) {\n  if (modelProp != null && modelProp.options.setterAction && !getCurrentActionContext()) {\n    // use apply set instead to wrap it in an action\n    applySet(model, modelPropName, value);\n    return;\n  }\n\n  var transform = modelProp == null ? void 0 : modelProp.transform;\n\n  if (transform) {\n    // no need to use set since these vars always get on the initial $\n    var memoTransform = memoTransformCache.getOrCreateMemoTransform(model, modelPropName, transform);\n    model.$[modelPropName] = memoTransform.dataToProp(value);\n  } else {\n    // no need to use set since these vars always get on the initial $\n    model.$[modelPropName] = value;\n  }\n}\n\n/**\r\n * Decorator that marks this class (which MUST inherit from the `Model` abstract class)\r\n * as a model.\r\n *\r\n * @param name Unique name for the model type. Note that this name must be unique for your whole\r\n * application, so it is usually a good idea to use some prefix unique to your application domain.\r\n */\n\nvar model = function model(name) {\n  return function (clazz) {\n    return internalModel$1(name)(clazz);\n  };\n};\n\nvar internalModel$1 = function internalModel(name) {\n  return function (clazz) {\n    assertIsModelClass(clazz, \"a model class\");\n\n    if (modelInfoByName[name]) {\n      if (getGlobalConfig().showDuplicateModelNameWarnings) {\n        logWarning(\"warn\", \"a model with name \\\"\" + name + \"\\\" already exists (if you are using hot-reloading you may safely ignore this warning)\", \"duplicateModelName - \" + name);\n      }\n    }\n\n    if (clazz[modelUnwrappedClassSymbol]) {\n      throw failure(\"a class already decorated with `@model` cannot be re-decorated\");\n    } // trick so plain new works\n\n\n    var newClazz = function newClazz(initialData, snapshotInitialData, generateNewIds) {\n      var instance = new clazz(initialData, snapshotInitialData, this.constructor, generateNewIds);\n      runLateInitializationFunctions(instance); // compatibility with mobx 6\n\n      if (getMobxVersion() >= 6) {\n        try {\n          mobx6.makeObservable(instance);\n        } catch (err) {\n          // sadly we need to use this hack since the PR to do this the proper way\n          // was rejected on the mobx side\n          if (err.message !== \"[MobX] No annotations were passed to makeObservable, but no decorator members have been found either\" && err.message !== \"[MobX] No annotations were passed to makeObservable, but no decorated members have been found either\") {\n            throw err;\n          }\n        }\n      } // the object is ready\n\n\n      addHiddenProp(instance, modelInitializedSymbol, true, false);\n\n      if (instance.onInit) {\n        wrapModelMethodInActionIfNeeded(instance, \"onInit\", HookAction.OnInit);\n        instance.onInit();\n      }\n\n      return instance;\n    };\n\n    clazz.toString = function () {\n      return \"class \" + clazz.name + \"#\" + name;\n    };\n\n    clazz[modelTypeKey] = name; // this also gives access to modelInitializersSymbol, modelPropertiesSymbol, modelDataTypeCheckerSymbol\n\n    Object.setPrototypeOf(newClazz, clazz);\n    newClazz.prototype = clazz.prototype;\n    Object.defineProperty(newClazz, \"name\", _extends({}, Object.getOwnPropertyDescriptor(newClazz, \"name\"), {\n      value: clazz.name\n    }));\n    newClazz[modelUnwrappedClassSymbol] = clazz;\n    var modelInfo = {\n      name: name,\n      \"class\": newClazz\n    };\n    modelInfoByName[name] = modelInfo;\n    modelInfoByClass.set(newClazz, modelInfo);\n    modelInfoByClass.set(clazz, modelInfo);\n    return newClazz;\n  };\n}; // basically taken from TS\n\n\nfunction tsDecorate(decorators, target, key, desc) {\n  var c = arguments.length,\n      r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,\n      d;\n  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--) {\n    if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  } // eslint-disable-next-line no-sequences\n\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\n/**\r\n * Marks a class (which MUST inherit from the `Model` abstract class)\r\n * as a model and decorates some of its methods/properties.\r\n *\r\n * @param name Unique name for the model type. Note that this name must be unique for your whole\r\n * application, so it is usually a good idea to use some prefix unique to your application domain.\r\n * If you don't want to assign a name yet (e.g. for a base model) pass `undefined`.\r\n * @param clazz Model class.\r\n * @param decorators Decorators.\r\n */\n\n\nfunction decoratedModel(name, clazz, decorators) {\n  // decorate class members\n  for (var _i = 0, _Object$entries = Object.entries(decorators); _i < _Object$entries.length; _i++) {\n    var _Object$entries$_i = _Object$entries[_i],\n        k = _Object$entries$_i[0],\n        decorator = _Object$entries$_i[1];\n    var prototypeValueDesc = Object.getOwnPropertyDescriptor(clazz.prototype, k); // TS seems to send null for methods in the prototype\n    // (which we substitute for the descriptor to avoid a double look-up) and void 0 (undefined) for props\n\n    tsDecorate(Array.isArray(decorator) ? decorator : [decorator], clazz.prototype, k, prototypeValueDesc ? prototypeValueDesc : void 0);\n  }\n\n  return name ? model(name)(clazz) : clazz;\n}\n\n/**\r\n * Applies (runs) a serialized action over a target object.\r\n * In this mode newly generated / modified model IDs will be tracked\r\n * so they can be later synchronized when applying it on another machine\r\n * via `applySerializedActionAndSyncNewModelIds`.\r\n * This means this method is usually used on the server side.\r\n *\r\n * If you intend to apply non-serialized actions check `applyAction` instead.\r\n *\r\n * @param subtreeRoot Subtree root target object to run the action over.\r\n * @param call The serialized action, usually as coming from the server/client.\r\n * @returns The return value of the action, if any, plus a new serialized action\r\n * with model overrides.\r\n */\n\nfunction applySerializedActionAndTrackNewModelIds(subtreeRoot, call) {\n  if (!call.serialized) {\n    throw failure(\"cannot apply a non-serialized action call, use 'applyAction' instead\");\n  }\n\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\");\n  var deserializedCall = deserializeActionCall(call, subtreeRoot);\n  var modelIdOverrides = []; // set a patch listener to track changes to model ids\n\n  var patchDisposer = onPatches(subtreeRoot, function (patches) {\n    scanPatchesForModelIdChanges(subtreeRoot, modelIdOverrides, patches);\n  });\n\n  try {\n    var returnValue = applyAction(subtreeRoot, deserializedCall);\n    return {\n      returnValue: returnValue,\n      serializedActionCall: _extends({}, call, {\n        modelIdOverrides: modelIdOverrides\n      })\n    };\n  } finally {\n    patchDisposer();\n  }\n}\n\nfunction scanPatchesForModelIdChanges(root, modelIdOverrides, patches) {\n  var len = patches.length;\n\n  for (var i = 0; i < len; i++) {\n    var patch = patches[i];\n\n    if (patch.op === \"replace\" || patch.op === \"add\") {\n      deepScanValueForModelIdChanges(root, modelIdOverrides, patch.value, patch.path);\n    }\n  }\n}\n\nfunction deepScanValueForModelIdChanges(root, modelIdOverrides, value, path) {\n  if (path.length >= 1 && path[path.length - 1] === modelIdKey && typeof value === \"string\") {\n    // ensure the parent is an actual model\n    var parent = resolvePath(root, path.slice(0, path.length - 1)).value;\n\n    if (isModel(parent)) {\n      // found one\n      modelIdOverrides.push({\n        op: \"replace\",\n        path: path.slice(),\n        value: value\n      });\n    }\n  } else if (Array.isArray(value)) {\n    var len = value.length;\n\n    for (var i = 0; i < len; i++) {\n      path.push(i);\n      deepScanValueForModelIdChanges(root, modelIdOverrides, value[i], path);\n      path.pop();\n    }\n  } else if (isObject(value)) {\n    // skip frozen values\n    if (!value[frozenKey]) {\n      var keys = Object.keys(value);\n      var _len = keys.length;\n\n      for (var _i = 0; _i < _len; _i++) {\n        var propName = keys[_i];\n        var propValue = value[propName];\n        path.push(propName);\n        deepScanValueForModelIdChanges(root, modelIdOverrides, propValue, path);\n        path.pop();\n      }\n    }\n  }\n}\n/**\r\n * Applies (runs) a serialized action over a target object.\r\n * In this mode newly generated / modified model IDs will be tracked\r\n * so they can be later synchronized when applying it on another machine\r\n * via `applySerializedActionAndSyncNewModelIds`.\r\n * This means this method is usually used on the server side.\r\n *\r\n * If you intend to apply non-serialized actions check `applyAction` instead.\r\n *\r\n * @param subtreeRoot Subtree root target object to run the action over.\r\n * @param call The serialized action, usually as coming from the server/client.\r\n * @returns The return value of the action, if any, plus a new serialized action\r\n * with model overrides.\r\n */\n\n\nfunction applySerializedActionAndSyncNewModelIds(subtreeRoot, call) {\n  if (!call.serialized) {\n    throw failure(\"cannot apply a non-serialized action call, use 'applyAction' instead\");\n  }\n\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\");\n  var deserializedCall = deserializeActionCall(call, subtreeRoot);\n  var returnValue;\n  runInAction(function () {\n    returnValue = applyAction(subtreeRoot, deserializedCall); // apply model id overrides\n\n    applyPatches(subtreeRoot, call.modelIdOverrides);\n  });\n  return returnValue;\n}\n\n/**\r\n * Action tracking middleware finish result.\r\n */\n\nvar ActionTrackingResult;\n\n(function (ActionTrackingResult) {\n  /**\r\n   * The action returned normally (without throwing).\r\n   */\n  ActionTrackingResult[\"Return\"] = \"return\";\n  /**\r\n   * The action threw an error.\r\n   */\n\n  ActionTrackingResult[\"Throw\"] = \"throw\";\n})(ActionTrackingResult || (ActionTrackingResult = {}));\n/**\r\n * Creates an action tracking middleware, which is a simplified version\r\n * of the standard action middleware.\r\n *\r\n * @param subtreeRoot Subtree root target object.\r\n * @param hooks Middleware hooks.\r\n * @returns The middleware disposer.\r\n */\n\n\nfunction actionTrackingMiddleware(subtreeRoot, hooks) {\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\");\n  var dataSymbol = Symbol(\"actionTrackingMiddlewareData\");\n\n  function getCtxData(ctx) {\n    return ctx.data[dataSymbol];\n  }\n\n  function setCtxData(ctx, partialData) {\n    var currentData = ctx.data[dataSymbol];\n\n    if (!currentData) {\n      ctx.data[dataSymbol] = partialData;\n    } else {\n      Object.assign(currentData, partialData);\n    }\n  }\n\n  var userFilter = function userFilter(ctx) {\n    if (hooks.filter) {\n      return hooks.filter(simplifyActionContext(ctx));\n    }\n\n    return true;\n  };\n\n  var resumeSuspendSupport = !!hooks.onResume || !!hooks.onSuspend;\n\n  var filter = function filter(ctx) {\n    if (ctx.type === ActionContextActionType.Sync) {\n      // start and finish is on the same context\n      var accepted = userFilter(ctx);\n\n      if (accepted) {\n        setCtxData(ctx, {\n          startAccepted: true,\n          state: \"idle\"\n        });\n      }\n\n      return accepted;\n    } else {\n      switch (ctx.asyncStepType) {\n        case ActionContextAsyncStepType.Spawn:\n          var _accepted = userFilter(ctx);\n\n          if (_accepted) {\n            setCtxData(ctx, {\n              startAccepted: true,\n              state: \"idle\"\n            });\n          }\n\n          return _accepted;\n\n        case ActionContextAsyncStepType.Return:\n        case ActionContextAsyncStepType.Throw:\n          // depends if the spawn one was accepted or not\n          var data = getCtxData(ctx.spawnAsyncStepContext);\n          return data ? data.startAccepted : false;\n\n        case ActionContextAsyncStepType.Resume:\n        case ActionContextAsyncStepType.ResumeError:\n          if (!resumeSuspendSupport) {\n            return false;\n          } else {\n            // depends if the spawn one was accepted or not\n            var _data = getCtxData(ctx.spawnAsyncStepContext);\n\n            return _data ? _data.startAccepted : false;\n          }\n\n        default:\n          return false;\n      }\n    }\n  };\n\n  var start = function start(simpleCtx) {\n    setCtxData(simpleCtx, {\n      state: \"started\"\n    });\n\n    if (hooks.onStart) {\n      return hooks.onStart(simpleCtx) || undefined;\n    }\n\n    return undefined;\n  };\n\n  var finish = function finish(simpleCtx, ret) {\n    // fakely resume and suspend the parent if needed\n    var parentCtx = simpleCtx.parentContext;\n    var parentResumed = false;\n\n    if (parentCtx) {\n      var parentData = getCtxData(parentCtx);\n\n      if (parentData && parentData.startAccepted && parentData.state === \"suspended\") {\n        parentResumed = true;\n        resume(parentCtx, false);\n      }\n    }\n\n    setCtxData(simpleCtx, {\n      state: \"finished\"\n    });\n\n    if (hooks.onFinish) {\n      ret = hooks.onFinish(simpleCtx, ret) || ret;\n    }\n\n    if (parentResumed) {\n      suspend(parentCtx);\n    }\n\n    return ret;\n  };\n\n  var resume = function resume(simpleCtx, real) {\n    // ensure parents are resumed\n    var parentCtx = simpleCtx.parentContext;\n\n    if (parentCtx) {\n      var parentData = getCtxData(parentCtx);\n\n      if (parentData && parentData.startAccepted && parentData.state === \"suspended\") {\n        resume(parentCtx, false);\n      }\n    }\n\n    setCtxData(simpleCtx, {\n      state: real ? \"realResumed\" : \"fakeResumed\"\n    });\n\n    if (hooks.onResume) {\n      hooks.onResume(simpleCtx);\n    }\n  };\n\n  var suspend = function suspend(simpleCtx) {\n    setCtxData(simpleCtx, {\n      state: \"suspended\"\n    });\n\n    if (hooks.onSuspend) {\n      hooks.onSuspend(simpleCtx);\n    } // ensure parents are suspended if they were fakely resumed\n\n\n    var parentCtx = simpleCtx.parentContext;\n\n    if (parentCtx) {\n      var parentData = getCtxData(parentCtx);\n\n      if (parentData && parentData.startAccepted && parentData.state === \"fakeResumed\") {\n        suspend(parentCtx);\n      }\n    }\n  };\n\n  var mware = function mware(ctx, next) {\n    var simpleCtx = simplifyActionContext(ctx);\n    var origNext = next;\n\n    next = function next() {\n      resume(simpleCtx, true);\n\n      try {\n        return origNext();\n      } finally {\n        suspend(simpleCtx);\n      }\n    };\n\n    if (ctx.type === ActionContextActionType.Sync) {\n      var retObj = start(simpleCtx);\n\n      if (retObj) {\n        // action cancelled / overriden by onStart\n        resume(simpleCtx, true);\n        suspend(simpleCtx);\n        retObj = finish(simpleCtx, retObj);\n      } else {\n        try {\n          retObj = finish(simpleCtx, {\n            result: ActionTrackingResult.Return,\n            value: next()\n          });\n        } catch (err) {\n          retObj = finish(simpleCtx, {\n            result: ActionTrackingResult.Throw,\n            value: err\n          });\n        }\n      }\n\n      return returnOrThrowActionTrackingReturn(retObj);\n    } else {\n      // async\n      switch (ctx.asyncStepType) {\n        case ActionContextAsyncStepType.Spawn:\n          {\n            var _retObj = start(simpleCtx);\n\n            if (_retObj) {\n              // action cancelled / overriden by onStart\n              resume(simpleCtx, true);\n              suspend(simpleCtx);\n              _retObj = finish(simpleCtx, _retObj);\n              return returnOrThrowActionTrackingReturn(_retObj);\n            } else {\n              return next();\n            }\n          }\n\n        case ActionContextAsyncStepType.Return:\n          {\n            var flowFinisher = next();\n\n            var _retObj2 = finish(simpleCtx, {\n              result: ActionTrackingResult.Return,\n              value: flowFinisher.value\n            });\n\n            flowFinisher.resolution = _retObj2.result === ActionTrackingResult.Return ? \"accept\" : \"reject\";\n            flowFinisher.value = _retObj2.value;\n            return flowFinisher;\n          }\n\n        case ActionContextAsyncStepType.Throw:\n          {\n            var _flowFinisher = next();\n\n            var _retObj3 = finish(simpleCtx, {\n              result: ActionTrackingResult.Throw,\n              value: _flowFinisher.value\n            });\n\n            _flowFinisher.resolution = _retObj3.result === ActionTrackingResult.Return ? \"accept\" : \"reject\";\n            _flowFinisher.value = _retObj3.value;\n            return _flowFinisher;\n          }\n\n        case ActionContextAsyncStepType.Resume:\n        case ActionContextAsyncStepType.ResumeError:\n          if (resumeSuspendSupport) {\n            return next();\n          } else {\n            throw failure(\"asssertion error: async step should have been filtered out - \" + ctx.asyncStepType);\n          }\n\n        default:\n          throw failure(\"asssertion error: async step should have been filtered out - \" + ctx.asyncStepType);\n      }\n    }\n  };\n\n  return addActionMiddleware({\n    middleware: mware,\n    filter: filter,\n    subtreeRoot: subtreeRoot\n  });\n}\n\nfunction returnOrThrowActionTrackingReturn(retObj) {\n  if (retObj.result === ActionTrackingResult.Return) {\n    return retObj.value;\n  } else {\n    throw retObj.value;\n  }\n}\n\nvar simpleDataContextSymbol = /*#__PURE__*/Symbol(\"simpleDataContext\");\n/**\r\n * Simplifies an action context by converting an async call hierarchy into a simpler one.\r\n *\r\n * @param ctx Action context to convert.\r\n * @returns Simplified action context.\r\n */\n\nfunction simplifyActionContext(ctx) {\n  while (ctx.previousAsyncStepContext) {\n    ctx = ctx.previousAsyncStepContext;\n  }\n\n  var simpleCtx = ctx.data[simpleDataContextSymbol];\n\n  if (!simpleCtx) {\n    var parentContext = ctx.parentContext ? simplifyActionContext(ctx.parentContext) : undefined;\n    simpleCtx = {\n      actionName: ctx.actionName,\n      type: ctx.type,\n      target: ctx.target,\n      args: ctx.args,\n      data: ctx.data,\n      parentContext: parentContext\n    };\n    simpleCtx.rootContext = parentContext ? parentContext.rootContext : simpleCtx;\n    ctx.data[simpleDataContextSymbol] = simpleCtx;\n  }\n\n  return simpleCtx;\n}\n\n/**\r\n * Attaches an action middleware that invokes a listener for all actions of a given tree.\r\n * Note that the listener will only be invoked for the topmost level actions, so it won't run for child actions or intermediary flow steps.\r\n * Also it won't trigger the listener for calls to hooks such as `onAttachedToRootStore` or its returned disposer.\r\n *\r\n * Its main use is to keep track of top level actions that can be later replicated via `applyAction` somewhere else (another machine, etc.).\r\n *\r\n * There are two kind of possible listeners, `onStart` and `onFinish` listeners.\r\n * `onStart` listeners are called before the action executes and allow cancellation by returning a new return value (which might be a return or a throw).\r\n * `onFinish` listeners are called after the action executes, have access to the action actual return value and allow overriding by returning a\r\n * new return value (which might be a return or a throw).\r\n *\r\n * If you want to ensure that the actual action calls are serializable you should use either `serializeActionCallArgument` over the arguments\r\n * or `serializeActionCall` over the whole action before sending the action call over the wire / storing them .\r\n *\r\n * @param subtreeRoot Subtree root target object.\r\n * @param listeners Listener functions that will be invoked everytime a topmost action is invoked on the model or any children.\r\n * @returns The middleware disposer.\r\n */\n\nfunction onActionMiddleware(subtreeRoot, listeners) {\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\");\n  assertIsObject(listeners, \"listeners\");\n  return actionTrackingMiddleware(subtreeRoot, {\n    filter: function filter(ctx) {\n      if (ctx.parentContext) {\n        // sub-action, do nothing\n        return false;\n      } // skip hooks\n\n\n      if (isHookAction(ctx.actionName)) {\n        return false;\n      }\n\n      return true;\n    },\n    onStart: function onStart(ctx) {\n      if (listeners.onStart) {\n        var actionCall = actionContextToActionCall(ctx);\n        return listeners.onStart(actionCall, ctx);\n      }\n    },\n    onFinish: function onFinish(ctx, ret) {\n      if (listeners.onFinish) {\n        var actionCall = actionContextToActionCall(ctx);\n        return listeners.onFinish(actionCall, ctx, ret);\n      }\n    }\n  });\n}\n\nfunction actionContextToActionCall(ctx) {\n  var rootPath = fastGetRootPath(ctx.target);\n  return {\n    actionName: ctx.actionName,\n    args: ctx.args,\n    targetPath: rootPath.path,\n    targetPathIds: rootPathToTargetPathIds(rootPath)\n  };\n}\n\n/**\r\n * Attaches an action middleware that will throw when any action is started\r\n * over the node or any of the child nodes, thus effectively making the subtree\r\n * readonly.\r\n *\r\n * It will return an object with a `dispose` function to remove the middleware and a `allowWrite` function\r\n * that will allow actions to be started inside the provided code block.\r\n *\r\n * Example:\r\n * ```ts\r\n * // given a model instance named todo\r\n * const { dispose, allowWrite } = readonlyMiddleware(todo)\r\n *\r\n * // this will throw\r\n * todo.setDone(false)\r\n * await todo.setDoneAsync(false)\r\n *\r\n * // this will work\r\n * allowWrite(() => todo.setDone(false))\r\n * // note: for async always use one action invocation per allowWrite!\r\n * await allowWrite(() => todo.setDoneAsync(false))\r\n * ```\r\n *\r\n * @param subtreeRoot Subtree root target object.\r\n * @returns An object with the middleware disposer (`dispose`) and a `allowWrite` function.\r\n */\n\nfunction readonlyMiddleware(subtreeRoot) {\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\");\n  var writable = false;\n  var writableSymbol = Symbol(\"writable\");\n  var disposer = actionTrackingMiddleware(subtreeRoot, {\n    filter: function filter(ctx) {\n      // skip hooks\n      if (isHookAction(ctx.actionName)) {\n        return false;\n      } // if we are inside allowWrite it is writable\n\n\n      var currentlyWritable = writable;\n\n      if (!currentlyWritable) {\n        // if a parent context was writable then the child should be as well\n        var currentCtx = ctx;\n\n        while (currentCtx && !currentlyWritable) {\n          currentlyWritable = !!currentCtx.data[writableSymbol];\n          currentCtx = currentCtx.parentContext;\n        }\n      }\n\n      if (currentlyWritable) {\n        ctx.data[writableSymbol] = true;\n        return false;\n      }\n\n      return true;\n    },\n    onStart: function onStart(ctx) {\n      // if we get here (wasn't filtered out) it is not writable\n      return {\n        result: ActionTrackingResult.Throw,\n        value: failure(\"tried to invoke action '\" + ctx.actionName + \"' over a readonly node\")\n      };\n    }\n  });\n  return {\n    dispose: disposer,\n    allowWrite: function allowWrite(fn) {\n      var oldWritable = writable;\n      writable = true;\n\n      try {\n        return fn();\n      } finally {\n        writable = oldWritable;\n      }\n    }\n  };\n}\n\n/**\r\n * Escapes a json pointer path.\r\n *\r\n * @param path The raw pointer\r\n * @return the Escaped path\r\n */\n\nfunction escapePathComponent(path) {\n  if (typeof path === \"number\") {\n    return \"\" + path;\n  }\n\n  if (path.indexOf(\"/\") === -1 && path.indexOf(\"~\") === -1) {\n    return path;\n  }\n\n  return path.replace(/~/g, \"~0\").replace(/\\//g, \"~1\");\n}\n/**\r\n * Unescapes a json pointer path.\r\n *\r\n * @param path The escaped pointer\r\n * @return The unescaped path\r\n */\n\n\nfunction unescapePathComponent(path) {\n  return path.replace(/~1/g, \"/\").replace(/~0/g, \"~\");\n}\n/**\r\n * Converts a path into a JSON pointer.\r\n *\r\n * @param path Path to convert.\r\n * @returns Converted JSON pointer.\r\n */\n\n\nfunction pathToJsonPointer(path) {\n  if (path.length <= 0) {\n    return \"\";\n  }\n\n  return \"/\" + path.map(escapePathComponent).join(\"/\");\n}\n/**\r\n * Converts a JSON pointer into a path.\r\n *\r\n * @param jsonPointer JSON pointer to convert.\r\n * @returns Converted path.\r\n */\n\nfunction jsonPointerToPath(jsonPointer) {\n  if (jsonPointer === \"\") {\n    return [];\n  }\n\n  if (!jsonPointer.startsWith(\"/\")) {\n    throw failure(\"a JSON pointer must start with '/' or be empty\");\n  }\n\n  jsonPointer = jsonPointer.slice(1);\n  return jsonPointer.split(\"/\").map(unescapePathComponent);\n}\n/**\r\n * Convert a patch into a JSON patch.\r\n *\r\n * @param patch A patch.\r\n * @returns A JSON patch.\r\n */\n\nfunction patchToJsonPatch(patch) {\n  return _extends({}, patch, {\n    path: pathToJsonPointer(patch.path)\n  });\n}\n/**\r\n * Converts a JSON patch into a patch.\r\n *\r\n * @param jsonPatch A JSON patch.\r\n * @returns A patch.\r\n */\n\nfunction jsonPatchToPatch(jsonPatch) {\n  return _extends({}, jsonPatch, {\n    path: jsonPointerToPath(jsonPatch.path)\n  });\n}\n\n/**\r\n * Creates a patch recorder.\r\n *\r\n * @param subtreeRoot\r\n * @param [opts]\r\n * @returns The patch recorder.\r\n */\n\nfunction patchRecorder(subtreeRoot, opts) {\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\");\n  return internalPatchRecorder(subtreeRoot, opts);\n}\n/**\r\n * @ignore\r\n * @internal\r\n *\r\n * Creates a global or local patch recorder.\r\n *\r\n * @param subtreeRoot\r\n * @param [opts]\r\n * @returns The patch recorder.\r\n */\n\nfunction internalPatchRecorder(subtreeRoot, opts) {\n  var _recording$filter$opt = _extends({\n    recording: true,\n    filter: alwaysAcceptFilter\n  }, opts),\n      recording = _recording$filter$opt.recording,\n      filter = _recording$filter$opt.filter;\n\n  var events = observable.array([], {\n    deep: false\n  });\n  var onPatchesDisposer;\n\n  if (subtreeRoot) {\n    onPatchesDisposer = onPatches(subtreeRoot, function (p, invP) {\n      if (recording && filter(p, invP)) {\n        events.push({\n          target: subtreeRoot,\n          patches: p,\n          inversePatches: invP\n        });\n        opts == null ? void 0 : opts.onPatches == null ? void 0 : opts.onPatches(p, invP);\n      }\n    });\n  } else {\n    onPatchesDisposer = onGlobalPatches(function (target, p, invP) {\n      if (recording && filter(p, invP)) {\n        events.push({\n          target: target,\n          patches: p,\n          inversePatches: invP\n        });\n        opts == null ? void 0 : opts.onPatches == null ? void 0 : opts.onPatches(p, invP);\n      }\n    });\n  }\n\n  return {\n    get recording() {\n      return recording;\n    },\n\n    set recording(enabled) {\n      recording = enabled;\n    },\n\n    get events() {\n      return events;\n    },\n\n    dispose: function dispose() {\n      onPatchesDisposer();\n    }\n  };\n}\n\nvar alwaysAcceptFilter = function alwaysAcceptFilter() {\n  return true;\n};\n\n/**\r\n * Creates a transaction middleware, which reverts changes made by an action / child\r\n * actions when the root action throws an exception by applying inverse patches.\r\n *\r\n * @typeparam M Model\r\n * @param target Object with the root target model object (`model`) and root action name (`actionName`).\r\n * @returns The middleware disposer.\r\n */\n\nfunction transactionMiddleware(target) {\n  assertIsObject(target, \"target\");\n  var model = target.model,\n      actionName = target.actionName;\n  assertIsModel(model, \"target.model\");\n\n  if (typeof actionName !== \"string\") {\n    throw failure(\"target.actionName must be a string\");\n  }\n\n  var patchRecorderSymbol = Symbol(\"patchRecorder\");\n\n  function initPatchRecorder(ctx) {\n    ctx.rootContext.data[patchRecorderSymbol] = internalPatchRecorder(undefined, {\n      recording: false\n    });\n  }\n\n  function getPatchRecorder(ctx) {\n    return ctx.rootContext.data[patchRecorderSymbol];\n  }\n\n  return actionTrackingMiddleware(model, {\n    filter: function filter(ctx) {\n      // the primary action must be on the root object\n      var rootContext = ctx.rootContext;\n      return rootContext.target === model && rootContext.actionName === actionName;\n    },\n    onStart: function onStart(ctx) {\n      if (ctx === ctx.rootContext) {\n        initPatchRecorder(ctx);\n      }\n    },\n    onResume: function onResume(ctx) {\n      getPatchRecorder(ctx).recording = true;\n    },\n    onSuspend: function onSuspend(ctx) {\n      getPatchRecorder(ctx).recording = false;\n    },\n    onFinish: function onFinish(ctx, ret) {\n      if (ctx === ctx.rootContext) {\n        var patchRecorder = getPatchRecorder(ctx);\n\n        try {\n          if (ret.result === ActionTrackingResult.Throw) {\n            // undo changes (backwards for inverse patches)\n            var events = patchRecorder.events;\n\n            for (var i = events.length - 1; i >= 0; i--) {\n              var event = events[i];\n              applyPatches(event.target, event.inversePatches, true);\n            }\n          }\n        } finally {\n          patchRecorder.dispose();\n        }\n      }\n    }\n  });\n}\n/**\r\n * Transaction middleware as a decorator.\r\n *\r\n * @param target\r\n * @param propertyKey\r\n */\n\nfunction transaction(target, propertyKey) {\n  checkModelDecoratorArgs(\"transaction\", target, propertyKey);\n  addModelClassInitializer(target.constructor, function (modelInstance) {\n    transactionMiddleware({\n      model: modelInstance,\n      actionName: propertyKey\n    });\n  });\n}\n\n/**\r\n * A type that represents an array of values of a given type.\r\n *\r\n * Example:\r\n * ```ts\r\n * const numberArrayType = types.array(types.number)\r\n * ```\r\n *\r\n * @typeparam T Item type.\r\n * @param itemType Type of inner items.\r\n * @returns\r\n */\n\nfunction typesArray(itemType) {\n  var typeInfoGen = function typeInfoGen(t) {\n    return new ArrayTypeInfo(t, resolveStandardType(itemType));\n  };\n\n  return lateTypeChecker(function () {\n    var itemChecker = resolveTypeChecker(itemType);\n\n    var getTypeName = function getTypeName() {\n      for (var _len = arguments.length, recursiveTypeCheckers = new Array(_len), _key = 0; _key < _len; _key++) {\n        recursiveTypeCheckers[_key] = arguments[_key];\n      }\n\n      return \"Array<\" + itemChecker.getTypeName.apply(itemChecker, recursiveTypeCheckers.concat([itemChecker])) + \">\";\n    };\n\n    var thisTc = new TypeChecker(function (array, path) {\n      if (!isArray(array)) {\n        return new TypeCheckError(path, getTypeName(thisTc), array);\n      }\n\n      if (!itemChecker.unchecked) {\n        for (var i = 0; i < array.length; i++) {\n          var itemError = itemChecker.check(array[i], [].concat(path, [i]));\n\n          if (itemError) {\n            return itemError;\n          }\n        }\n      }\n\n      return null;\n    }, getTypeName, typeInfoGen);\n    return thisTc;\n  }, typeInfoGen);\n}\n/**\r\n * `types.array` type info.\r\n */\n\nvar ArrayTypeInfo = /*#__PURE__*/function (_TypeInfo) {\n  _inheritsLoose(ArrayTypeInfo, _TypeInfo);\n\n  _createClass(ArrayTypeInfo, [{\n    key: \"itemTypeInfo\",\n    get: function get() {\n      return getTypeInfo(this.itemType);\n    }\n  }]);\n\n  function ArrayTypeInfo(thisType, itemType) {\n    var _this;\n\n    _this = _TypeInfo.call(this, thisType) || this;\n    _this.itemType = void 0;\n    _this.itemType = itemType;\n    return _this;\n  }\n\n  return ArrayTypeInfo;\n}(TypeInfo);\n\nfunction tProp(typeOrDefaultValue, arg1, arg2) {\n  var def;\n  var opts = {};\n  var hasDefaultValue = false;\n\n  switch (typeof typeOrDefaultValue) {\n    case \"string\":\n      return tProp(typesString, typeOrDefaultValue, arg1);\n\n    case \"number\":\n      return tProp(typesNumber, typeOrDefaultValue, arg1);\n\n    case \"boolean\":\n      return tProp(typesBoolean, typeOrDefaultValue, arg1);\n  }\n\n  if (arguments.length >= 3) {\n    // type, default, options\n    def = arg1;\n    hasDefaultValue = true;\n    opts = _extends({}, arg2);\n  } else if (arguments.length === 2) {\n    // type, default | options\n    if (isObject(arg1)) {\n      // options\n      opts = _extends({}, arg1);\n    } else {\n      // default\n      def = arg1;\n      hasDefaultValue = true;\n    }\n  }\n\n  var isDefFn = typeof def === \"function\";\n  return {\n    $propValueType: null,\n    $propCreationValueType: null,\n    $isOptional: null,\n    $instanceValueType: null,\n    $instanceCreationValueType: null,\n    defaultFn: hasDefaultValue && isDefFn ? def : noDefaultValue,\n    defaultValue: hasDefaultValue && !isDefFn ? def : noDefaultValue,\n    typeChecker: resolveStandardType(typeOrDefaultValue),\n    transform: undefined,\n    options: opts\n  };\n}\n\n/**\r\n * Store model instance for undo/redo actions.\r\n * Do not manipulate directly, other that creating it.\r\n */\n\nvar UndoStore = /*#__PURE__*/function (_Model) {\n  _inheritsLoose(UndoStore, _Model);\n\n  function UndoStore() {\n    return _Model.apply(this, arguments) || this;\n  }\n\n  var _proto = UndoStore.prototype;\n\n  /**\r\n   * @ignore\r\n   */\n  _proto._clearUndo = function _clearUndo() {\n    var _this = this;\n\n    withoutUndo(function () {\n      _this.undoEvents.length = 0;\n    });\n  }\n  /**\r\n   * @ignore\r\n   */\n  ;\n\n  _proto._clearRedo = function _clearRedo() {\n    var _this2 = this;\n\n    withoutUndo(function () {\n      _this2.redoEvents.length = 0;\n    });\n  }\n  /**\r\n   * @ignore\r\n   */\n  ;\n\n  _proto._undo = function _undo() {\n    var _this3 = this;\n\n    withoutUndo(function () {\n      var event = _this3.undoEvents.pop();\n\n      _this3.redoEvents.push(event);\n    });\n  }\n  /**\r\n   * @ignore\r\n   */\n  ;\n\n  _proto._redo = function _redo() {\n    var _this4 = this;\n\n    withoutUndo(function () {\n      var event = _this4.redoEvents.pop();\n\n      _this4.undoEvents.push(event);\n    });\n  }\n  /**\r\n   * @ignore\r\n   */\n  ;\n\n  _proto._addUndo = function _addUndo(event) {\n    var _this5 = this;\n\n    withoutUndo(function () {\n      _this5.undoEvents.push(event); // once an undo event is added redo queue is no longer valid\n\n\n      _this5.redoEvents.length = 0;\n    });\n  };\n\n  return UndoStore;\n}( /*#__PURE__*/Model({\n  // TODO: add proper type checking to undo store\n  undoEvents: /*#__PURE__*/tProp( /*#__PURE__*/typesArray( /*#__PURE__*/typesUnchecked()), function () {\n    return [];\n  }),\n  redoEvents: /*#__PURE__*/tProp( /*#__PURE__*/typesArray( /*#__PURE__*/typesUnchecked()), function () {\n    return [];\n  })\n}));\n\n__decorate([modelAction], UndoStore.prototype, \"_clearUndo\", null);\n\n__decorate([modelAction], UndoStore.prototype, \"_clearRedo\", null);\n\n__decorate([modelAction], UndoStore.prototype, \"_undo\", null);\n\n__decorate([modelAction], UndoStore.prototype, \"_redo\", null);\n\n__decorate([modelAction], UndoStore.prototype, \"_addUndo\", null);\n\nUndoStore = /*#__PURE__*/__decorate([/*#__PURE__*/model(\"mobx-keystone/UndoStore\")], UndoStore);\n/**\r\n * Manager class returned by `undoMiddleware` that allows you to perform undo/redo actions.\r\n */\n\nvar UndoManager = /*#__PURE__*/function () {\n  var _proto2 = UndoManager.prototype;\n\n  /**\r\n   * Clears the undo queue.\r\n   */\n  _proto2.clearUndo = function clearUndo() {\n    this.store._clearUndo();\n  }\n  /**\r\n   * The number of redo actions available.\r\n   */\n  ;\n\n  /**\r\n   * Clears the redo queue.\r\n   */\n  _proto2.clearRedo = function clearRedo() {\n    this.store._clearRedo();\n  }\n  /**\r\n   * Undoes the last action.\r\n   * Will throw if there is no action to undo.\r\n   */\n  ;\n\n  _proto2.undo = function undo() {\n    var _this6 = this;\n\n    if (!this.canUndo) {\n      throw failure(\"nothing to undo\");\n    }\n\n    var event = this.undoQueue[this.undoQueue.length - 1];\n    withoutUndo(function () {\n      applyPatches(_this6.subtreeRoot, event.inversePatches, true);\n    });\n\n    this.store._undo();\n  }\n  /**\r\n   * Redoes the previous action.\r\n   * Will throw if there is no action to redo.\r\n   */\n  ;\n\n  _proto2.redo = function redo() {\n    var _this7 = this;\n\n    if (!this.canRedo) {\n      throw failure(\"nothing to redo\");\n    }\n\n    var event = this.redoQueue[this.redoQueue.length - 1];\n    withoutUndo(function () {\n      applyPatches(_this7.subtreeRoot, event.patches);\n    });\n\n    this.store._redo();\n  }\n  /**\r\n   * Disposes the undo middleware.\r\n   */\n  ;\n\n  _proto2.dispose = function dispose() {\n    this.disposer();\n  }\n  /**\r\n   * Creates an instance of `UndoManager`.\r\n   * Do not use directly, use `undoMiddleware` instead.\r\n   *\r\n   * @param disposer\r\n   * @param subtreeRoot\r\n   * @param [store]\r\n   */\n  ;\n\n  _createClass(UndoManager, [{\n    key: \"undoQueue\",\n\n    /**\r\n     * The store currently being used to store undo/redo action events.\r\n     */\n\n    /**\r\n     * The undo stack, where the first operation to undo will be the last of the array.\r\n     * Do not manipulate this array directly.\r\n     */\n    get: function get() {\n      return this.store.undoEvents;\n    }\n    /**\r\n     * The redo stack, where the first operation to redo will be the last of the array.\r\n     * Do not manipulate this array directly.\r\n     */\n\n  }, {\n    key: \"redoQueue\",\n    get: function get() {\n      return this.store.redoEvents;\n    }\n    /**\r\n     * The number of undo actions available.\r\n     */\n\n  }, {\n    key: \"undoLevels\",\n    get: function get() {\n      return this.undoQueue.length;\n    }\n    /**\r\n     * If undo can be performed (if there is at least one undo action available).\r\n     */\n\n  }, {\n    key: \"canUndo\",\n    get: function get() {\n      return this.undoLevels > 0;\n    }\n  }, {\n    key: \"redoLevels\",\n    get: function get() {\n      return this.redoQueue.length;\n    }\n    /**\r\n     * If redo can be performed (if there is at least one redo action available)\r\n     */\n\n  }, {\n    key: \"canRedo\",\n    get: function get() {\n      return this.redoLevels > 0;\n    }\n  }]);\n\n  function UndoManager(disposer, subtreeRoot, store) {\n    this.disposer = void 0;\n    this.subtreeRoot = void 0;\n    this.store = void 0;\n    this.disposer = disposer;\n    this.subtreeRoot = subtreeRoot;\n\n    if (getMobxVersion() >= 6) {\n      mobx6.makeObservable(this);\n    }\n\n    this.store = store != null ? store : new UndoStore({});\n  }\n\n  return UndoManager;\n}();\n\n__decorate([computed], UndoManager.prototype, \"undoQueue\", null);\n\n__decorate([computed], UndoManager.prototype, \"redoQueue\", null);\n\n__decorate([computed], UndoManager.prototype, \"undoLevels\", null);\n\n__decorate([computed], UndoManager.prototype, \"canUndo\", null);\n\n__decorate([action], UndoManager.prototype, \"clearUndo\", null);\n\n__decorate([computed], UndoManager.prototype, \"redoLevels\", null);\n\n__decorate([computed], UndoManager.prototype, \"canRedo\", null);\n\n__decorate([action], UndoManager.prototype, \"clearRedo\", null);\n\n__decorate([action], UndoManager.prototype, \"undo\", null);\n\n__decorate([action], UndoManager.prototype, \"redo\", null);\n/**\r\n * Creates an undo middleware.\r\n *\r\n * @param subtreeRoot Subtree root target object.\r\n * @param [store] Optional `UndoStore` where to store the undo/redo queues. Use this if you want to\r\n * store such queues somewhere in your models. If none is provided it will reside in memory.\r\n * @returns An `UndoManager` which allows you to do the manage the undo/redo operations and dispose of the middleware.\r\n */\n\n\nfunction undoMiddleware(subtreeRoot, store) {\n  assertTweakedObject(subtreeRoot, \"subtreeRoot\");\n  var patchRecorderSymbol = Symbol(\"patchRecorder\");\n\n  function initPatchRecorder(ctx) {\n    ctx.rootContext.data[patchRecorderSymbol] = {\n      recorder: patchRecorder(subtreeRoot, {\n        recording: false,\n        filter: undoDisabledFilter\n      }),\n      recorderStack: 0,\n      undoRootContext: ctx\n    };\n  }\n\n  function getPatchRecorderData(ctx) {\n    return ctx.rootContext.data[patchRecorderSymbol];\n  }\n\n  var manager;\n  var middlewareDisposer = actionTrackingMiddleware(subtreeRoot, {\n    onStart: function onStart(ctx) {\n      if (!getPatchRecorderData(ctx)) {\n        initPatchRecorder(ctx);\n      }\n    },\n    onResume: function onResume(ctx) {\n      var patchRecorderData = getPatchRecorderData(ctx);\n      patchRecorderData.recorderStack++;\n      patchRecorderData.recorder.recording = patchRecorderData.recorderStack > 0;\n    },\n    onSuspend: function onSuspend(ctx) {\n      var patchRecorderData = getPatchRecorderData(ctx);\n      patchRecorderData.recorderStack--;\n      patchRecorderData.recorder.recording = patchRecorderData.recorderStack > 0;\n    },\n    onFinish: function onFinish(ctx) {\n      var patchRecorderData = getPatchRecorderData(ctx);\n\n      if (patchRecorderData && patchRecorderData.undoRootContext === ctx) {\n        var _patchRecorder = patchRecorderData.recorder;\n\n        if (_patchRecorder.events.length > 0) {\n          var patches = [];\n          var inversePatches = [];\n\n          for (var _iterator = _createForOfIteratorHelperLoose(_patchRecorder.events), _step; !(_step = _iterator()).done;) {\n            var event = _step.value;\n            patches.push.apply(patches, event.patches);\n            inversePatches.push.apply(inversePatches, event.inversePatches);\n          }\n\n          manager.store._addUndo({\n            targetPath: fastGetRootPath(ctx.target).path,\n            actionName: ctx.actionName,\n            patches: patches,\n            inversePatches: inversePatches\n          });\n        }\n\n        _patchRecorder.dispose();\n      }\n    }\n  });\n  manager = new UndoManager(middlewareDisposer, subtreeRoot, store);\n  return manager;\n}\nvar undoDisabled = false;\n\nvar undoDisabledFilter = function undoDisabledFilter() {\n  return !undoDisabled;\n};\n/**\r\n * Skips the undo recording mechanism for the code block that gets run synchronously inside.\r\n *\r\n * @typeparam T\r\n * @param fn\r\n * @returns\r\n */\n\n\nfunction withoutUndo(fn) {\n  var savedUndoDisabled = undoDisabled;\n  undoDisabled = true;\n\n  try {\n    return fn();\n  } finally {\n    undoDisabled = savedUndoDisabled;\n  }\n}\n\nfunction getContextValue(contextValue) {\n  if (contextValue.type === \"value\") {\n    return contextValue.value;\n  } else {\n    return contextValue.value.get();\n  }\n}\n\nvar ContextClass = /*#__PURE__*/function () {\n  var _proto = ContextClass.prototype;\n\n  _proto.getNodeAtom = function getNodeAtom(node) {\n    var atomPerNode = this.nodeAtom.get(node);\n\n    if (!atomPerNode) {\n      atomPerNode = createAtom(\"contextValue\");\n      this.nodeAtom.set(node, atomPerNode);\n    }\n\n    return atomPerNode;\n  };\n\n  _proto.fastGet = function fastGet(node) {\n    this.getNodeAtom(node).reportObserved();\n    var obsForNode = this.nodeContextValue.get(node);\n\n    if (obsForNode) {\n      return getContextValue(obsForNode);\n    }\n\n    var parent = fastGetParent(node);\n\n    if (!parent) {\n      return this.getDefault();\n    }\n\n    return this.fastGet(parent);\n  };\n\n  _proto.get = function get(node) {\n    assertTweakedObject(node, \"node\");\n    return this.fastGet(node);\n  };\n\n  _proto.fastGetProviderNode = function fastGetProviderNode(node) {\n    this.getNodeAtom(node).reportObserved();\n    var obsForNode = this.nodeContextValue.get(node);\n\n    if (obsForNode) {\n      return node;\n    }\n\n    var parent = fastGetParent(node);\n\n    if (!parent) {\n      return undefined;\n    }\n\n    return this.fastGetProviderNode(parent);\n  };\n\n  _proto.getProviderNode = function getProviderNode(node) {\n    assertTweakedObject(node, \"node\");\n    return this.fastGetProviderNode(node);\n  };\n\n  _proto.getDefault = function getDefault() {\n    return getContextValue(this.defaultContextValue);\n  };\n\n  _proto.setDefault = function setDefault(value) {\n    this.defaultContextValue = {\n      type: \"value\",\n      value: value\n    };\n  };\n\n  _proto.setDefaultComputed = function setDefaultComputed(valueFn) {\n    this.defaultContextValue = {\n      type: \"computed\",\n      value: computed(valueFn)\n    };\n  };\n\n  _proto.set = function set(node, value) {\n    assertTweakedObject(node, \"node\");\n    this.nodeContextValue.set(node, {\n      type: \"value\",\n      value: value\n    });\n    this.getNodeAtom(node).reportChanged();\n  };\n\n  _proto.setComputed = function setComputed(node, valueFn) {\n    assertTweakedObject(node, \"node\");\n    this.nodeContextValue.set(node, {\n      type: \"computed\",\n      value: computed(valueFn)\n    });\n    this.getNodeAtom(node).reportChanged();\n  };\n\n  _proto.unset = function unset(node) {\n    assertTweakedObject(node, \"node\");\n    this.nodeContextValue[\"delete\"](node);\n    this.getNodeAtom(node).reportChanged();\n  };\n\n  function ContextClass(defaultValue) {\n    this.defaultContextValue = void 0;\n    this.nodeContextValue = new WeakMap();\n    this.nodeAtom = new WeakMap();\n\n    if (getMobxVersion() >= 6) {\n      mobx6.makeObservable(this);\n    }\n\n    this.setDefault(defaultValue);\n  }\n\n  return ContextClass;\n}();\n\n__decorate([observable.ref], ContextClass.prototype, \"defaultContextValue\", void 0);\n\n__decorate([action], ContextClass.prototype, \"setDefault\", null);\n\n__decorate([action], ContextClass.prototype, \"setDefaultComputed\", null);\n\n__decorate([action], ContextClass.prototype, \"set\", null);\n\n__decorate([action], ContextClass.prototype, \"setComputed\", null);\n\n__decorate([action], ContextClass.prototype, \"unset\", null); // base\n\n\nfunction createContext(defaultValue) {\n  return new ContextClass(defaultValue);\n}\n\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction extendFnModelFlowActions(fnModelObj, namespace, flowActions) {\n  for (var _i = 0, _Object$entries = Object.entries(flowActions); _i < _Object$entries.length; _i++) {\n    var _Object$entries$_i = _Object$entries[_i],\n        name = _Object$entries$_i[0],\n        fn = _Object$entries$_i[1];\n    addActionToFnModel(fnModelObj, namespace, name, fn, true);\n  }\n\n  return fnModelObj;\n}\n\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction extendFnModelSetterActions(fnModelObj, namespace, setterActions) {\n  var _loop = function _loop() {\n    var _Object$entries$_i = _Object$entries[_i],\n        name = _Object$entries$_i[0],\n        fieldName = _Object$entries$_i[1];\n\n    // make strings setters\n    var fn = function fn(value) {\n      this[fieldName] = value;\n    };\n\n    addActionToFnModel(fnModelObj, namespace, name, fn, false);\n  };\n\n  for (var _i = 0, _Object$entries = Object.entries(setterActions); _i < _Object$entries.length; _i++) {\n    _loop();\n  }\n\n  return fnModelObj;\n}\n\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction extendFnModelViews(fnModelObj, views) {\n  var _loop = function _loop() {\n    var _Object$entries$_i = _Object$entries[_i],\n        name = _Object$entries$_i[0],\n        fnOrFnWithOptions = _Object$entries$_i[1];\n    assertFnModelKeyNotInUse(fnModelObj, name);\n    var computedsPerObject = new WeakMap();\n    var fn = void 0;\n    var equals = void 0;\n\n    if (typeof fnOrFnWithOptions === \"function\") {\n      fn = fnOrFnWithOptions;\n    } else {\n      fn = fnOrFnWithOptions.get;\n      equals = fnOrFnWithOptions.equals;\n    }\n\n    fnModelObj[name] = function (target) {\n      var computedFn = computedsPerObject.get(target);\n\n      if (!computedFn) {\n        computedFn = computed(fn, {\n          name: name,\n          context: target,\n          equals: equals\n        });\n        computedsPerObject.set(target, computedFn);\n      }\n\n      return computedFn.get();\n    };\n  };\n\n  for (var _i = 0, _Object$entries = Object.entries(views); _i < _Object$entries.length; _i++) {\n    _loop();\n  }\n\n  return fnModelObj;\n}\n\nfunction fnModel(arg1, arg2) {\n  var actualType = arguments.length >= 2 ? arg1 : null;\n  var namespace = arguments.length >= 2 ? arg2 : arg1;\n  assertIsString(namespace, \"namespace\");\n  var fnModelObj = {\n    create: actualType ? fnModelCreateWithType.bind(undefined, actualType) : fnModelCreateWithoutType,\n    type: actualType\n  };\n  fnModelObj.views = extendFnModelViews.bind(undefined, fnModelObj);\n  fnModelObj.actions = extendFnModelActions.bind(undefined, fnModelObj, namespace);\n  fnModelObj.flowActions = extendFnModelFlowActions.bind(undefined, fnModelObj, namespace);\n  fnModelObj.setterActions = extendFnModelSetterActions.bind(undefined, fnModelObj, namespace);\n  return fnModelObj;\n}\n\nfunction fnModelCreateWithoutType(data) {\n  return toTreeNode(data);\n}\n\nfunction fnModelCreateWithType(actualType, data) {\n  if (isModelAutoTypeCheckingEnabled()) {\n    var errors = typeCheck(actualType, data);\n\n    if (errors) {\n      errors[\"throw\"](data);\n    }\n  }\n\n  return toTreeNode(data);\n}\n\nfunction _splice() {\n  return this.splice.apply(this, arguments);\n}\n\nvar _fnArray = /*#__PURE__*/fnModel(\"mobx-keystone/fnArray\").actions({\n  set: function set$1(index, value) {\n    set(this, index, value);\n  },\n  \"delete\": function _delete(index) {\n    return remove(this, \"\" + index);\n  },\n  setLength: function setLength(length) {\n    this.length = length;\n  },\n  concat: function concat() {\n    return this.concat.apply(this, arguments);\n  },\n  copyWithin: function copyWithin(target, start, end) {\n    return this.copyWithin(target, start, end);\n  },\n  fill: function fill(value, start, end) {\n    return this.fill(value, start, end);\n  },\n  pop: function pop() {\n    return this.pop();\n  },\n  push: function push() {\n    return this.push.apply(this, arguments);\n  },\n  reverse: function reverse() {\n    return this.reverse();\n  },\n  shift: function shift() {\n    return this.shift();\n  },\n  slice: function slice(start, end) {\n    return this.slice(start, end);\n  },\n  sort: function sort(compareFn) {\n    return this.sort(compareFn);\n  },\n  splice: _splice,\n  unshift: function unshift() {\n    return this.unshift.apply(this, arguments);\n  }\n});\n\nvar fnArray = {\n  set: _fnArray.set,\n  \"delete\": _fnArray[\"delete\"],\n  setLength: _fnArray.setLength,\n  concat: _fnArray.concat,\n  copyWithin: _fnArray.copyWithin,\n  fill: _fnArray.fill,\n  pop: _fnArray.pop,\n  push: _fnArray.push,\n  reverse: _fnArray.reverse,\n  shift: _fnArray.shift,\n  slice: _fnArray.slice,\n  sort: _fnArray.sort,\n  splice: _fnArray.splice,\n  unshift: _fnArray.unshift,\n  create: _fnArray.create\n};\n\nvar _fnObject = /*#__PURE__*/fnModel(\"mobx-keystone/fnObject\").actions({\n  set: function set$1(key, value) {\n    set(this, key, value);\n  },\n  assign: function assign(partialObject) {\n    assertIsObject(partialObject, \"partialObject\");\n    var keys = Object.keys(partialObject);\n\n    for (var _i = 0, _keys = keys; _i < _keys.length; _i++) {\n      var key = _keys[_i];\n\n      set(this, key, partialObject[key]);\n    }\n  },\n  \"delete\": function _delete(key) {\n    return remove(this, key);\n  },\n  call: function call(methodName) {\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    return this[methodName].apply(this, args);\n  }\n});\n\nvar fnObject = {\n  set: _fnObject.set,\n  assign: _fnObject.assign,\n  \"delete\": _fnObject[\"delete\"],\n  call: _fnObject.call,\n  create: _fnObject.create\n};\n\nvar Lock = /*#__PURE__*/function () {\n  function Lock() {\n    this._locked = true;\n  }\n\n  var _proto = Lock.prototype;\n\n  _proto.unlockedFn = function unlockedFn(fn) {\n    var _this = this;\n\n    var innerFn = function innerFn() {\n      var oldLocked = _this._locked;\n      _this._locked = false;\n\n      try {\n        return fn.apply(void 0, arguments);\n      } finally {\n        _this._locked = oldLocked;\n      }\n    };\n\n    return innerFn;\n  };\n\n  _proto.withUnlock = function withUnlock(fn) {\n    var oldLocked = this._locked;\n    this._locked = false;\n\n    try {\n      return fn();\n    } finally {\n      this._locked = oldLocked;\n    }\n  };\n\n  _createClass(Lock, [{\n    key: \"isLocked\",\n    get: function get() {\n      return this._locked;\n    }\n  }]);\n\n  return Lock;\n}();\n\n/**\r\n * Creates a tag data accessor for a target object of a certain type.\r\n * Tag data will be lazy created on access and reused for the same target object.\r\n *\r\n * @typeparam Target Target type.\r\n * @typeparam TagData Tag data type.\r\n * @param tagDataConstructor Function that will be called the first time the tag\r\n * for a given object is requested.\r\n * @returns The tag data associated with the target object.\r\n */\nfunction tag(tagDataConstructor) {\n  var map = new WeakMap();\n  return {\n    \"for\": function _for(target) {\n      if (!map.has(target)) {\n        var data = tagDataConstructor(target);\n        map.set(target, data);\n        return data;\n      } else {\n        return map.get(target);\n      }\n    }\n  };\n}\n\nvar observableMapBackedByObservableObject = /*#__PURE__*/action(function (obj) {\n  if (inDevMode()) {\n    if (!isObservableObject(obj)) {\n      throw failure(\"assertion failed: expected an observable object\");\n    }\n  }\n\n  var map = observable.map();\n  map.dataObject = obj;\n  var keys = Object.keys(obj);\n\n  for (var i = 0; i < keys.length; i++) {\n    var k = keys[i];\n    map.set(k, obj[k]);\n  }\n\n  var mutationLock = new Lock(); // when the object changes the map changes\n\n  observe(obj, action(mutationLock.unlockedFn(function (change) {\n    switch (change.type) {\n      case \"add\":\n      case \"update\":\n        {\n          map.set(change.name, change.newValue);\n          break;\n        }\n\n      case \"remove\":\n        {\n          map[\"delete\"](change.name);\n          break;\n        }\n    }\n  }))); // when the map changes also change the object\n\n  intercept(map, action(function (change) {\n    if (!mutationLock.isLocked) {\n      return null; // already changed\n    }\n\n    switch (change.type) {\n      case \"add\":\n      case \"update\":\n        {\n          set(obj, change.name, change.newValue);\n          break;\n        }\n\n      case \"delete\":\n        {\n          remove(obj, change.name);\n          break;\n        }\n    }\n\n    return change;\n  }));\n  return map;\n});\nvar observableMapBackedByObservableArray = /*#__PURE__*/action(function (array) {\n  if (inDevMode()) {\n    if (!isObservableArray(array)) {\n      throw failure(\"assertion failed: expected an observable array\");\n    }\n  }\n\n  var map = observable.map(array);\n  map.dataObject = array;\n\n  if (map.size !== array.length) {\n    throw failure(\"arrays backing a map cannot contain duplicate keys\");\n  }\n\n  var mutationLock = new Lock(); // for speed reasons we will just assume distinct values are only once in the array\n  // also we assume tuples themselves are immutable\n  // when the array changes the map changes\n\n  observe(array, action(mutationLock.unlockedFn(function (change\n  /*IArrayDidChange<[string, T]>*/\n  ) {\n    switch (change.type) {\n      case \"splice\":\n        {\n          {\n            var removed = change.removed;\n\n            for (var i = 0; i < removed.length; i++) {\n              map[\"delete\"](removed[i][0]);\n            }\n          }\n          {\n            var added = change.added;\n\n            for (var _i = 0; _i < added.length; _i++) {\n              map.set(added[_i][0], added[_i][1]);\n            }\n          }\n          break;\n        }\n\n      case \"update\":\n        {\n          map[\"delete\"](change.oldValue[0]);\n          map.set(change.newValue[0], change.newValue[1]);\n          break;\n        }\n    }\n  }))); // when the map changes also change the array\n\n  intercept(map, action(function (change) {\n    if (!mutationLock.isLocked) {\n      return null; // already changed\n    }\n\n    switch (change.type) {\n      case \"update\":\n        {\n          // replace the whole tuple to keep tuple immutability\n          var i = array.findIndex(function (i) {\n            return i[0] === change.name;\n          });\n          array[i] = [change.name, change.newValue];\n          break;\n        }\n\n      case \"add\":\n        {\n          array.push([change.name, change.newValue]);\n          break;\n        }\n\n      case \"delete\":\n        {\n          var _i2 = array.findIndex(function (i) {\n            return i[0] === change.name;\n          });\n\n          if (_i2 >= 0) {\n            array.splice(_i2, 1);\n          }\n\n          break;\n        }\n    }\n\n    return change;\n  }));\n  return map;\n});\nvar asMapTag = /*#__PURE__*/tag(function (objOrArray) {\n  if (isArray(objOrArray)) {\n    assertIsObservableArray(objOrArray, \"objOrArray\");\n    return observableMapBackedByObservableArray(objOrArray);\n  } else {\n    assertIsObservableObject(objOrArray, \"objOrArray\");\n    return observableMapBackedByObservableObject(objOrArray);\n  }\n});\n/**\r\n * Wraps an observable object or a tuple array to offer a map like interface.\r\n *\r\n * @param objOrArray Object or array.\r\n */\n\nfunction asMap(objOrArray) {\n  return asMapTag[\"for\"](objOrArray);\n}\n/**\r\n * Converts a map to an object. If the map is a collection wrapper it will return the backed object.\r\n *\r\n * @param map\r\n */\n\nfunction mapToObject(map) {\n  assertIsMap(map, \"map\");\n  var dataObject = map.dataObject;\n\n  if (dataObject && !isArray(dataObject)) {\n    return dataObject;\n  }\n\n  var obj = {};\n\n  for (var _iterator = _createForOfIteratorHelperLoose(map.keys()), _step; !(_step = _iterator()).done;) {\n    var k = _step.value;\n    obj[k] = map.get(k);\n  }\n\n  return obj;\n}\n/**\r\n * Converts a map to an array. If the map is a collection wrapper it will return the backed array.\r\n *\r\n * @param map\r\n */\n\nfunction mapToArray(map) {\n  assertIsMap(map, \"map\");\n  var dataObject = map.dataObject;\n\n  if (dataObject && isArray(dataObject)) {\n    return dataObject;\n  }\n\n  var arr = [];\n\n  for (var _iterator2 = _createForOfIteratorHelperLoose(map.keys()), _step2; !(_step2 = _iterator2()).done;) {\n    var k = _step2.value;\n    arr.push([k, map.get(k)]);\n  }\n\n  return arr;\n}\n\nvar arrayAsMapInnerTransform = {\n  propToData: function propToData(arr) {\n    return isArray(arr) ? asMap(arr) : arr;\n  },\n  dataToProp: function dataToProp(newMap) {\n    if (!isMap(newMap)) {\n      return newMap;\n    }\n\n    return mapToArray(newMap);\n  }\n};\nfunction prop_mapArray(def) {\n  return transformedProp(prop(def), arrayAsMapInnerTransform, true);\n}\nfunction tProp_mapArray(typeOrDefaultValue, def) {\n  return transformedProp(tProp(typeOrDefaultValue, def), arrayAsMapInnerTransform, true);\n}\n\nvar observableSetBackedByObservableArray = /*#__PURE__*/action(function (array) {\n  if (inDevMode()) {\n    if (!isObservableArray(array)) {\n      throw failure(\"assertion failed: expected an observable array\");\n    }\n  }\n\n  var set = observable.set(array);\n  set.dataObject = array;\n\n  if (set.size !== array.length) {\n    throw failure(\"arrays backing a set cannot contain duplicate values\");\n  }\n\n  var mutationLock = new Lock(); // for speed reasons we will just assume distinct values are only once in the array\n  // when the array changes the set changes\n\n  observe(array, action(mutationLock.unlockedFn(function (change\n  /*IArrayDidChange<T>*/\n  ) {\n    switch (change.type) {\n      case \"splice\":\n        {\n          {\n            var removed = change.removed;\n\n            for (var i = 0; i < removed.length; i++) {\n              set[\"delete\"](removed[i]);\n            }\n          }\n          {\n            var added = change.added;\n\n            for (var _i = 0; _i < added.length; _i++) {\n              set.add(added[_i]);\n            }\n          }\n          break;\n        }\n\n      case \"update\":\n        {\n          set[\"delete\"](change.oldValue);\n          set.add(change.newValue);\n          break;\n        }\n    }\n  }))); // when the set changes also change the array\n\n  intercept(set, action(function (change) {\n    if (!mutationLock.isLocked) {\n      return null; // already changed\n    }\n\n    switch (change.type) {\n      case \"add\":\n        {\n          array.push(change.newValue);\n          break;\n        }\n\n      case \"delete\":\n        {\n          var i = array.indexOf(change.oldValue);\n\n          if (i >= 0) {\n            array.splice(i, 1);\n          }\n\n          break;\n        }\n    }\n\n    return change;\n  }));\n  return set;\n});\nvar asSetTag = /*#__PURE__*/tag(function (array) {\n  assertIsObservableArray(array, \"array\");\n  return observableSetBackedByObservableArray(array);\n});\n/**\r\n * Wraps an observable array to offer a set like interface.\r\n *\r\n * @param array\r\n */\n\nfunction asSet(array) {\n  return asSetTag[\"for\"](array);\n}\n/**\r\n * Converts a set to an array. If the set is a collection wrapper it will return the backed array.\r\n *\r\n * @param set\r\n */\n\nfunction setToArray(set) {\n  assertIsSet(set, \"set\");\n  var dataObject = set.dataObject;\n\n  if (dataObject) {\n    return dataObject;\n  }\n\n  return Array.from(set.values());\n}\n\nvar arrayAsSetInnerTransform = {\n  propToData: function propToData(arr) {\n    return isArray(arr) ? asSet(arr) : arr;\n  },\n  dataToProp: function dataToProp(newSet) {\n    return isSet(newSet) ? setToArray(newSet) : newSet;\n  }\n};\nfunction prop_setArray(def) {\n  return transformedProp(prop(def), arrayAsSetInnerTransform, true);\n}\nfunction tProp_setArray(typeOrDefaultValue, def) {\n  return transformedProp(tProp(typeOrDefaultValue, def), arrayAsSetInnerTransform, true);\n}\n\nvar objectAsMapInnerTransform = {\n  propToData: function propToData(obj) {\n    return isObject(obj) ? asMap(obj) : obj;\n  },\n  dataToProp: function dataToProp(newMap) {\n    if (!isMap(newMap)) {\n      return newMap;\n    }\n\n    return mapToObject(newMap);\n  }\n};\nfunction prop_mapObject(def) {\n  return transformedProp(prop(def), objectAsMapInnerTransform, true);\n}\nfunction tProp_mapObject(typeOrDefaultValue, def) {\n  return transformedProp(tProp(typeOrDefaultValue, def), objectAsMapInnerTransform, true);\n}\n\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction immutableDate(value) {\n  return new InternalImmutableDate(value);\n}\nvar errMessage = \"this Date object is immutable\";\n\nvar InternalImmutableDate = /*#__PURE__*/function (_Date) {\n  _inheritsLoose(InternalImmutableDate, _Date);\n\n  function InternalImmutableDate() {\n    return _Date.apply(this, arguments) || this;\n  }\n\n  var _proto = InternalImmutableDate.prototype;\n\n  // disable mutable methods\n  _proto.setTime = function setTime() {\n    throw failure(errMessage);\n  };\n\n  _proto.setMilliseconds = function setMilliseconds() {\n    throw failure(errMessage);\n  };\n\n  _proto.setUTCMilliseconds = function setUTCMilliseconds() {\n    throw failure(errMessage);\n  };\n\n  _proto.setSeconds = function setSeconds() {\n    throw failure(errMessage);\n  };\n\n  _proto.setUTCSeconds = function setUTCSeconds() {\n    throw failure(errMessage);\n  };\n\n  _proto.setMinutes = function setMinutes() {\n    throw failure(errMessage);\n  };\n\n  _proto.setUTCMinutes = function setUTCMinutes() {\n    throw failure(errMessage);\n  };\n\n  _proto.setHours = function setHours() {\n    throw failure(errMessage);\n  };\n\n  _proto.setUTCHours = function setUTCHours() {\n    throw failure(errMessage);\n  };\n\n  _proto.setDate = function setDate() {\n    throw failure(errMessage);\n  };\n\n  _proto.setUTCDate = function setUTCDate() {\n    throw failure(errMessage);\n  };\n\n  _proto.setMonth = function setMonth() {\n    throw failure(errMessage);\n  };\n\n  _proto.setUTCMonth = function setUTCMonth() {\n    throw failure(errMessage);\n  };\n\n  _proto.setFullYear = function setFullYear() {\n    throw failure(errMessage);\n  };\n\n  _proto.setUTCFullYear = function setUTCFullYear() {\n    throw failure(errMessage);\n  };\n\n  return InternalImmutableDate;\n}( /*#__PURE__*/_wrapNativeSuper(Date));\n\n/**\r\n * Property transform for ISO date strings to Date objects and vice-versa.\r\n * If a model property, consider using `prop_dateString` or `tProp_dateString` instead.\r\n */\n\nvar stringAsDate = /*#__PURE__*/propTransform({\n  propToData: function propToData(prop) {\n    if (typeof prop !== \"string\") {\n      return prop;\n    }\n\n    return immutableDate(prop);\n  },\n  dataToProp: function dataToProp(date) {\n    return date instanceof Date ? date.toJSON() : date;\n  }\n});\nfunction prop_dateString(def) {\n  return transformedProp(prop(def), stringAsDate, true);\n}\nfunction tProp_dateString(typeOrDefaultValue, def) {\n  return transformedProp(tProp(typeOrDefaultValue, def), stringAsDate, true);\n}\n\n/**\r\n * Property transform for number timestamps to Date objects and vice-versa.\r\n * If a model property, consider using `prop_dateTimestamp` or `tProp_dateTimestamp` instead.\r\n */\n\nvar timestampAsDate = /*#__PURE__*/propTransform({\n  propToData: function propToData(prop) {\n    if (typeof prop !== \"number\") {\n      return prop;\n    }\n\n    return immutableDate(prop);\n  },\n  dataToProp: function dataToProp(date) {\n    return date instanceof Date ? date.getTime() : date;\n  }\n});\nfunction prop_dateTimestamp(def) {\n  return transformedProp(prop(def), timestampAsDate, true);\n}\nfunction tProp_dateTimestamp(typeOrDefaultValue, def) {\n  return transformedProp(tProp(typeOrDefaultValue, def), timestampAsDate, true);\n}\n\n/**\r\n * Connects a tree node to a redux dev tools instance.\r\n *\r\n * @param remotedevPackage The remotedev package (usually the result of `require(\"remoteDev\")`) (https://www.npmjs.com/package/remotedev).\r\n * @param remotedevConnection The result of a connect method from the remotedev package (usually the result of `remoteDev.connectViaExtension(...)`).\r\n * @param target Object to use as root.\r\n * @param storeName Name to be shown in the redux dev tools.\r\n * @param [options] Optional options object. `logArgsNearName` if it should show the arguments near the action name (default is `true`).\r\n */\n\nfunction connectReduxDevTools(remotedevPackage, remotedevConnection, target, options) {\n  assertTweakedObject(target, \"target\");\n\n  var opts = _extends({\n    logArgsNearName: true\n  }, options);\n\n  var handlingMonitorAction = 0; // subscribe to change state (if need more than just logging)\n\n  remotedevConnection.subscribe(function (message) {\n    if (message.type === \"DISPATCH\") {\n      handleMonitorActions(remotedevConnection, target, message);\n    }\n  });\n  var initialState = getSnapshot(target);\n  remotedevConnection.init(initialState);\n  var currentActionId = 0;\n  var actionIdSymbol = Symbol(\"actionId\");\n  actionTrackingMiddleware(target, {\n    onStart: function onStart(ctx) {\n      ctx.data[actionIdSymbol] = currentActionId++;\n    },\n    onResume: function onResume(ctx) {\n      // give a chance to the parent to log its own changes before the child starts\n      if (ctx.parentContext) {\n        log(ctx.parentContext, undefined);\n      }\n\n      log(ctx, undefined);\n    },\n    onSuspend: function onSuspend(ctx) {\n      log(ctx, undefined);\n    },\n    onFinish: function onFinish(ctx, ret) {\n      log(ctx, ret.result);\n    }\n  });\n\n  function handleMonitorActions(remotedev2, target2, message) {\n    try {\n      handlingMonitorAction++;\n\n      switch (message.payload.type) {\n        case \"RESET\":\n          applySnapshot(target2, initialState);\n          return remotedev2.init(initialState);\n\n        case \"COMMIT\":\n          return remotedev2.init(getSnapshot(target2));\n\n        case \"ROLLBACK\":\n          return remotedev2.init(remotedevPackage.extractState(message));\n\n        case \"JUMP_TO_STATE\":\n        case \"JUMP_TO_ACTION\":\n          applySnapshot(target2, remotedevPackage.extractState(message));\n          return;\n\n        case \"IMPORT_STATE\":\n          var nextLiftedState = message.payload.nextLiftedState;\n          var computedStates = nextLiftedState.computedStates;\n          applySnapshot(target2, computedStates[computedStates.length - 1].state);\n          remotedev2.send(null, nextLiftedState);\n          return;\n\n        default:\n      }\n    } finally {\n      handlingMonitorAction--;\n    }\n  }\n\n  var lastLoggedSnapshot = initialState;\n\n  function log(ctx, result) {\n    if (handlingMonitorAction) {\n      return;\n    }\n\n    var sn = getSnapshot(target); // ignore actions that don't change anything (unless it is a throw)\n\n    if (sn === lastLoggedSnapshot && result !== ActionTrackingResult.Throw) {\n      return;\n    }\n\n    lastLoggedSnapshot = sn;\n    var rootPath = fastGetRootPath(ctx.target);\n    var name = getActionContextNameAndTypePath(ctx, rootPath, result);\n    var copy = {\n      type: name,\n      path: rootPath.path,\n      args: ctx.args\n    };\n    remotedevConnection.send(copy, sn);\n  }\n\n  function getActionContextNameAndTypePath(ctx, rootPath, result) {\n    var pathStr = \"[/\" + rootPath.path.join(\"/\") + \"] \";\n    var name = pathStr + ctx.actionName;\n\n    if (opts.logArgsNearName) {\n      var args = ctx.args.map(function (a) {\n        try {\n          return JSON.stringify(a);\n        } catch (_unused) {\n          return \"**unserializable**\";\n        }\n      }).join(\", \");\n\n      if (args.length > 64) {\n        args = args.slice(0, 64) + \"...\";\n      }\n\n      name += \"(\" + args + \")\";\n    }\n\n    var actionId = ctx.data[actionIdSymbol];\n    name += \" (id \" + (actionId !== undefined ? actionId : \"?\");\n\n    if (ctx.type === ActionContextActionType.Async) {\n      name += \", async\";\n    }\n\n    name += \")\";\n\n    if (result === ActionTrackingResult.Throw) {\n      name += \" -error thrown-\";\n    }\n\n    if (ctx.parentContext) {\n      var parentName = getActionContextNameAndTypePath(ctx.parentContext, fastGetRootPath(ctx.parentContext.target), undefined);\n\n      if (parentName) {\n        name = parentName + \" >>> \" + name;\n      }\n    }\n\n    return name;\n  }\n}\n\n/**\r\n * Adds a reaction that will trigger every time an snapshot changes.\r\n *\r\n * @typeparam T Object type.\r\n * @param node Object to get the snapshot from.\r\n * @param listener Function that will be triggered when the snapshot changes.\r\n * @returns A disposer.\r\n */\n\nfunction onSnapshot(node, listener) {\n  assertTweakedObject(node, \"node\");\n  var currentSnapshot = getSnapshot(node);\n  return reaction(function () {\n    return getSnapshot(node);\n  }, function (newSnapshot) {\n    var prevSn = currentSnapshot;\n    currentSnapshot = newSnapshot;\n    listener(newSnapshot, prevSn);\n  });\n}\n\nvar reduxActionType = \"applyAction\";\n/**\r\n * Transforms an action call into a redux action.\r\n *\r\n * @param actionCall Action call.\r\n * @returns A redux action.\r\n */\n\nfunction actionCallToReduxAction(actionCall) {\n  return {\n    type: reduxActionType,\n    payload: actionCall\n  };\n}\n/**\r\n * Generates a redux compatible store out of a mobx-keystone object.\r\n *\r\n * @template T Object type.\r\n * @param target Root object.\r\n * @param middlewares Optional list of redux middlewares.\r\n * @returns A redux compatible store.\r\n */\n\nfunction asReduxStore(target) {\n  assertTweakedObject(target, \"target\");\n\n  var defaultDispatch = function defaultDispatch(action) {\n    if (action.type !== reduxActionType) {\n      throw failure(\"action type was expected to be '\" + reduxActionType + \"', but it was '\" + action.type + \"'\");\n    }\n\n    applyAction(target, action.payload);\n    return action;\n  };\n\n  var store = {\n    getState: function getState() {\n      return getSnapshot(target);\n    },\n    dispatch: function dispatch(action) {\n      return runMiddlewares(action, runners, defaultDispatch);\n    },\n    subscribe: function subscribe(listener) {\n      return onSnapshot(target, listener);\n    }\n  };\n\n  for (var _len = arguments.length, middlewares = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    middlewares[_key - 1] = arguments[_key];\n  }\n\n  var runners = middlewares.map(function (mw) {\n    return mw(store);\n  });\n  return store;\n}\n\nfunction runMiddlewares(initialAction, runners, next) {\n  var i = 0;\n\n  function runNextMiddleware(action) {\n    var runner = runners[i];\n    i++;\n\n    if (runner) {\n      return runner(runNextMiddleware)(action);\n    } else {\n      return next(action);\n    }\n  }\n\n  return runNextMiddleware(initialAction);\n}\n\n/**\r\n * A reference model base type.\r\n * Use `customRef` to create a custom ref constructor.\r\n */\n\nvar Ref = /*#__PURE__*/function (_Model) {\n  _inheritsLoose(Ref, _Model);\n\n  function Ref() {\n    return _Model.apply(this, arguments) || this;\n  }\n\n  _createClass(Ref, [{\n    key: \"maybeCurrent\",\n\n    /**\r\n     * The object this reference points to, or `undefined` if the reference is currently invalid.\r\n     */\n    get: function get() {\n      return this.resolve();\n    }\n    /**\r\n     * If the reference is currently valid.\r\n     */\n\n  }, {\n    key: \"isValid\",\n    get: function get() {\n      return !!this.maybeCurrent;\n    }\n    /**\r\n     * The object this reference points to, or throws if invalid.\r\n     */\n\n  }, {\n    key: \"current\",\n    get: function get() {\n      var current = this.maybeCurrent;\n\n      if (!current) {\n        throw failure(\"a reference of type '\" + this[modelTypeKey] + \"' could not resolve an object with id '\" + this.id + \"'\");\n      }\n\n      return current;\n    }\n  }]);\n\n  return Ref;\n}( /*#__PURE__*/Model({\n  /**\r\n   * Reference id.\r\n   */\n  id: /*#__PURE__*/tProp(typesString)\n}));\n\n__decorate([computed], Ref.prototype, \"maybeCurrent\", null);\n\n__decorate([computed], Ref.prototype, \"isValid\", null);\n\n__decorate([computed], Ref.prototype, \"current\", null);\n/**\r\n * Checks if a ref object is of a given ref type.\r\n *\r\n * @typeparam T Referenced object type.\r\n * @param ref Reference object.\r\n * @param refType Reference type.\r\n * @returns `true` if it is of the given type, false otherwise.\r\n */\n\n\nfunction isRefOfType(ref, refType) {\n  return ref instanceof refType.refClass;\n}\n\n/**\r\n * Back-references from object to the references that point to it.\r\n */\n\nvar objectBackRefs = /*#__PURE__*/new WeakMap();\n/**\r\n * @ignore\r\n * @internal\r\n */\n\nfunction internalCustomRef(modelTypeId, resolverGen, getId, onResolvedValueChange) {\n  var _temp;\n\n  var CustomRef = (_temp = /*#__PURE__*/function (_Ref) {\n    _inheritsLoose(CustomRef, _Ref);\n\n    function CustomRef() {\n      var _this;\n\n      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n        args[_key] = arguments[_key];\n      }\n\n      _this = _Ref.call.apply(_Ref, [this].concat(args)) || this;\n      _this.resolver = void 0;\n      return _this;\n    }\n\n    var _proto = CustomRef.prototype;\n\n    _proto.resolve = function resolve() {\n      if (!this.resolver) {\n        this.resolver = resolverGen(this);\n      }\n\n      return this.resolver(this);\n    };\n\n    _proto.onInit = function onInit() {\n      var _this2 = this;\n\n      // listen to changes\n      var savedOldTarget;\n      var savedFirstTime = true; // according to mwestrate this won't leak as long as we don't keep the disposer around\n\n      reaction(function () {\n        return _this2.maybeCurrent;\n      }, function (newTarget) {\n        var oldTarget = savedOldTarget;\n        var firstTime = savedFirstTime; // update early in case of thrown exceptions\n\n        savedOldTarget = newTarget;\n        savedFirstTime = false;\n        updateBackRefs(_this2, fn, newTarget, oldTarget);\n\n        if (!firstTime && onResolvedValueChange && newTarget !== oldTarget) {\n          onResolvedValueChange(_this2, newTarget, oldTarget);\n        }\n      }, {\n        fireImmediately: true\n      });\n    };\n\n    return CustomRef;\n  }(Ref), _temp);\n  CustomRef = __decorate([model(modelTypeId)], CustomRef);\n\n  var fn = function fn(target) {\n    var id;\n\n    if (typeof target === \"string\") {\n      id = target;\n    } else {\n      assertIsObject(target, \"target\");\n      id = getId(target);\n    }\n\n    if (typeof id !== \"string\") {\n      throw failure(\"ref target object must have an id of string type\");\n    }\n\n    var ref = new CustomRef({\n      id: id\n    });\n    return ref;\n  };\n\n  fn.refClass = CustomRef;\n  return fn;\n}\n/**\r\n * Uses a model `getRefId()` method whenever possible to get a reference ID.\r\n * If the model does not have an implementation of that method it returns `undefined`.\r\n * If the model has an implementation, but that implementation returns anything other than\r\n * a `string` it will throw.\r\n *\r\n * @param target Target object to get the ID from.\r\n * @returns The string ID or `undefined`.\r\n */\n\nfunction getModelRefId(target) {\n  if (isModel(target) && target.getRefId) {\n    var id = target.getRefId();\n\n    if (typeof id !== \"string\") {\n      throw failure(\"'getRefId()' must return a string when present\");\n    }\n\n    return id;\n  }\n\n  return undefined;\n}\n\nfunction getBackRefs(target, refType) {\n  var backRefs = objectBackRefs.get(target);\n\n  if (!backRefs) {\n    backRefs = {\n      all: observable.set(undefined, {\n        deep: false\n      }),\n      byType: new WeakMap()\n    };\n    objectBackRefs.set(target, backRefs);\n  }\n\n  if (!refType) {\n    return backRefs.all;\n  } else {\n    var byType = backRefs.byType.get(refType);\n\n    if (!byType) {\n      byType = observable.set(undefined, {\n        deep: false\n      });\n      backRefs.byType.set(refType, byType);\n    }\n\n    return byType;\n  }\n}\n/**\r\n * Gets all references that resolve to a given object.\r\n *\r\n * @typeparam T Referenced object type.\r\n * @param target Node the references point to.\r\n * @param [refType] Pass it to filter by only references of a given type, or do not to get references of any type.\r\n * @returns An observable set with all reference objects that point to the given object.\r\n */\n\n\nfunction getRefsResolvingTo(target, refType) {\n  assertTweakedObject(target, \"target\");\n  var refTypeObject = refType;\n  return getBackRefs(target, refTypeObject);\n}\n\nfunction updateBackRefs(ref, refClass, newTarget, oldTarget) {\n  if (newTarget === oldTarget) {\n    return;\n  }\n\n  if (oldTarget) {\n    getBackRefs(oldTarget)[\"delete\"](ref);\n    getBackRefs(oldTarget, refClass)[\"delete\"](ref);\n  }\n\n  if (newTarget) {\n    getBackRefs(newTarget).add(ref);\n    getBackRefs(newTarget, refClass).add(ref);\n  }\n}\n\n/**\r\n * Creates a custom ref to an object, which in its snapshot form has an id.\r\n *\r\n * @typeparam T Target object type.\r\n * @param modelTypeId Unique model type id.\r\n * @param options Custom reference options.\r\n * @returns A function that allows you to construct that type of custom reference.\r\n */\n\nvar customRef = /*#__PURE__*/action(\"customRef\", function (modelTypeId, options) {\n  var _options$getId;\n\n  var getId = (_options$getId = options.getId) != null ? _options$getId : getModelRefId;\n  return internalCustomRef(modelTypeId, function () {\n    return options.resolve;\n  }, getId, options.onResolvedValueChange);\n});\n\nvar computedIdTrees = /*#__PURE__*/new WeakMap();\n/**\r\n * Creates a root ref to an object, which in its snapshot form has an id.\r\n * A root ref will only be able to resolve references as long as both the Ref\r\n * and the referenced object share a common root.\r\n *\r\n * @typeparam T Target object type.\r\n * @param modelTypeId Unique model type id.\r\n * @param [options] Root reference options.\r\n * @returns A function that allows you to construct that type of root reference.\r\n */\n\nvar rootRef = /*#__PURE__*/action(\"rootRef\", function (modelTypeId, options) {\n  var _options$getId;\n\n  var getId = (_options$getId = options == null ? void 0 : options.getId) != null ? _options$getId : getModelRefId;\n  var onResolvedValueChange = options == null ? void 0 : options.onResolvedValueChange; // cache/reuse computedIdTrees for same getId function\n\n  var computedIdTree = computedIdTrees.get(getId);\n\n  if (!computedIdTree) {\n    computedIdTree = computedWalkTreeAggregate(getId);\n    computedIdTrees.set(getId, computedIdTree);\n  }\n\n  var resolverGen = function resolverGen(ref) {\n    var cachedTarget;\n    return function () {\n      var refRoot = fastGetRoot(ref);\n\n      if (isRefRootCachedTargetOk(ref, refRoot, cachedTarget, getId)) {\n        return cachedTarget;\n      } // when not found, everytime a child is added/removed or its id changes we will perform another search\n      // this search is only done once for every distinct getId function\n\n\n      var idMap = computedIdTree.walk(refRoot);\n      var newTarget = idMap ? idMap.get(ref.id) : undefined;\n\n      if (newTarget) {\n        cachedTarget = newTarget;\n      }\n\n      return newTarget;\n    };\n  };\n\n  return internalCustomRef(modelTypeId, resolverGen, getId, onResolvedValueChange);\n});\n\nfunction isRefRootCachedTargetOk(ref, refRoot, cachedTarget, getId) {\n  if (!cachedTarget) return false;\n  if (ref.id !== getId(cachedTarget)) return false;\n  if (refRoot !== fastGetRoot(cachedTarget)) return false;\n  return true;\n}\n\n/**\r\n * Clones an object by doing a `fromSnapshot(getSnapshot(value), { generateNewIds: true })`.\r\n *\r\n * @typeparam T Object type.\r\n * @param node Object to clone.\r\n * @param [options] Options.\r\n * @returns The cloned object.\r\n */\n\nfunction clone(node, options) {\n  assertTweakedObject(node, \"node\");\n\n  var opts = _extends({\n    generateNewIds: true\n  }, options);\n\n  var sn = getSnapshot(node);\n  return fromSnapshot(sn, opts);\n}\n\n/**\r\n * Deeply compares two values.\r\n *\r\n * Supported values are:\r\n * - Primitives\r\n * - Boxed observables\r\n * - Objects, observable objects\r\n * - Arrays, observable arrays\r\n * - Typed arrays\r\n * - Maps, observable maps\r\n * - Sets, observable sets\r\n * - Tree nodes (optimized by using snapshot comparison internally)\r\n *\r\n * Note that in the case of models the result will be false if their model IDs are different.\r\n *\r\n * @param a First value to compare.\r\n * @param b Second value to compare.\r\n * @returns `true` if they are the equivalent, `false` otherwise.\r\n */\n\nfunction deepEquals(a, b) {\n  // quick check for reference\n  if (a === b) {\n    return true;\n  } // use snapshots to compare if possible\n  // since snapshots use structural sharing it is more likely\n  // to speed up comparisons\n\n\n  if (isTreeNode(a)) {\n    a = getSnapshot(a);\n  } else if (isObservable(a)) {\n    a = toJS(a, toJSOptions);\n  }\n\n  if (isTreeNode(b)) {\n    b = getSnapshot(b);\n  } else if (isObservable(b)) {\n    b = toJS(b, toJSOptions);\n  }\n\n  return fastDeepEqual(a, b);\n}\nvar toJSOptions = /*#__PURE__*/getMobxVersion() >= 6 ? undefined : {\n  exportMapsAsObjects: false,\n  recurseEverything: false\n};\n\n/**\r\n * A class with the implementationm of draft.\r\n * Use `draft` to create an instance of this class.\r\n *\r\n * @typeparam T Data type.\r\n */\n\nvar Draft = /*#__PURE__*/function () {\n  var _proto = Draft.prototype;\n\n  /**\r\n   * Draft data object.\r\n   */\n\n  /**\r\n   * Commits current draft changes to the original object.\r\n   */\n  _proto.commit = function commit() {\n    applySnapshot(this.originalData, getSnapshot(this.data));\n  }\n  /**\r\n   * Partially commits current draft changes to the original object.\r\n   * If the path cannot be resolved in either the draft or the original object it will throw.\r\n   * Note that model IDs are checked to be the same when resolving the paths.\r\n   *\r\n   * @param path Path to commit.\r\n   */\n  ;\n\n  _proto.commitByPath = function commitByPath(path) {\n    var draftTarget = resolvePath(this.data, path);\n\n    if (!draftTarget.resolved) {\n      throw failure(\"path \" + JSON.stringify(path) + \" could not be resolved in draft object\");\n    }\n\n    var draftPathIds = pathToTargetPathIdsIgnoringLast(this.data, path);\n    var originalTarget = resolvePathCheckingIds(this.originalData, path, draftPathIds);\n\n    if (!originalTarget.resolved) {\n      throw failure(\"path \" + JSON.stringify(path) + \" could not be resolved in original object\");\n    }\n\n    applyPatches(this.originalData, [{\n      path: path,\n      op: \"replace\",\n      value: getSnapshot(draftTarget.value)\n    }]);\n  }\n  /**\r\n   * Resets the draft to be an exact copy of the current state of the original object.\r\n   */\n  ;\n\n  _proto.reset = function reset() {\n    applySnapshot(this.data, this.originalSnapshot);\n  }\n  /**\r\n   * Partially resets current draft changes to be the same as the original object.\r\n   * If the path cannot be resolved in either the draft or the original object it will throw.\r\n   * Note that model IDs are checked to be the same when resolving the paths.\r\n   *\r\n   * @param path Path to reset.\r\n   */\n  ;\n\n  _proto.resetByPath = function resetByPath(path) {\n    var originalTarget = resolvePath(this.originalData, path);\n\n    if (!originalTarget.resolved) {\n      throw failure(\"path \" + JSON.stringify(path) + \" could not be resolved in original object\");\n    }\n\n    var originalPathIds = pathToTargetPathIdsIgnoringLast(this.originalData, path);\n    var draftTarget = resolvePathCheckingIds(this.data, path, originalPathIds);\n\n    if (!draftTarget.resolved) {\n      throw failure(\"path \" + JSON.stringify(path) + \" could not be resolved in draft object\");\n    }\n\n    applyPatches(this.data, [{\n      path: path,\n      op: \"replace\",\n      value: getSnapshot(originalTarget.value)\n    }]);\n  }\n  /**\r\n   * Returns `true` if the draft has changed compared to the original object, `false` otherwise.\r\n   */\n  ;\n\n  /**\r\n   * Returns `true` if the value at the given path of the draft has changed compared to the original object.\r\n   * If the path cannot be resolved in the draft it will throw.\r\n   * If the path cannot be resolved in the original object it will return `true`.\r\n   * Note that model IDs are checked to be the same when resolving the paths.\r\n   *\r\n   * @param path Path to check.\r\n   */\n  _proto.isDirtyByPath = function isDirtyByPath(path) {\n    var draftTarget = resolvePath(this.data, path);\n\n    if (!draftTarget.resolved) {\n      throw failure(\"path \" + JSON.stringify(path) + \" could not be resolved in draft object\");\n    }\n\n    var draftPathIds = pathToTargetPathIdsIgnoringLast(this.data, path);\n    var originalTarget = resolvePathCheckingIds(this.originalData, path, draftPathIds);\n\n    if (!originalTarget.resolved) {\n      return true;\n    }\n\n    return !deepEquals(draftTarget.value, originalTarget.value);\n  }\n  /**\r\n   * Original data object.\r\n   */\n  ;\n\n  _createClass(Draft, [{\n    key: \"isDirty\",\n    get: function get() {\n      return !deepEquals(getSnapshot(this.data), this.originalSnapshot);\n    }\n  }, {\n    key: \"originalSnapshot\",\n    get: function get() {\n      return getSnapshot(this.originalData);\n    }\n    /**\r\n     * Creates an instance of Draft.\r\n     * Do not use directly, use `draft` instead.\r\n     *\r\n     * @param original\r\n     */\n\n  }]);\n\n  function Draft(original) {\n    this.data = void 0;\n    this.originalData = void 0;\n    assertTweakedObject(original, \"original\");\n    this.originalData = original;\n    this.data = fromSnapshot(this.originalSnapshot, {\n      generateNewIds: false\n    });\n  }\n\n  return Draft;\n}();\n\n__decorate([action], Draft.prototype, \"commit\", null);\n\n__decorate([action], Draft.prototype, \"commitByPath\", null);\n\n__decorate([action], Draft.prototype, \"reset\", null);\n\n__decorate([action], Draft.prototype, \"resetByPath\", null);\n\n__decorate([computed], Draft.prototype, \"isDirty\", null);\n\n__decorate([computed], Draft.prototype, \"originalSnapshot\", null);\n/**\r\n * Creates a draft copy of a tree node and all its children.\r\n *\r\n * @typeparam T Data type.\r\n * @param original Original node.\r\n * @returns The draft object.\r\n */\n\n\nfunction draft(original) {\n  return new Draft(original);\n}\n\nfunction pathToTargetPathIdsIgnoringLast(root, path) {\n  var pathIds = pathToTargetPathIds(root, path);\n\n  if (pathIds.length >= 1) {\n    // never check the last object id\n    pathIds[pathIds.length - 1] = skipIdChecking;\n  }\n\n  return pathIds;\n}\n\n/**\r\n * Context that allows access to the sandbox manager this node runs under (if any).\r\n */\n\nvar sandboxManagerContext = /*#__PURE__*/createContext();\n/**\r\n * Returns the sandbox manager of a node, or `undefined` if none.\r\n *\r\n * @param node Node to check.\r\n * @returns The sandbox manager of a node, or `undefined` if none.\r\n */\n\nfunction getNodeSandboxManager(node) {\n  return sandboxManagerContext.get(node);\n}\n/**\r\n * Returns if a given node is a sandboxed node.\r\n *\r\n * @param node Node to check.\r\n * @returns `true` if it is sandboxed, `false`\r\n */\n\nfunction isSandboxedNode(node) {\n  return !!getNodeSandboxManager(node);\n}\n/**\r\n * Manager class returned by `sandbox` that allows you to make changes to a sandbox copy of the\r\n * original subtree and apply them to the original subtree or reject them.\r\n */\n\nvar SandboxManager = /*#__PURE__*/function () {\n  /**\r\n   * The sandbox copy of the original subtree.\r\n   */\n\n  /**\r\n   * The internal disposer.\r\n   */\n\n  /**\r\n   * The internal `withSandbox` patch recorder. If `undefined`, no `withSandbox` call is being\r\n   * executed.\r\n   */\n\n  /**\r\n   * Function from `readonlyMiddleware` that will allow actions to be started inside the provided\r\n   * code block on a readonly node.\r\n   */\n\n  /**\r\n   * Creates an instance of `SandboxManager`.\r\n   * Do not use directly, use `sandbox` instead.\r\n   *\r\n   * @param subtreeRoot Subtree root target object.\r\n   */\n  function SandboxManager(subtreeRoot) {\n    var _this = this;\n\n    this.subtreeRoot = void 0;\n    this.subtreeRootClone = void 0;\n    this.disposer = void 0;\n    this.withSandboxPatchRecorder = void 0;\n    this.allowWrite = void 0;\n    this.subtreeRoot = subtreeRoot;\n    assertTweakedObject(subtreeRoot, \"subtreeRoot\"); // we temporarily set the default value of the context manager so that\n    // cloned nodes can access it while in their onInit phase\n\n    var previousContextDefault = sandboxManagerContext.getDefault();\n    sandboxManagerContext.setDefault(this);\n\n    try {\n      this.subtreeRootClone = clone(subtreeRoot, {\n        generateNewIds: false\n      });\n      sandboxManagerContext.set(this.subtreeRootClone, this);\n    } catch (err) {\n      throw err;\n    } finally {\n      sandboxManagerContext.setDefault(previousContextDefault);\n    }\n\n    var wasRS = false;\n    var disposeReactionRS = reaction(function () {\n      return isRootStore(subtreeRoot);\n    }, function (isRS) {\n      if (isRS !== wasRS) {\n        wasRS = isRS;\n\n        if (isRS) {\n          registerRootStore(_this.subtreeRootClone);\n        } else {\n          unregisterRootStore(_this.subtreeRootClone);\n        }\n      }\n    }, {\n      fireImmediately: true\n    });\n    var disposeOnPatches = onPatches(subtreeRoot, function (patches) {\n      if (_this.withSandboxPatchRecorder) {\n        throw failure(\"original subtree must not change while 'withSandbox' executes\");\n      }\n\n      _this.allowWrite(function () {\n        applyPatches(_this.subtreeRootClone, patches);\n      });\n    });\n\n    var _readonlyMiddleware = readonlyMiddleware(this.subtreeRootClone),\n        allowWrite = _readonlyMiddleware.allowWrite,\n        disposeReadonlyMW = _readonlyMiddleware.dispose;\n\n    this.allowWrite = allowWrite;\n\n    this.disposer = function () {\n      disposeReactionRS();\n      disposeOnPatches();\n      disposeReadonlyMW();\n\n      if (isRootStore(_this.subtreeRootClone)) {\n        unregisterRootStore(_this.subtreeRootClone);\n      }\n\n      _this.disposer = function () {};\n    };\n  }\n  /**\r\n   * Executes `fn` with a sandbox copy of `node`. The changes made to the sandbox in `fn` can be\r\n   * accepted, i.e. applied to the original subtree, or rejected.\r\n   *\r\n   * @typeparam T Object type.\r\n   * @typeparam R Return type.\r\n   * @param node Object or tuple of objects for which to obtain a sandbox copy.\r\n   * @param fn Function that is called with a sandbox copy of `node`. Any changes made to the\r\n   * sandbox are applied to the original subtree when `fn` returns `true` or\r\n   * `{ commit: true, ... }`. When `fn` returns `false` or `{ commit: false, ... }` the changes made\r\n   * to the sandbox are rejected.\r\n   * @returns Value of type `R` when `fn` returns an object of type `{ commit: boolean; return: R }`\r\n   * or `void` when `fn` returns a boolean.\r\n   */\n\n\n  var _proto = SandboxManager.prototype;\n\n  _proto.withSandbox = function withSandbox(node, fn) {\n    assertIsFunction(fn, \"fn\");\n    var isNodesArray = Array.isArray(node) && !isTweakedObject(node, false);\n    var nodes = isNodesArray ? node : [node];\n\n    var _this$prepareSandboxC = this.prepareSandboxChanges(nodes),\n        sandboxNodes = _this$prepareSandboxC.sandboxNodes,\n        applyRecorderChanges = _this$prepareSandboxC.applyRecorderChanges;\n\n    var commit = false;\n\n    try {\n      var returnValue = this.allowWrite(function () {\n        return fn(isNodesArray ? sandboxNodes : sandboxNodes[0]);\n      });\n\n      if (typeof returnValue === \"boolean\") {\n        commit = returnValue;\n        return undefined;\n      } else {\n        commit = returnValue.commit;\n        return returnValue[\"return\"];\n      }\n    } finally {\n      applyRecorderChanges(commit);\n    }\n  }\n  /**\r\n   * Disposes of the sandbox.\r\n   */\n  ;\n\n  _proto.dispose = function dispose() {\n    this.disposer();\n  };\n\n  _proto.prepareSandboxChanges = function prepareSandboxChanges(nodes) {\n    var _this2 = this;\n\n    var isNestedWithSandboxCall = !!this.withSandboxPatchRecorder;\n    var sandboxNodes = nodes.map(function (node) {\n      assertTweakedObject(node, \"node\");\n      var path = getParentToChildPath(isNestedWithSandboxCall ? _this2.subtreeRootClone : _this2.subtreeRoot, node);\n\n      if (!path) {\n        throw failure(\"node is not a child of subtreeRoot\" + (isNestedWithSandboxCall ? \"Clone\" : \"\"));\n      }\n\n      var sandboxNode = resolvePath(_this2.subtreeRootClone, path).value;\n\n      if (!sandboxNode) {\n        throw failure(\"path could not be resolved - sandbox may be out of sync with original tree\");\n      }\n\n      return sandboxNode;\n    });\n\n    if (!this.withSandboxPatchRecorder) {\n      this.withSandboxPatchRecorder = patchRecorder(this.subtreeRootClone);\n    }\n\n    var recorder = this.withSandboxPatchRecorder;\n    var numRecorderEvents = recorder.events.length;\n\n    var applyRecorderChanges = function applyRecorderChanges(commit) {\n      if (!isNestedWithSandboxCall) {\n        recorder.dispose();\n        _this2.withSandboxPatchRecorder = undefined;\n      }\n\n      if (commit) {\n        if (!isNestedWithSandboxCall) {\n          var patches = [];\n          var len = recorder.events.length;\n\n          for (var i = 0; i < len; i++) {\n            patches.push.apply(patches, recorder.events[i].patches);\n          }\n\n          applyPatches(_this2.subtreeRoot, patches);\n        }\n      } else {\n        _this2.allowWrite(function () {\n          runInAction(function () {\n            var i = recorder.events.length;\n\n            while (i-- > numRecorderEvents) {\n              applyPatches(_this2.subtreeRootClone, recorder.events[i].inversePatches, true);\n            }\n          });\n        });\n      }\n    };\n\n    return {\n      sandboxNodes: sandboxNodes,\n      applyRecorderChanges: applyRecorderChanges\n    };\n  };\n\n  return SandboxManager;\n}();\n/**\r\n * Creates a sandbox.\r\n *\r\n * @param subtreeRoot Subtree root target object.\r\n * @returns A `SandboxManager` which allows you to manage the sandbox operations and dispose of the\r\n * sandbox.\r\n */\n\nfunction sandbox(subtreeRoot) {\n  return new SandboxManager(subtreeRoot);\n}\n\n/**\r\n * A set that is backed by an array.\r\n * Use `arraySet` to create it.\r\n */\n\nvar ArraySet = /*#__PURE__*/function (_Model) {\n  _inheritsLoose(ArraySet, _Model);\n\n  function ArraySet() {\n    return _Model.apply(this, arguments) || this;\n  }\n\n  var _proto = ArraySet.prototype;\n\n  _proto.add = function add(value) {\n    var items = this.items;\n\n    if (!items.includes(value)) {\n      items.push(value);\n    }\n\n    return this;\n  };\n\n  _proto.clear = function clear() {\n    this.items.length = 0;\n  };\n\n  _proto[\"delete\"] = function _delete(value) {\n    var items = this.items;\n    var index = items.findIndex(function (t) {\n      return t === value;\n    });\n\n    if (index >= 0) {\n      items.splice(index, 1);\n      return true;\n    } else {\n      return false;\n    }\n  };\n\n  _proto.forEach = function forEach(callbackfn, thisArg) {\n    // we cannot use the set implementation since we need to pass this as set\n    var items = this.items;\n    var len = items.length;\n\n    for (var i = 0; i < len; i++) {\n      var k = items[i];\n      callbackfn.call(thisArg, k, k, this);\n    }\n  };\n\n  _proto.has = function has(value) {\n    return this.items.includes(value);\n  };\n\n  _proto.keys = function keys() {\n    return this.values(); // yes, values\n  };\n\n  _proto.values = function values$1() {\n    var items = this.items;\n    return values(items)[Symbol.iterator]();\n  };\n\n  _proto.entries = function entries() {\n    var items = this.items; // TODO: should use an actual iterator\n\n    return items.map(function (v) {\n      return [v, v];\n    }).values();\n  };\n\n  _proto[Symbol.iterator] = function () {\n    return this.values();\n  };\n\n  _createClass(ArraySet, [{\n    key: \"size\",\n    get: function get() {\n      return this.items.length;\n    }\n  }, {\n    key: Symbol.toStringTag,\n    get: function get() {\n      return \"ArraySet\";\n    }\n  }]);\n\n  return ArraySet;\n}( /*#__PURE__*/Model({\n  items: /*#__PURE__*/tProp( /*#__PURE__*/typesArray( /*#__PURE__*/typesUnchecked()), function () {\n    return [];\n  })\n}));\n\n__decorate([modelAction], ArraySet.prototype, \"add\", null);\n\n__decorate([modelAction], ArraySet.prototype, \"clear\", null);\n\n__decorate([modelAction], ArraySet.prototype, \"delete\", null);\n\nArraySet = /*#__PURE__*/__decorate([/*#__PURE__*/model(\"mobx-keystone/ArraySet\")], ArraySet);\n/**\r\n * Creates a new ArraySet model instance.\r\n *\r\n * @typeparam V Value type.\r\n * @param [entries] Optional initial values.\r\n */\n\nfunction arraySet(values) {\n  var initialArr = values ? values.slice() : [];\n  return new ArraySet({\n    items: initialArr\n  });\n}\n\n/**\r\n * A type that represents an array backed set ArraySet.\r\n *\r\n * Example:\r\n * ```ts\r\n * const numberSetType = types.arraySet(types.number)\r\n * ```\r\n *\r\n * @typeparam T Value type.\r\n * @param valueType Value type.\r\n * @returns\r\n */\n\nfunction typesArraySet(valueType) {\n  var typeInfoGen = function typeInfoGen(t) {\n    return new ArraySetTypeInfo(t, resolveStandardType(valueType));\n  };\n\n  return lateTypeChecker(function () {\n    var valueChecker = resolveTypeChecker(valueType);\n\n    var getTypeName = function getTypeName() {\n      for (var _len = arguments.length, recursiveTypeCheckers = new Array(_len), _key = 0; _key < _len; _key++) {\n        recursiveTypeCheckers[_key] = arguments[_key];\n      }\n\n      return \"ArraySet<\" + valueChecker.getTypeName.apply(valueChecker, recursiveTypeCheckers.concat([valueChecker])) + \">\";\n    };\n\n    var thisTc = new TypeChecker(function (obj, path) {\n      if (!(obj instanceof ArraySet)) {\n        return new TypeCheckError(path, getTypeName(thisTc), obj);\n      }\n\n      var dataTypeChecker = typesObject(function () {\n        return {\n          items: typesArray(valueChecker)\n        };\n      });\n      var resolvedTc = resolveTypeChecker(dataTypeChecker);\n      return resolvedTc.check(obj.$, path);\n    }, getTypeName, typeInfoGen);\n    return thisTc;\n  }, typeInfoGen);\n}\n/**\r\n * `types.arraySet` type info.\r\n */\n\nvar ArraySetTypeInfo = /*#__PURE__*/function (_TypeInfo) {\n  _inheritsLoose(ArraySetTypeInfo, _TypeInfo);\n\n  _createClass(ArraySetTypeInfo, [{\n    key: \"valueTypeInfo\",\n    get: function get() {\n      return getTypeInfo(this.valueType);\n    }\n  }]);\n\n  function ArraySetTypeInfo(originalType, valueType) {\n    var _this;\n\n    _this = _TypeInfo.call(this, originalType) || this;\n    _this.valueType = void 0;\n    _this.valueType = valueType;\n    return _this;\n  }\n\n  return ArraySetTypeInfo;\n}(TypeInfo);\n\n/**\r\n * A type that represents the union of several other types (a | b | c | ...).\r\n *\r\n * Example:\r\n * ```ts\r\n * const booleanOrNumberType = types.or(types.boolean, types.number)\r\n * ```\r\n *\r\n * @typeparam T Type.\r\n * @param orTypes Possible types.\r\n * @returns\r\n */\n\nfunction typesOr() {\n  for (var _len = arguments.length, orTypes = new Array(_len), _key = 0; _key < _len; _key++) {\n    orTypes[_key] = arguments[_key];\n  }\n\n  var typeInfoGen = function typeInfoGen(t) {\n    return new OrTypeInfo(t, orTypes.map(resolveStandardType));\n  };\n\n  return lateTypeChecker(function () {\n    var checkers = orTypes.map(resolveTypeChecker); // if the or includes unchecked then it is unchecked\n\n    if (checkers.some(function (tc) {\n      return tc.unchecked;\n    })) {\n      return typesUnchecked();\n    }\n\n    var getTypeName = function getTypeName() {\n      for (var _len2 = arguments.length, recursiveTypeCheckers = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        recursiveTypeCheckers[_key2] = arguments[_key2];\n      }\n\n      var typeNames = checkers.map(function (tc) {\n        if (recursiveTypeCheckers.includes(tc)) {\n          return \"...\";\n        }\n\n        return tc.getTypeName.apply(tc, recursiveTypeCheckers.concat([tc]));\n      });\n      return typeNames.join(\" | \");\n    };\n\n    var thisTc = new TypeChecker(function (value, path) {\n      var noMatchingType = checkers.every(function (tc) {\n        return !!tc.check(value, path);\n      });\n\n      if (noMatchingType) {\n        return new TypeCheckError(path, getTypeName(thisTc), value);\n      } else {\n        return null;\n      }\n    }, getTypeName, typeInfoGen);\n    return thisTc;\n  }, typeInfoGen);\n}\n/**\r\n * `types.or` type info.\r\n */\n\nvar OrTypeInfo = /*#__PURE__*/function (_TypeInfo) {\n  _inheritsLoose(OrTypeInfo, _TypeInfo);\n\n  _createClass(OrTypeInfo, [{\n    key: \"orTypeInfos\",\n    // memoize to always return the same array on the getter\n    get: function get() {\n      return this._orTypeInfos();\n    }\n  }]);\n\n  function OrTypeInfo(thisType, orTypes) {\n    var _this;\n\n    _this = _TypeInfo.call(this, thisType) || this;\n    _this.orTypes = void 0;\n    _this._orTypeInfos = lateVal(function () {\n      return _this.orTypes.map(getTypeInfo);\n    });\n    _this.orTypes = orTypes;\n    return _this;\n  }\n\n  return OrTypeInfo;\n}(TypeInfo);\n\nfunction enumValues(e) {\n  var vals = [];\n\n  for (var _i = 0, _Object$keys = Object.keys(e); _i < _Object$keys.length; _i++) {\n    var k = _Object$keys[_i];\n    var v = e[k]; // we have to do this since TS does something weird\n    // to number values\n    // Hi = 0 -> { Hi: 0, 0: \"Hi\" }\n\n    if (typeof v !== \"string\" || e[v] !== +k) {\n      vals.push(v);\n    }\n  }\n\n  return vals;\n}\n\nfunction typesEnum(enumObject) {\n  assertIsObject(enumObject, \"enumObject\");\n  var literals = enumValues(enumObject).map(function (e) {\n    return typesLiteral(e);\n  });\n  return typesOr.apply(void 0, literals);\n}\n\n/**\r\n * A type that represents either a type or undefined.\r\n * Syntactic sugar for `types.or(baseType, types.undefined)`\r\n *\r\n * Example:\r\n * ```ts\r\n * const numberOrUndefinedType = types.maybe(types.number)\r\n * ```\r\n *\r\n * @typeparam T Type.\r\n * @param baseType Type.\r\n * @returns\r\n */\n\nfunction typesMaybe(baseType) {\n  return typesOr(baseType, typesUndefined);\n}\n/**\r\n * A type that represents either a type or null.\r\n * Syntactic sugar for `types.or(baseType, types.null)`\r\n *\r\n *  * Example:\r\n * ```ts\r\n * const numberOrNullType = types.maybeNull(types.number)\r\n * ```\r\n *\r\n * @typeparam T Type.\r\n * @param type Type.\r\n * @returns\r\n */\n\nfunction typesMaybeNull(type) {\n  return typesOr(type, typesNull);\n}\n\n/**\r\n * A type that represents an object-like map, an object with string keys and values all of a same given type.\r\n *\r\n * Example:\r\n * ```ts\r\n * // { [k: string]: number }\r\n * const numberMapType = types.record(types.number)\r\n * ```\r\n *\r\n * @typeparam T Type.\r\n * @param valueType Type of the values of the object-like map.\r\n * @returns\r\n */\n\nfunction typesRecord(valueType) {\n  var typeInfoGen = function typeInfoGen(tc) {\n    return new RecordTypeInfo(tc, resolveStandardType(valueType));\n  };\n\n  return lateTypeChecker(function () {\n    var valueChecker = resolveTypeChecker(valueType);\n\n    var getTypeName = function getTypeName() {\n      for (var _len = arguments.length, recursiveTypeCheckers = new Array(_len), _key = 0; _key < _len; _key++) {\n        recursiveTypeCheckers[_key] = arguments[_key];\n      }\n\n      return \"Record<\" + valueChecker.getTypeName.apply(valueChecker, recursiveTypeCheckers.concat([valueChecker])) + \">\";\n    };\n\n    var thisTc = new TypeChecker(function (obj, path) {\n      if (!isObject(obj)) return new TypeCheckError(path, getTypeName(thisTc), obj);\n\n      if (!valueChecker.unchecked) {\n        var keys = Object.keys(obj);\n\n        for (var i = 0; i < keys.length; i++) {\n          var k = keys[i];\n          var v = obj[k];\n          var valueError = valueChecker.check(v, [].concat(path, [k]));\n\n          if (valueError) {\n            return valueError;\n          }\n        }\n      }\n\n      return null;\n    }, getTypeName, typeInfoGen);\n    return thisTc;\n  }, typeInfoGen);\n}\n/**\r\n * `types.record` type info.\r\n */\n\nvar RecordTypeInfo = /*#__PURE__*/function (_TypeInfo) {\n  _inheritsLoose(RecordTypeInfo, _TypeInfo);\n\n  _createClass(RecordTypeInfo, [{\n    key: \"valueTypeInfo\",\n    get: function get() {\n      return getTypeInfo(this.valueType);\n    }\n  }]);\n\n  function RecordTypeInfo(thisType, valueType) {\n    var _this;\n\n    _this = _TypeInfo.call(this, thisType) || this;\n    _this.valueType = void 0;\n    _this.valueType = valueType;\n    return _this;\n  }\n\n  return RecordTypeInfo;\n}(TypeInfo);\n\n/**\r\n * A map that is backed by an object-like map.\r\n * Use `objectMap` to create it.\r\n */\n\nvar ObjectMap = /*#__PURE__*/function (_Model) {\n  _inheritsLoose(ObjectMap, _Model);\n\n  function ObjectMap() {\n    return _Model.apply(this, arguments) || this;\n  }\n\n  var _proto = ObjectMap.prototype;\n\n  _proto.clear = function clear() {\n    var items = this.items;\n    var keys = Object.keys(items);\n    var len = keys.length;\n\n    for (var i = 0; i < len; i++) {\n      var k = keys[i];\n      remove(items, k);\n    }\n  };\n\n  _proto[\"delete\"] = function _delete(key) {\n    var hasKey = this.has(key);\n\n    if (hasKey) {\n      remove(this.items, key);\n      return true;\n    } else {\n      return false;\n    }\n  };\n\n  _proto.forEach = function forEach(callbackfn, thisArg) {\n    // we cannot use the map implementation since we need to pass this as map\n    var items = this.items;\n    var keys = Object.keys(items);\n    var len = keys.length;\n\n    for (var i = 0; i < len; i++) {\n      var k = keys[i];\n      callbackfn.call(thisArg, items[k], k, this);\n    }\n  };\n\n  _proto.get = function get$1(key) {\n    return get(this.items, key);\n  };\n\n  _proto.has = function has$1(key) {\n    return has(this.items, key);\n  };\n\n  _proto.set = function set$1(key, value) {\n    set(this.items, key, value);\n\n    return this;\n  };\n\n  _proto.keys = function keys$1() {\n    // TODO: should use an actual iterator\n    return keys(this.items)[Symbol.iterator]();\n  };\n\n  _proto.values = function values$1() {\n    // TODO: should use an actual iterator\n    return values(this.items)[Symbol.iterator]();\n  };\n\n  _proto.entries = function entries$1() {\n    // TODO: should use an actual iterator\n    return entries(this.items)[Symbol.iterator]();\n  };\n\n  _proto[Symbol.iterator] = function () {\n    return this.entries();\n  };\n\n  _createClass(ObjectMap, [{\n    key: \"size\",\n    get: function get() {\n      return keys(this.items).length;\n    }\n  }, {\n    key: Symbol.toStringTag,\n    get: function get() {\n      return \"ObjectMap\";\n    }\n  }]);\n\n  return ObjectMap;\n}( /*#__PURE__*/Model({\n  items: /*#__PURE__*/tProp( /*#__PURE__*/typesRecord( /*#__PURE__*/typesUnchecked()), function () {\n    return {};\n  })\n}));\n\n__decorate([modelAction], ObjectMap.prototype, \"clear\", null);\n\n__decorate([modelAction], ObjectMap.prototype, \"delete\", null);\n\n__decorate([modelAction], ObjectMap.prototype, \"set\", null);\n\nObjectMap = /*#__PURE__*/__decorate([/*#__PURE__*/model(\"mobx-keystone/ObjectMap\")], ObjectMap);\n/**\r\n * Creates a new ObjectMap model instance.\r\n *\r\n * @typeparam V Value type.\r\n * @param [entries] Optional initial values.\r\n */\n\nfunction objectMap(entries) {\n  var initialObj = {};\n\n  if (entries) {\n    var len = entries.length;\n\n    for (var i = 0; i < len; i++) {\n      var entry = entries[i];\n      initialObj[entry[0]] = entry[1];\n    }\n  }\n\n  return new ObjectMap({\n    items: initialObj\n  });\n}\n\n/**\r\n * A type that represents an object-like map ObjectMap.\r\n *\r\n * Example:\r\n * ```ts\r\n * const numberMapType = types.objectMap(types.number)\r\n * ```\r\n *\r\n * @typeparam T Value type.\r\n * @param valueType Value type.\r\n * @returns\r\n */\n\nfunction typesObjectMap(valueType) {\n  var typeInfoGen = function typeInfoGen(t) {\n    return new ObjectMapTypeInfo(t, resolveStandardType(valueType));\n  };\n\n  return lateTypeChecker(function () {\n    var valueChecker = resolveTypeChecker(valueType);\n\n    var getTypeName = function getTypeName() {\n      for (var _len = arguments.length, recursiveTypeCheckers = new Array(_len), _key = 0; _key < _len; _key++) {\n        recursiveTypeCheckers[_key] = arguments[_key];\n      }\n\n      return \"ObjectMap<\" + valueChecker.getTypeName.apply(valueChecker, recursiveTypeCheckers.concat([valueChecker])) + \">\";\n    };\n\n    var thisTc = new TypeChecker(function (obj, path) {\n      if (!(obj instanceof ObjectMap)) {\n        return new TypeCheckError(path, getTypeName(thisTc), obj);\n      }\n\n      var dataTypeChecker = typesObject(function () {\n        return {\n          items: typesRecord(valueChecker)\n        };\n      });\n      var resolvedTc = resolveTypeChecker(dataTypeChecker);\n      return resolvedTc.check(obj.$, path);\n    }, getTypeName, typeInfoGen);\n    return thisTc;\n  }, typeInfoGen);\n}\n/**\r\n * `types.objectMap` type info.\r\n */\n\nvar ObjectMapTypeInfo = /*#__PURE__*/function (_TypeInfo) {\n  _inheritsLoose(ObjectMapTypeInfo, _TypeInfo);\n\n  _createClass(ObjectMapTypeInfo, [{\n    key: \"valueTypeInfo\",\n    get: function get() {\n      return getTypeInfo(this.valueType);\n    }\n  }]);\n\n  function ObjectMapTypeInfo(thisType, valueType) {\n    var _this;\n\n    _this = _TypeInfo.call(this, thisType) || this;\n    _this.valueType = void 0;\n    _this.valueType = valueType;\n    return _this;\n  }\n\n  return ObjectMapTypeInfo;\n}(TypeInfo);\n\n/**\r\n * A type that represents a reference to an object or model.\r\n *\r\n * Example:\r\n * ```ts\r\n * const refToSomeObject = types.ref<SomeObject>()\r\n * ```\r\n *\r\n * @typeparam O Object or model type.\r\n * @returns\r\n */\n\nfunction typesRef() {\n  return refTypeChecker;\n}\nvar typeName = \"Ref\";\nvar refDataTypeChecker = /*#__PURE__*/typesObject(function () {\n  return {\n    id: typesString\n  };\n});\nvar refTypeChecker = /*#__PURE__*/new TypeChecker(function (value, path) {\n  if (!(value instanceof Ref)) {\n    return new TypeCheckError(path, typeName, value);\n  }\n\n  var resolvedTc = resolveTypeChecker(refDataTypeChecker);\n  return resolvedTc.check(value.$, path);\n}, function () {\n  return typeName;\n}, function (t) {\n  return new RefTypeInfo(t);\n});\n/**\r\n * `types.ref` type info.\r\n */\n\nvar RefTypeInfo = /*#__PURE__*/function (_TypeInfo) {\n  _inheritsLoose(RefTypeInfo, _TypeInfo);\n\n  function RefTypeInfo() {\n    return _TypeInfo.apply(this, arguments) || this;\n  }\n\n  return RefTypeInfo;\n}(TypeInfo);\n\n/**\r\n * A type that represents an tuple of values of a given type.\r\n *\r\n * Example:\r\n * ```ts\r\n * const stringNumberTupleType = types.tuple(types.string, types.number)\r\n * ```\r\n *\r\n * @typeparam T Item types.\r\n * @param itemType Type of inner items.\r\n * @returns\r\n */\n\nfunction typesTuple() {\n  for (var _len = arguments.length, itemTypes = new Array(_len), _key = 0; _key < _len; _key++) {\n    itemTypes[_key] = arguments[_key];\n  }\n\n  var typeInfoGen = function typeInfoGen(t) {\n    return new TupleTypeInfo(t, itemTypes.map(resolveStandardType));\n  };\n\n  return lateTypeChecker(function () {\n    var checkers = itemTypes.map(resolveTypeChecker);\n\n    var getTypeName = function getTypeName() {\n      for (var _len2 = arguments.length, recursiveTypeCheckers = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n        recursiveTypeCheckers[_key2] = arguments[_key2];\n      }\n\n      var typeNames = checkers.map(function (tc) {\n        if (recursiveTypeCheckers.includes(tc)) {\n          return \"...\";\n        }\n\n        return tc.getTypeName.apply(tc, recursiveTypeCheckers.concat([tc]));\n      });\n      return \"[\" + typeNames.join(\", \") + \"]\";\n    };\n\n    var thisTc = new TypeChecker(function (array, path) {\n      if (!isArray(array) || array.length !== itemTypes.length) {\n        return new TypeCheckError(path, getTypeName(thisTc), array);\n      }\n\n      for (var i = 0; i < array.length; i++) {\n        var itemChecker = checkers[i];\n\n        if (!itemChecker.unchecked) {\n          var itemError = itemChecker.check(array[i], [].concat(path, [i]));\n\n          if (itemError) {\n            return itemError;\n          }\n        }\n      }\n\n      return null;\n    }, getTypeName, typeInfoGen);\n    return thisTc;\n  }, typeInfoGen);\n}\n/**\r\n * `types.tuple` type info.\r\n */\n\nvar TupleTypeInfo = /*#__PURE__*/function (_TypeInfo) {\n  _inheritsLoose(TupleTypeInfo, _TypeInfo);\n\n  _createClass(TupleTypeInfo, [{\n    key: \"itemTypeInfos\",\n    // memoize to always return the same array on the getter\n    get: function get() {\n      return this._itemTypeInfos();\n    }\n  }]);\n\n  function TupleTypeInfo(thisType, itemTypes) {\n    var _this;\n\n    _this = _TypeInfo.call(this, thisType) || this;\n    _this.itemTypes = void 0;\n    _this._itemTypeInfos = lateVal(function () {\n      return _this.itemTypes.map(getTypeInfo);\n    });\n    _this.itemTypes = itemTypes;\n    return _this;\n  }\n\n  return TupleTypeInfo;\n}(TypeInfo);\n\nvar types = {\n  literal: typesLiteral,\n  undefined: typesUndefined,\n  \"null\": typesNull,\n  \"boolean\": typesBoolean,\n  number: typesNumber,\n  string: typesString,\n  or: typesOr,\n  maybe: typesMaybe,\n  maybeNull: typesMaybeNull,\n  array: typesArray,\n  record: typesRecord,\n  unchecked: typesUnchecked,\n  model: typesModel,\n  object: typesObject,\n  ref: typesRef,\n  frozen: typesFrozen,\n  \"enum\": typesEnum,\n  refinement: typesRefinement,\n  integer: typesInteger,\n  nonEmptyString: typesNonEmptyString,\n  objectMap: typesObjectMap,\n  arraySet: typesArraySet,\n  tuple: typesTuple,\n  mapArray: function mapArray(valueType) {\n    return typesArray(typesTuple(typesString, valueType));\n  },\n  setArray: function setArray(valueType) {\n    return typesArray(valueType);\n  },\n  mapObject: function mapObject(valueType) {\n    return typesRecord(valueType);\n  },\n  dateString: typesNonEmptyString,\n  dateTimestamp: typesInteger\n};\n\nexport { ActionContextActionType, ActionContextAsyncStepType, ActionTrackingResult, ArraySet, ArraySetTypeInfo, ArrayTypeInfo, BaseModel, BooleanTypeInfo, BuiltInAction, Draft, ExtendedModel, Frozen, FrozenCheckMode, FrozenTypeInfo, HookAction, InternalPatchRecorder, LiteralTypeInfo, MobxKeystoneError, Model, ModelAutoTypeCheckingMode, ModelTypeInfo, NumberTypeInfo, ObjectMap, ObjectMapTypeInfo, ObjectTypeInfo, OrTypeInfo, RecordTypeInfo, Ref, RefTypeInfo, RefinementTypeInfo, SandboxManager, StringTypeInfo, TupleTypeInfo, TypeCheckError, TypeInfo, UncheckedTypeInfo, UndoManager, UndoStore, WalkTreeMode, _async, _await, abstractModelClass, actionCallToReduxAction, actionTrackingMiddleware, addActionMiddleware, addActionToFnModel, addHiddenProp, addLateInitializationFunction, applyAction, applyDelete, applyMethodCall, applyPatches, applySerializedActionAndSyncNewModelIds, applySerializedActionAndTrackNewModelIds, applySet, applySnapshot, arraySet, asMap, asReduxStore, asSet, assertCanWrite, assertFnModelKeyNotInUse, assertIsFunction, assertIsMap, assertIsModel, assertIsModelClass, assertIsObject, assertIsObservableArray, assertIsObservableObject, assertIsPlainObject, assertIsPrimitive, assertIsSet, assertIsString, assertIsTreeNode, assertTweakedObject, baseModelPropNames, canWrite, cannotSerialize, checkModelDecoratorArgs, clone, computedWalkTreeAggregate, connectReduxDevTools, createContext, customRef, debugFreeze, decorateWrapMethodOrField, decoratedModel, deepEquals, deleteFromArray, deserializeActionCall, deserializeActionCallArgument, detach, draft, extendFnModelActions, extendFnModelSetterActions, extendFnModelViews, failure, fastGetParent, fastGetParentIncludingDataObjects, fastGetParentPath, fastGetParentPathIncludingDataObjects, fastGetRoot, fastGetRootPath, fastGetRootStore, fastIsModelDataObject, fastIsRootStore, findParent, findParentPath, flow, fnArray, fnModel, fnObject, fromSnapshot, frozen, frozenKey, getActionMiddlewares, getActionProtection, getChildrenObjects, getCurrentActionContext, getFnModelAction, getGlobalConfig, getMobxVersion, getModelDataType, getModelRefId, getNodeSandboxManager, getParent, getParentPath, getParentToChildPath, getRefsResolvingTo, getRoot, getRootPath, getRootStore, getSnapshot, getTypeInfo, inDevMode, instanceCreationDataTypeSymbol, instanceDataTypeSymbol, internalApplyDelete, internalApplyMethodCall, internalApplyPatches, internalCustomRef, internalPatchRecorder, isArray, isBuiltInAction, isChildOfParent, isFrozenSnapshot, isHookAction, isMap, isModel, isModelAction, isModelAutoTypeCheckingEnabled, isModelClass, isModelDataObject, isModelFlow, isModelSnapshot, isObject, isParentOfChild, isPlainObject, isPrimitive, isRefOfType, isReservedModelKey, isRoot, isRootStore, isSandboxedNode, isSet, isTreeNode, isTweakedObject, jsonPatchToPatch, jsonPointerToPath, lateVal, lazy, logWarning, makePropReadonly, mapToArray, mapToObject, mobx6, model, modelAction, modelClass, modelFlow, modelIdKey, modelInitializedSymbol, modelSnapshotInWithMetadata, modelSnapshotOutWithMetadata, modelTypeKey, noDefaultValue, objectMap, onActionMiddleware, onChildAttachedTo, onGlobalPatches, onPatches, onSnapshot, patchRecorder, patchToJsonPatch, pathToJsonPointer, prop, propTransform, prop_dateString, prop_dateTimestamp, prop_mapArray, prop_mapObject, prop_setArray, propsCreationDataTypeSymbol, propsDataTypeSymbol, readonlyMiddleware, reduxActionType, registerActionCallArgumentSerializer, registerRootStore, resolvePath, resolvePathCheckingIds, rootRef, runLateInitializationFunctions, runUnprotected, runWithoutSnapshotOrPatches, runningWithoutSnapshotOrPatches, sandbox, serializeActionCall, serializeActionCallArgument, setCurrentActionContext, setGlobalConfig, setToArray, simplifyActionContext, skipIdChecking, stringAsDate, tProp, tProp_dateString, tProp_dateTimestamp, tProp_mapArray, tProp_mapObject, tProp_setArray, tag, timestampAsDate, toTreeNode, transaction, transactionMiddleware, tryUntweak, tweak, tweakedObjects, typeCheck, types, undoMiddleware, unregisterRootStore, walkTree, withoutUndo };\n//# sourceMappingURL=mobxkeystone.esm.js.map\n"],"names":["module","exports","equal","a","b","constructor","length","i","keys","Array","isArray","Map","size","entries","has","get","Set","ArrayBuffer","isView","RegExp","source","flags","valueOf","Object","prototype","toString","hasOwnProperty","call","key","getRandomValues","rnds8","Uint8Array","rng","crypto","bind","msCrypto","Error","uuid","byteToHex","push","substr","arr","offset","arguments","undefined","toLowerCase","TypeError","options","buf","rnds","random","__decorate","decorators","target","desc","d","c","r","getOwnPropertyDescriptor","Reflect","decorate","defineProperty","create","ActionContextActionType","ActionContextAsyncStepType","currentActionContext","getCurrentActionContext","setCurrentActionContext","ctx","_defineProperties","props","descriptor","enumerable","configurable","writable","_createClass","Constructor","protoProps","staticProps","_extends","assign","apply","this","_inheritsLoose","subClass","superClass","__proto__","_getPrototypeOf","o","setPrototypeOf","getPrototypeOf","_setPrototypeOf","p","_isNativeReflectConstruct","construct","sham","Proxy","Date","e","_construct","Parent","args","Class","instance","Function","_wrapNativeSuper","_cache","fn","indexOf","set","Wrapper","value","_arrayLikeToArray","len","arr2","_createForOfIteratorHelperLoose","allowArrayLike","it","Symbol","iterator","minLen","n","slice","name","from","test","_unsupportedIterableToArray","done","next","MobxKeystoneError","_Error","msg","_this","self","ReferenceError","_assertThisInitialized","failure","writableHiddenPropDescriptor","addHiddenProp","object","propName","isPlainObject","isObject","proto","isPrimitive","deleteFromArray","array","index","splice","isMap","val","isObservableMap","isSet","isObservableSet","isObservableArray","assertIsObject","argName","assertIsFunction","assertIsString","decoratorsSymbol","addLateInitializationFunction","decoratorsArray","decorateWrapMethodOrField","decoratorName","data","wrap","propertyKey","baseDescriptor","addFieldDecorator","warningsAlreadyDisplayed","logWarning","type","uniqueKey","add","console","warn","error","notMemoized","lateVal","getter","memoized","lazy","valueGen","inited","mobx6","makeObservable","getMobxVersion","ModelAutoTypeCheckingMode","localId","localBaseId","shortenUuid","globalConfig","modelAutoTypeChecking","DevModeOnly","modelIdGenerator","id","allowUndefinedArrayElements","showDuplicateModelNameWarnings","getGlobalConfig","isModelAutoTypeCheckingEnabled","AlwaysOff","AlwaysOn","hexMatch","split","join","match","input","g","Buffer","btoa","charCode","str","String","output","block","idx","map","charAt","charCodeAt","toBase64","fromCharCode","parseInt","noDefaultValue","prop","arg1","arg2","def","opts","hasDefaultValue","isDefFn","$propValueType","$propCreationValueType","$isOptional","$instanceValueType","$instanceCreationValueType","defaultFn","defaultValue","typeChecker","transform","memoTransformCache","MemoTransformCache","cache","WeakMap","getOrCreateMemoTransform","baseTransform","transformsPerProperty","propSetter","lastPropValue","lastDataValue","memoTransform","newPropValue","$","valueNotMemoized","isMemoPropTransform","propToData","propValue","dataToProp","newDataValue","objectParents","objectParentsAtoms","createParentPathAtom","obj","atom","createAtom","reportParentPathChanged","node","reportChanged","dataObjectParent","dataToModelNode","modelNode","modelToDataNode","isModel","tweakedObjects","isTweakedObject","canBeDataObject","isTreeNode","assertTweakedObject","treeNode","runningWithoutSnapshotOrPatches","modelTypeKey","modelIdKey","isReservedModelKey","defaultObservableSetOptions","deep","objectChildren","getObjectChildren","shallow","getDeepObjectChildren","deepDirty","updateDeepObjectChildren","deepAtom","reportObserved","deepByModelTypeAndId","addNodeToDeepLists","byModelTypeAndIdKey","action","childrenIter","values","ch","retIter","retCur","addObjectChild","child","invalidateDeepChildren","removeObjectChild","parent","fastGetParent","modelType","modelId","fastGetParentPath","fastGetParentPathIncludingDataObjects","parentModel","path","parentPath","computedsGetRootPath","fastGetRootPath","computedGetRootPathForNode","computed","rootPath","root","pathObjects","unshift","internalGetRootPath","fastGetRoot","isChildOfParent","unresolved","resolved","resolvePath","pathRootObject","current","skipIdChecking","resolvePathCheckingIds","pathIds","currentMaybeModel","expectedId","snapshots","getInternalSnapshot","unsetInternalSnapshot","oldSn","setInternalSnapshot","standard","sn","untracked","parentSn","parentSnapshot","getInternalSnapshotParent","parentStandardSn","getSnapshot","nodeOrPrimitive","snapshot","modelDataTypeCheckerSymbol","modelUnwrappedClassSymbol","getModelDataType","modelClassOrInstance","isModelClass","modelInfoByName","modelInfoByClass","getModelInfoForName","modelPropertiesSymbol","getInternalModelClassPropsInfo","modelClass","TypeCheckError","expectedTypeName","actualValue","typeCheckedValue","concat","emptyPath","typeCheckersWithCachedResultsOfObject","TypeChecker","_proto","_check","getTypeName","typeInfoGen","checkResultCache","unchecked","_cachedTypeInfoGen","createCacheIfNeeded","setCachedResult","newCacheValue","typeCheckerSet","invalidateCachedResult","getCachedResult","check","cachedResult","lateTypeCheckerSymbol","lateTypeChecker","cached","ltc","cachedTypeInfoGen","isLateTypeChecker","TypeInfo","thisType","getTypeInfo","typeInfo","resolveStandardType","typesLiteral","literal","typeName","assertIsPrimitive","JSON","stringify","t","LiteralTypeInfo","_TypeInfo","typesUndefined","typesNull","typesBoolean","BooleanTypeInfo","_TypeInfo2","typesNumber","NumberTypeInfo","_TypeInfo3","typesString","StringTypeInfo","_TypeInfo4","resolveTypeChecker","v","Number","Boolean","cachedModelTypeChecker","typesModel","modelClazz","assertIsModelClass","cachedTypeChecker","_typeInfoGen","ModelTypeInfo","tc","modelInfo","dataTypeChecker","resolvedTc","_props","objSchema","propTypes","forEach","propData","hasDefault","typeCheck","assertCanWrite","getActionProtection","actionProtection","HookAction","pendingActions","isActionRunning","tryRunPendingActions","shift","nextAction","perObjectActionMiddlewares","perObjectActionMiddlewaresIterator","getActionMiddlewares","_iterable","iterable","getCurrentIterator","objMwares","findNextIterator","nextIter","iter","result","WalkTreeMode","modelActionSymbol","wrapInAction","_ref","actionType","overrideContext","_ref$isFlowFinisher","isFlowFinisher","wrappedAction","_fn","parentContext","context","actionName","rootContext","previousAsyncStepContext","mwareFn","mwareIter","mwareCur","mware","filterPassed","filter","middleware","ret","flowFinisher","resolution","accepter","rejecter","wrapModelMethodInActionIfNeeded","model","isModelAction","wrappedFn","Sync","walkTree","predicate","mode","ParentFirst","walkTreeParentFirst","recurse","walkTreeChildrenFirst","_recurse","rootPredicate","_ret","_ret2","computedWalkTreeAggregate","computedFns","getComputedTreeResult","tree","cmpted","rootVal","childrenMap","childMap","mapIter","mapCur","walkTreeAggregate","walk","onAttachedDisposers","attachToRootStore","rootStore","childrenToCall","BaseModel","onAttachedToRootStore","OnAttachedToRootStore","childrenToCallLen","disposer","detachFromRootStore","disposersToCall","disposerAction","OnAttachedToRootStoreDisposer","ChildrenFirst","disposersToCallLen","rootStores","WeakSet","rootStoreAtoms","registerRootStore","getOrCreateRootStoreAtom","isRootStore","fastIsRootStore","setParent","indexChangeAllowed","isDataObject","observable","actualParent","oldParentPath","parentPath2","comparePath","parentPath1","removeFromOldParent","attachToNewParent","_parentPath","oldRoot","oldRootStore","newRoot","newRootStore","enqueuePendingAction","tweakModel","FrozenCheckMode","InternalPatchRecorder","patches","invPatches","record","emit","emitPatch","patchListeners","globalPatchListeners","onPatches","subtreeRoot","listener","isAction","listenersForObject","inversePatches","emitGlobally","_i","_listener","childPath","newPatches","addPathToPatch","newInversePatches","patch","BuiltInAction","Frozen","dataToFreeze","checkMode","On","checkDataIsSerializableAndFreeze","freeze","tweak","frozen","arrLen","dataKeys","dataKeysLen","k","_v","isFrozenSnapshot","findParent","maxDepth","foundParentPath","depth","findParentPath","detach","wrappedInternalDetach","Detach","internalDetach","isObservableObject","remove","fromSnapshot","generateNewIds","overrideRootModelId","snapshotToInitialData","internalFromSnapshot","observableOptions","ln","tweakArray","fromArraySnapshot","isModelSnapshot","snapshotInitialData","unprocessedSnapshot","fromModelSnapshot","plainObj","snKeys","snKeysLen","tweakPlainObject","fromPlainObjectSnapshot","processedSn","initialData","processedSnKeys","processedSnKeysLen","reconcileSnapshot","modelPool","oldValue","newValue","detachIfNeeded","reconcileArraySnapshot","reconcileFrozenSnapshot","modelInPool","findModelForSnapshot","modelObj","_i2","_k","reconcileModelSnapshot","plainObjKeys","plainObjKeysLen","_i3","_k2","reconcilePlainObjectSnapshot","findModelByTypeAndId","ModelPool","_dataObjectParent$get","pool","applyPatches","reverse","wrappedInternalApplyPatches","internalApplyPatches","j","applySinglePatch","_p","len2","_j","ApplyPatches","_pathArrayToObjectAnd","pathArrayToObjectAndProp","op","_index","_index2","_newValue","_newValue2","_newValue3","runTypeCheckingAfterChange","patchRecorder","_step","_iterator","invalidateCachedTypeCheckerResult","parentModelWithTypeChecker","actualChild","findNearestParentModelWithTypeChecker","err","old","runInAction","runWithoutSnapshotOrPatches","doNotTweakChildren","interceptDisposer","observeDisposer","originalArr","arrLn","tweakedArr","observableOptions$1","standardSn","tweakedValue","valueSn","intercept","interceptArrayMutation","observe","arrayDidChange","change","oldSnapshot","newSnapshot","addedCount","removedCount","addedItems","added","oldLen","realIndex","newVal","oldVal","interimLen","removeUsingSetLength","_realIndex","_path","restoreUsingSetLength","_realIndex2","_path2","_oldVal","_path3","_i4","removedValue","tryUntweak","_i5","oldNextIndex","newNextIndex","_i6","toTreeNode","internalTweak","frozenObj","_setInternalSnapshot","tweakFrozen","untweaker","children","childrenCur","snapshotModelType","originalObj","tweakedObj","observableOptions$2","originalObjKeys","originalObjKeysLen","interceptObjectMutation","objectDidChange","actualNode","_oldVal2","modelInitializersSymbol","internalNewModel","origModelObj","_modelClass","modelProps","modelPropsKeys","obsData","initializers","getModelClassInitializers","init","propsDataTypeSymbol","propsCreationDataTypeSymbol","instanceDataTypeSymbol","instanceCreationDataTypeSymbol","modelInitializedSymbol","_arguments$","propsWithTransforms","propsWithTransformsLen","propWithTransform","propTransform","getRefId","finalOptions","withData","firstPart","baseModelPropNames","checkModelDecoratorArgs","fnName","errMessage","modelAction","checkModelActionArgs","modelFlowSymbol","flow","generator","flowFn","_len","_key","ctxOverride","stepType","spawnAsyncStepContext","asyncStepType","generatorRun","gen","Async","Spawn","Promise","resolve","genNext","genThrow","promise","reject","onFulfilled","res","Resume","Throw","onRejected","ResumeError","then","Return","isModelFlow","modelFlow","checkModelFlowArgs","_async","_await","promiseGenerator","thisArg","body","f","y","_","label","sent","trys","ops","verb","pop","step","_a","assertFnModelKeyNotInUse","fnModelObj","fnModelActionRegistry","extendFnModelActions","namespace","actions","_Object$entries","_Object$entries$_i","addActionToFnModel","isFlow","fullActionName","applySnapshot","wrappedInternalApplySnapshot","internalApplySnapshot","reconcile","ApplySnapshot","internalApplyDelete","fieldName","wrappedInternalApplyDelete","ApplyDelete","internalApplyMethodCall","methodName","wrappedInternalApplyMethodCall","ApplyMethodCall","applySet","wrappedInternalApplySet","internalApplySet","isObservable","_builtInActionToFunct","ApplySet","cannotSerialize","arraySerializer","serialize","_serialize","deserialize","_deserialize","dateSerializer","date","timestamp","mapSerializer","cur","rootPathToTargetPathIds","targetPathIds","targetObj","targetObjId","objectPathSerializer","targetRoot","targetPath","ref","objectSnapshotSerializer","plainObjectSerializer","mapObjectFields","mapFn","setSerializer","serializersArray","serializersMap","registerActionCallArgumentSerializer","serializer","includes","typesObjectHelper","objFn","objectSchema","schemaEntries","propsMsg","recursiveTypeCheckers","_step$value","unresolvedTc","propTypename","thisTc","_step2","_iterator2","_step2$value","objVal","valueError","typesObject","objectFunction","ObjectTypeInfo","_objTypeFn","UncheckedTypeInfo","typesUnchecked","Model","internalModel","baseModel","_baseModel","unwrappedClass","extraDescriptors","composedModelProps","oldModelProps","_Object$keys","oldModelPropKey","createModelPropDescriptor","some","mp","typeCheckerObj","modelPropName","extraPropNames","extraPropNamesLen","base","_ref2","CustomBaseModel","_base","constructorOptions","_constructorOptions$m","extraPropName","setInternalModelClassPropsInfo","defineProperties","modelProp","getModelInstanceDataField","setterAction","setModelInstanceDataField","ActionTrackingResult","clazz","internalModel$1","newClazz","fns","runLateInitializationFunctions","message","onInit","OnInit","actionTrackingMiddleware","hooks","dataSymbol","getCtxData","setCtxData","partialData","currentData","userFilter","simplifyActionContext","resumeSuspendSupport","onResume","onSuspend","start","simpleCtx","state","onStart","finish","parentCtx","parentResumed","parentData","startAccepted","resume","onFinish","suspend","real","targetFilter","customFilter","actualMware","addActionMiddleware","origNext","retObj","returnOrThrowActionTrackingReturn","_retObj","_retObj2","_flowFinisher","_retObj3","accepted","_accepted","_data","simpleDataContextSymbol","internalPatchRecorder","onPatchesDisposer","_recording$filter$opt","recording","alwaysAcceptFilter","events","invP","enabled","dispose","typesArray","itemType","ArrayTypeInfo","itemChecker","itemError","tProp","typeOrDefaultValue","UndoStore","_Model","_clearUndo","withoutUndo","undoEvents","_clearRedo","_this2","redoEvents","_undo","_this3","event","_redo","_this4","_addUndo","_this5","UndoManager","_proto2","store","clearUndo","clearRedo","undo","_this6","canUndo","undoQueue","redo","_this7","canRedo","redoQueue","undoLevels","redoLevels","undoMiddleware","manager","patchRecorderSymbol","getPatchRecorderData","middlewareDisposer","recorder","undoDisabledFilter","recorderStack","undoRootContext","initPatchRecorder","patchRecorderData","_patchRecorder","undoDisabled","savedUndoDisabled","getContextValue","contextValue","ContextClass","defaultContextValue","nodeContextValue","nodeAtom","setDefault","getNodeAtom","atomPerNode","fastGet","obsForNode","getDefault","fastGetProviderNode","getProviderNode","setDefaultComputed","valueFn","setComputed","unset","extendFnModelFlowActions","flowActions","extendFnModelSetterActions","setterActions","_loop","extendFnModelViews","views","fnOrFnWithOptions","computedsPerObject","equals","computedFn","fnModel","actualType","fnModelCreateWithType","fnModelCreateWithoutType","errors","_fnArray","setLength","copyWithin","end","fill","sort","compareFn","_fnObject","partialObject","_keys","onSnapshot","currentSnapshot","reaction","prevSn","Ref","maybeCurrent","objectBackRefs","internalCustomRef","modelTypeId","resolverGen","getId","onResolvedValueChange","_temp","CustomRef","_Ref","resolver","savedOldTarget","savedFirstTime","newTarget","oldTarget","firstTime","refClass","getBackRefs","updateBackRefs","fireImmediately","getModelRefId","refType","backRefs","all","byType","computedIdTrees","rootRef","_options$getId","computedIdTree","cachedTarget","refRoot","isRefRootCachedTargetOk","idMap","deepEquals","toJS","toJSOptions","exportMapsAsObjects","recurseEverything","Draft","original","originalData","originalSnapshot","commit","commitByPath","draftTarget","draftPathIds","pathToTargetPathIdsIgnoringLast","reset","resetByPath","originalTarget","originalPathIds","isDirtyByPath","pathToTargetPathIds","ArraySet","items","clear","findIndex","callbackfn","toStringTag","typesRecord","valueType","RecordTypeInfo","valueChecker","ObjectMap"],"sourceRoot":""}