Module: packages/mobx-state-tree/src/types/utility-types/refinement

function 𝓟42{CONSTRUCTOR} (𝓟43{name}: 𝓛[ty]10051{String},𝓟44{type}: [OOV]𝓟[ty]6960{IType},𝓟45{predicate}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟46{message}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]50{Refinement})
{
  const 𝓟[ty]50{Refinement};
  const 𝓟[ty]50{Refinement};
  𝓟[ty]50{Refinement}(𝓟43{name})
  𝓟[ty]50{Refinement}.type ⟵ 𝓟44{type};
  𝓟[ty]50{Refinement}.predicate ⟵ 𝓟45{predicate};
  𝓟[ty]50{Refinement}.message ⟵ 𝓟46{message};
}
class 𝓟[ty]50{Refinement} extends 𝓟[ty]2778{Type}{
  𝓟52{type}: [OOV]𝓟[ty]6960{IType};
  𝓟53{predicate}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function});
  𝓟54{message}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function});
  function 𝓟55{flags} (): (𝓟56)
  {
    return 𝓟56 = 𝓟[ty]50{Refinement}.type.flags.BarToken(𝓟2693{TypeFlags}.Refinement)
  }
  function 𝓟59{describe} (): (𝓟60: [miss]𝓛[ty]10051{String})
  {
    return 𝓟60 = 𝓟[ty]50{Refinement}.name
  }
  function 𝓟61{instantiate} (𝓟62{parent}: [OOV]𝓟[ty]6979{INode},𝓟63{subpath}: 𝓛[ty]10051{String},𝓟64{environment}: [OOV]any,𝓟65{value}: [OOV]any): (𝓟66: [OOV]𝓟[ty]6979{INode})
  {
    const 𝓟67{inst}: [OOV]𝓟[ty]6979{INode} = 𝓟[ty]50{Refinement}.type.instantiate(𝓟62{parent},𝓟63{subpath},𝓟64{environment},𝓟65{value});
    return 𝓟66 = 𝓟67{inst}
  }
  function 𝓟71{isValidSnapshot} (𝓟72{value}: [OOV]any,𝓟73{context}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟74: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
  {
    const 𝓟75{subtypeErrors}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]50{Refinement}.type.validate(𝓟72{value},𝓟73{context});
    if (𝓟75{subtypeErrors}.length.GreaterThanToken(𝓛8745{Number}))
    {
      return 𝓟74 = 𝓟75{subtypeErrors}
    }
    const 𝓟76{snapshot} = (𝓟673{isStateTreeNode}(𝓟72{value}) ? 𝓟676{getStateTreeNode}(𝓟72{value}).snapshot : 𝓟72{value};
    if (𝓛12548{ExclamationToken}(𝓟[ty]50{Refinement}.predicate(𝓟76{snapshot})))
    {
      return 𝓟74 = 𝓟1319{typeCheckFailure}(𝓟73{context},𝓟72{value},𝓟[ty]50{Refinement}.message(𝓟72{value}))
    }
    return 𝓟74 = 𝓟1317{typeCheckSuccess}()
  }
  function 𝓟68{isAssignableFrom} (𝓟69{type}: [OOV]𝓟[ty]6960{IType}): (𝓟70: [miss]𝓛[ty]8666{Boolean})
  {
    return 𝓟70 = 𝓟[ty]50{Refinement}.type.isAssignableFrom(𝓟69{type})
  }
  function 𝓟57{shouldAttachNode} (): (𝓟58)
  {
    return 𝓟58 = 𝓟[ty]50{Refinement}.type.shouldAttachNode
  }
}
function 𝓟77{refinement} (𝓟78{name}: 𝓛[ty]10051{String},𝓟79{type}: [OOV]𝓟[ty]6960{IType},𝓟80{predicate}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟81{message}: [OOV]any): (𝓟82: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟83{refinement} (𝓟84{name}: 𝓛[ty]10051{String},𝓟85{type}: [OOV]𝓟[ty]6960{IType},𝓟86{predicate}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟87{message}: [OOV]any): (𝓟88: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟89{refinement} (𝓟90{type}: [OOV]𝓟[ty]6960{IType},𝓟91{predicate}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟92{message}: [OOV]any): (𝓟93: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟94{refinement} (𝓟95{type}: [OOV]𝓟[ty]6960{IType},𝓟96{predicate}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟97{message}: [OOV]any): (𝓟98: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟99{refinement} (𝓟100{args}: 𝓛[ty]8670{Array}): (𝓟101: [OOV]𝓟[ty]6960{IType})
{
  const 𝓟102{name} = (𝓛12550{$TypeOf}(𝓟100{args}.access(𝓛8745{Number})).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟100{args}.shift() : (𝓟2822{isType}(𝓟100{args}.access(𝓛8745{Number})) ? 𝓟100{args}.access(𝓛8745{Number}).name : 𝓛12563{undefined};
  const 𝓟103{type} = 𝓟100{args}.access(𝓛8745{Number});
  const 𝓟104{predicate} = 𝓟100{args}.access(𝓛8745{Number});
  function 𝓟105{$Lambda114} (𝓟106{v}: [OOV]any): (𝓟107: [miss]𝓛[ty]10051{String})
  {
    return 𝓟107 = 𝓛8743{String}
  }
  const 𝓟108{message} = (𝓟100{args}.access(𝓛8745{Number}) ? 𝓟100{args}.access(𝓛8745{Number}) : 𝓟105{$Lambda114};
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12550{$TypeOf}(𝓟102{name}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟102{name}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12548{ExclamationToken}(𝓟2822{isType}(𝓟103{type})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟103{type}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12550{$TypeOf}(𝓟104{predicate}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟104{predicate}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12550{$TypeOf}(𝓟108{message}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟108{message}).PlusToken(𝓛8743{String}))
    }
  }
  return 𝓟101 = 𝓟42{CONSTRUCTOR}(𝓟102{name},𝓟103{type},𝓟104{predicate},𝓟108{message})
}
function 𝓟109{isRefinementType} (𝓟110{type}: [OOV]any): (𝓟111: 𝓛[ty]8666{Boolean})
{
  return 𝓟111 = 𝓟110{type}.flags.AmpersandToken(𝓟2693{TypeFlags}.Refinement).GreaterThanToken(𝓛8745{Number})
}

Module: packages/mobx-state-tree/src/types/primitives

function 𝓟112{CONSTRUCTOR} (𝓟113{name}: [OOV]any,𝓟114{flags}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟115{checker}: [OOV]any,𝓟116{initializer}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]120{CoreType})
{
  const 𝓟[ty]120{CoreType};
  const 𝓟[ty]120{CoreType};
  𝓟[ty]120{CoreType}.shouldAttachNode ⟵ 𝓛8744{Boolean};
  𝓟[ty]120{CoreType}(𝓟113{name})
  𝓟[ty]120{CoreType}.flags ⟵ 𝓟114{flags};
  𝓟[ty]120{CoreType}.checker ⟵ 𝓟115{checker};
  𝓟[ty]120{CoreType}.initializer ⟵ 𝓟116{initializer};
}
class 𝓟[ty]120{CoreType} extends 𝓟[ty]2778{Type}{
  𝓟122{shouldAttachNode}: [miss]𝓛[ty]8666{Boolean};
  𝓟123{checker}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function});
  𝓟124{flags}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8655{Number});
  𝓟125{initializer}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function});
  function 𝓟126{describe} (): (𝓟127: [miss]𝓛[ty]10051{String})
  {
    return 𝓟127 = 𝓟[ty]120{CoreType}.name
  }
  function 𝓟128{instantiate} (𝓟129{parent}: [OOV]any,𝓟130{subpath}: 𝓛[ty]10051{String},𝓟131{environment}: [OOV]any,𝓟132{snapshot}: [OOV]any): (𝓟133: [OOV]𝓟[ty]6979{INode})
  {
    return 𝓟133 = 𝓟2551{createNode}(𝓟[ty]120{CoreType},𝓟129{parent},𝓟130{subpath},𝓟131{environment},𝓟132{snapshot},𝓟[ty]120{CoreType}.initializer)
  }
  function 𝓟134{isValidSnapshot} (𝓟135{value}: [OOV]any,𝓟136{context}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟137: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
  {
    if (𝓟452{isPrimitive}(𝓟135{value}).AmpersandAmpersandToken(𝓟[ty]120{CoreType}.checker(𝓟135{value})))
    {
      return 𝓟137 = 𝓟1317{typeCheckSuccess}()
    }
    const 𝓟138{typeName}: [miss]𝓛[ty]10051{String} = (𝓟[ty]120{CoreType}.name.EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓛8743{String} : 𝓟[ty]120{CoreType}.name;
    return 𝓟137 = 𝓟1319{typeCheckFailure}(𝓟136{context},𝓟135{value},𝓛12554{$Template}(𝓟138{typeName}))
  }
}
function 𝓟139{$Lambda46} (𝓟140{v}: [OOV]any): (𝓟141: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟141 = 𝓛12550{$TypeOf}(𝓟140{v}).EqualsEqualsEqualsToken(𝓛8743{String})
}
const 𝓟142{string}: [OOV]𝓟[ty]6944{ISnapshottable} = 𝓟112{CONSTRUCTOR}(𝓛8743{String},𝓟2693{TypeFlags}.String,𝓟139{$Lambda46});
function 𝓟143{$Lambda47} (𝓟144{v}: [OOV]any): (𝓟145: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟145 = 𝓛12550{$TypeOf}(𝓟144{v}).EqualsEqualsEqualsToken(𝓛8743{String})
}
const 𝓟146{number}: [OOV]𝓟[ty]6944{ISnapshottable} = 𝓟112{CONSTRUCTOR}(𝓛8743{String},𝓟2693{TypeFlags}.Number,𝓟143{$Lambda47});
function 𝓟147{$Lambda48} (𝓟148{v}: [OOV]any): (𝓟149: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟149 = 𝓛12550{$TypeOf}(𝓟148{v}).EqualsEqualsEqualsToken(𝓛8743{String})
}
const 𝓟150{boolean}: [OOV]𝓟[ty]6944{ISnapshottable} = 𝓟112{CONSTRUCTOR}(𝓛8743{String},𝓟2693{TypeFlags}.Boolean,𝓟147{$Lambda48});
function 𝓟151{$Lambda49} (𝓟152{v}: [OOV]any): (𝓟153: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟153 = 𝓟152{v}.EqualsEqualsEqualsToken(𝓛12563{undefined})
}
const 𝓟154{nullType}: [OOV]𝓟[ty]6944{ISnapshottable} = 𝓟112{CONSTRUCTOR}(𝓛8743{String},𝓟2693{TypeFlags}.Null,𝓟151{$Lambda49});
function 𝓟155{$Lambda50} (𝓟156{v}: [OOV]any): (𝓟157: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟157 = 𝓟156{v}.EqualsEqualsEqualsToken(𝓛12563{undefined})
}
const 𝓟158{undefinedType}: [OOV]𝓟[ty]6944{ISnapshottable} = 𝓟112{CONSTRUCTOR}(𝓛8743{String},𝓟2693{TypeFlags}.Undefined,𝓟155{$Lambda50});
function 𝓟159{$Lambda51} (𝓟160{v}: [OOV]any): (𝓟161: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟161 = 𝓛12550{$TypeOf}(𝓟160{v}).EqualsEqualsEqualsToken(𝓛8743{String}).BarBarToken(𝓟160{v}.InstanceOfKeyword(𝓛8747{Date}))
}
function 𝓟162{$Lambda52} (𝓟163{v}: [OOV]any): (𝓟164: [miss]𝓛[ty]8635{Date})
{
  return 𝓟164 = (𝓟163{v}.InstanceOfKeyword(𝓛8747{Date}) ? 𝓟163{v} : 𝓛8747{Date}.CONSTRUCTOR(𝓟163{v})
}
const 𝓟165{DatePrimitive}: [OOV]𝓟[ty]6960{IType} = 𝓟112{CONSTRUCTOR}(𝓛8743{String},𝓟2693{TypeFlags}.Date,𝓟159{$Lambda51},𝓟162{$Lambda52});
function 𝓟166{$Lambda53} (𝓟167{node}: [OOV]𝓟[ty]6979{INode}): (𝓟168: [OOV]any)
{
  return 𝓟168 = 𝓟167{node}.storedValue.getTime()
}
𝓟165{DatePrimitive} as any.getSnapshot ⟵ 𝓟166{$Lambda53};
function 𝓟169{getPrimitiveFactoryFromValue} (𝓟170{value}: [OOV]any): (𝓟171: [OOV]𝓟[ty]6944{ISnapshottable})
{
  𝓛12549{$Switch}(𝓛12550{$TypeOf}(𝓟170{value}))
  𝓛12561{$Case}(𝓛8743{String})
  return 𝓟171 = 𝓟142{string}
  𝓛12561{$Case}(𝓛8743{String})
  return 𝓟171 = 𝓟146{number}
  𝓛12561{$Case}(𝓛8743{String})
  return 𝓟171 = 𝓟150{boolean}
  𝓛12561{$Case}(𝓛8743{String})
  if (𝓟170{value}.InstanceOfKeyword(𝓛8747{Date}))
  {
    return 𝓟171 = 𝓟165{DatePrimitive}
  }
  return 𝓟171 = 𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟170{value}))
}
function 𝓟172{isPrimitiveType} (𝓟173{type}: [OOV]any): (𝓟174: 𝓛[ty]8666{Boolean})
{
  return 𝓟174 = 𝓟2822{isType}(𝓟173{type}).AmpersandAmpersandToken(𝓟173{type}.flags.AmpersandToken(𝓟2693{TypeFlags}.String.BarToken(𝓟2693{TypeFlags}.Number).BarToken(𝓟2693{TypeFlags}.Boolean).BarToken(𝓟2693{TypeFlags}.Date)).GreaterThanToken(𝓛8745{Number}))
}

Module: packages/mobx-state-tree/src/core/action

type 𝓛[ty]0{ANY} = any
type 𝓟[ty]6969{IMiddlewareHandler} = (𝓟[ty]6976{IMiddlewareEvent},((𝓟[ty]6976{IMiddlewareEvent})->any))->any
type 𝓟[ty]6976{IMiddlewareEvent} = {name: 𝓛[ty]10051{String}, context: 𝓟[ty]6977{IStateTreeNode}, id: 𝓛[ty]8655{Number}, rootId: 𝓛[ty]8655{Number}, tree: 𝓟[ty]6977{IStateTreeNode}, args: 𝓛[ty]8670{Array}, type: 𝓛[ty]0{ANY}, parentId: 𝓛[ty]8655{Number}}
let 𝓟178{nextActionId}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
let 𝓟179{currentActionContext}: [OOV]any = 𝓛12563{undefined};
function 𝓟180{getNextActionId} (): (𝓟181: [miss]𝓛[ty]8655{Number})
{
  return 𝓟181 = 𝓛12546{POST_PlusPlusToken}(𝓟178{nextActionId})
}
function 𝓟182{runWithActionContext} (𝓟183{context}: [OOV]𝓟[ty]6976{IMiddlewareEvent},𝓟184{fn}: 𝓛[ty]8696{Function}): (𝓟185: [OOV]any)
{
  const 𝓟186{node}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟183{context}.context);
  const 𝓟187{baseIsRunningAction}: [miss]𝓛[ty]8666{Boolean} = 𝓟186{node}._isRunningAction;
  const 𝓟188{prevContext}: [OOV]𝓟[ty]6976{IMiddlewareEvent} = 𝓟179{currentActionContext};
  𝓟186{node}.assertAlive()
  𝓟186{node}._isRunningAction ⟵ 𝓛8744{Boolean};
  𝓟179{currentActionContext} ⟵ 𝓟183{context};
  {
    return 𝓟185 = 𝓟219{runMiddleWares}(𝓟186{node},𝓟183{context},𝓟184{fn})
  }
  {
    𝓟179{currentActionContext} ⟵ 𝓟188{prevContext};
    𝓟186{node}._isRunningAction ⟵ 𝓟187{baseIsRunningAction};
  }
}
function 𝓟189{getActionContext} (): (𝓟190: [OOV]𝓟[ty]6976{IMiddlewareEvent})
{
  if (𝓛12548{ExclamationToken}(𝓟179{currentActionContext}))
  {
    return 𝓟190 = 𝓟376{fail}(𝓛8743{String})
  }
  return 𝓟190 = 𝓟179{currentActionContext}
}
function 𝓟191{createActionInvoker} (𝓟192{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟193{name}: 𝓛[ty]10051{String},𝓟194{fn}: [OOV]any): (𝓟195: [miss]𝓛[ty]8696{Function})
{
  function 𝓟196{$Lambda32} (): (𝓟197: [OOV]any)
  {
    const 𝓟198{id}: [miss]𝓛[ty]8655{Number} = 𝓟180{getNextActionId}();
    return 𝓟197 = 𝓟182{runWithActionContext}({name: 𝓟193{name},context: 𝓟192{target},id: 𝓟198{id},rootId: (𝓟179{currentActionContext} ? 𝓟179{currentActionContext}.rootId : 𝓟198{id},tree: 𝓟605{getRoot}(𝓟192{target}),args: 𝓟498{argsToArray}(𝓛10035{arguments}),type: 𝓛8743{String},parentId: (𝓟179{currentActionContext} ? 𝓟179{currentActionContext}.id : 𝓛8745{Number}},𝓟194{fn})
  }
  return 𝓟195 = 𝓟196{$Lambda32}
}
function 𝓟199{addMiddleware} (𝓟200{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟201{middleware}: [OOV]𝓟[ty]6969{IMiddlewareHandler}): (𝓟202: [OOV]𝓟[ty]6974{IDisposer})
{
  const 𝓟203{node}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟200{target});
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟203{node}.isProtectionEnabled))
    {
      𝓛1{<UNKNOWN>}(𝓛8743{String})
    }
  }
  return 𝓟202 = 𝓟203{node}.addMiddleWare(𝓟201{middleware})
}
function 𝓟204{decorate} (𝓟205{middleware}: [OOV]𝓟[ty]6969{IMiddlewareHandler},𝓟206{fn}: [OOV]any): (𝓟207: [OOV]any)
{
}
function 𝓟208{decorate} (𝓟209{middleware}: [OOV]𝓟[ty]6969{IMiddlewareHandler},𝓟210{fn}: [OOV]any): (𝓟211: [OOV]any)
{
  if (𝓟210{fn}.$mst_middleware)
  {
    𝓟210{fn}.$mst_middleware.push(𝓟209{middleware})
  }
  else
  {
    𝓟210{fn}.$mst_middleware ⟵ 𝓛8757{Array}(𝓟209{middleware});
  }
  return 𝓟211 = 𝓟210{fn}
}
function 𝓟212{collectMiddlewareHandlers} (𝓟213{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟214{baseCall}: [OOV]𝓟[ty]6976{IMiddlewareEvent},𝓟215{fn}: 𝓛[ty]8696{Function}): (𝓟216: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8670{Array}))
{
  let 𝓟217{handlers}: 𝓛[ty]8670{Array} = 𝓟215{fn} as any.$mst_middleware.BarBarToken(𝓟374{EMPTY_ARRAY});
  let 𝓟218{n}: [OOV]any = 𝓟213{node};
  while (𝓟218{n})
  {
    if (𝓟218{n}.middlewares)
    {
      𝓟217{handlers} ⟵ 𝓟217{handlers}.concat(𝓟218{n}.middlewares);
    }
    𝓟218{n} ⟵ 𝓟218{n}.parent;
  }
  return 𝓟216 = 𝓟217{handlers}
}
function 𝓟219{runMiddleWares} (𝓟220{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟221{baseCall}: [OOV]𝓟[ty]6976{IMiddlewareEvent},𝓟222{originalFn}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟223: [OOV]any)
{
  const 𝓟224{handlers}: [miss]𝓛[ty]8670{Array} = 𝓟212{collectMiddlewareHandlers}(𝓟220{node},𝓟221{baseCall},𝓟222{originalFn});
  if (𝓛12548{ExclamationToken}(𝓟224{handlers}.length))
  {
    return 𝓟223 = 𝓟2826{mobxAction}(𝓟222{originalFn}).apply(𝓛12563{undefined},𝓟221{baseCall}.args)
  }
  let 𝓟225{index}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
  function 𝓟226{runNextMiddleware} (𝓟227{call}: [OOV]𝓟[ty]6976{IMiddlewareEvent}): (𝓟228: [OOV]any)
  {
    const 𝓟229{handler}: [OOV]𝓟[ty]6969{IMiddlewareHandler} = 𝓟224{handlers}.access(𝓛12546{POST_PlusPlusToken}(𝓟225{index}));
    if (𝓟229{handler})
    {
      return 𝓟228 = 𝓟229{handler}(𝓟227{call},𝓟226{runNextMiddleware})
    }
    else
    {
      return 𝓟228 = 𝓟2826{mobxAction}(𝓟222{originalFn}).apply(𝓛12563{undefined},𝓟221{baseCall}.args)
    }
  }
  return 𝓟223 = 𝓟226{runNextMiddleware}(𝓟221{baseCall})
}

Module: packages/mobx-state-tree/src/types/utility-types/optional

type 𝓟[ty]6965{IFunctionReturn} = ()->any
type 𝓛[ty]0{ANY} = any
function 𝓟304{CONSTRUCTOR} (𝓟305{type}: [OOV]𝓟[ty]6960{IType},𝓟306{defaultValue}: [OOV]𝓛[ty]0{ANY}): (𝓟[ty]310{OptionalValue})
{
  const 𝓟[ty]310{OptionalValue};
  const 𝓟[ty]310{OptionalValue};
  𝓟[ty]310{OptionalValue}(𝓟305{type}.name)
  𝓟[ty]310{OptionalValue}.type ⟵ 𝓟305{type};
  𝓟[ty]310{OptionalValue}.defaultValue ⟵ 𝓟306{defaultValue};
}
class 𝓟[ty]310{OptionalValue} extends 𝓟[ty]2778{Type}{
  𝓟312{type}: [OOV]𝓟[ty]6960{IType};
  𝓟313{defaultValue}: [OOV]𝓛[ty]0{ANY};
  function 𝓟332{getDefaultValue} (): (𝓟333: [OOV]any)
  {
    const 𝓟334{defaultValue} = (𝓛12550{$TypeOf}(𝓟[ty]310{OptionalValue}.defaultValue).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟[ty]310{OptionalValue}.defaultValue() : 𝓟[ty]310{OptionalValue}.defaultValue;
    if (𝓛12550{$TypeOf}(𝓟[ty]310{OptionalValue}.defaultValue).EqualsEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟1331{typecheck}(𝓟[ty]310{OptionalValue},𝓟334{defaultValue})
    }
    return 𝓟333 = 𝓟334{defaultValue}
  }
  function 𝓟314{flags} (): (𝓟315)
  {
    return 𝓟315 = 𝓟[ty]310{OptionalValue}.type.flags.BarToken(𝓟2693{TypeFlags}.Optional)
  }
  function 𝓟318{describe} (): (𝓟319: [miss]𝓛[ty]10051{String})
  {
    return 𝓟319 = 𝓟[ty]310{OptionalValue}.type.describe().PlusToken(𝓛8743{String})
  }
  function 𝓟320{instantiate} (𝓟321{parent}: [OOV]𝓟[ty]6979{INode},𝓟322{subpath}: 𝓛[ty]10051{String},𝓟323{environment}: [OOV]any,𝓟324{value}: [OOV]any): (𝓟325: [OOV]𝓟[ty]6979{INode})
  {
    if (𝓛12550{$TypeOf}(𝓟324{value}).EqualsEqualsEqualsToken(𝓛8743{String}))
    {
      const 𝓟326{defaultValue} = 𝓟[ty]310{OptionalValue}.getDefaultValue();
      const 𝓟327{defaultSnapshot} = (𝓟673{isStateTreeNode}(𝓟326{defaultValue}) ? 𝓟676{getStateTreeNode}(𝓟326{defaultValue}).snapshot : 𝓟326{defaultValue};
      return 𝓟325 = 𝓟[ty]310{OptionalValue}.type.instantiate(𝓟321{parent},𝓟322{subpath},𝓟323{environment},𝓟327{defaultSnapshot})
    }
    return 𝓟325 = 𝓟[ty]310{OptionalValue}.type.instantiate(𝓟321{parent},𝓟322{subpath},𝓟323{environment},𝓟324{value})
  }
  function 𝓟335{isValidSnapshot} (𝓟336{value}: [OOV]any,𝓟337{context}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array})): (𝓟338: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
  {
    if (𝓟336{value}.EqualsEqualsEqualsToken(𝓛12563{undefined}))
    {
      return 𝓟338 = 𝓟1317{typeCheckSuccess}()
    }
    return 𝓟338 = 𝓟[ty]310{OptionalValue}.type.validate(𝓟336{value},𝓟337{context})
  }
  function 𝓟328{reconcile} (𝓟329{current}: [OOV]𝓟[ty]6979{INode},𝓟330{newValue}: [OOV]any): (𝓟331: [OOV]𝓟[ty]6979{INode})
  {
    return 𝓟331 = 𝓟[ty]310{OptionalValue}.type.reconcile(𝓟329{current},(𝓟[ty]310{OptionalValue}.type.is(𝓟330{newValue}) ? 𝓟330{newValue} : 𝓟[ty]310{OptionalValue}.getDefaultValue())
  }
  function 𝓟339{isAssignableFrom} (𝓟340{type}: [OOV]𝓟[ty]6960{IType}): (𝓟341: [miss]𝓛[ty]8666{Boolean})
  {
    return 𝓟341 = 𝓟[ty]310{OptionalValue}.type.isAssignableFrom(𝓟340{type})
  }
  function 𝓟316{shouldAttachNode} (): (𝓟317)
  {
    return 𝓟317 = 𝓟[ty]310{OptionalValue}.type.shouldAttachNode
  }
}
function 𝓟342{optional} (𝓟343{type}: [OOV]𝓟[ty]6960{IType},𝓟344{defaultValueOrFunction}: [OOV]any): (𝓟345: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟346{optional} (𝓟347{type}: [OOV]𝓟[ty]6960{IType},𝓟348{defaultValueOrFunction}: [OOV]any): (𝓟349: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟350{optional} (𝓟351{type}: [OOV]𝓟[ty]6960{IType},𝓟352{defaultValueOrFunction}: 𝓛[ty]8696{Function}): (𝓟353: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟354{optional} (𝓟355{type}: [OOV]𝓟[ty]6960{IType},𝓟356{defaultValueOrFunction}: 𝓛[ty]8696{Function}): (𝓟357: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟358{optional} (𝓟359{type}: [OOV]𝓟[ty]6960{IType},𝓟360{defaultValueOrFunction}: [OOV]any): (𝓟361: [OOV]𝓟[ty]6960{IType})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟2822{isType}(𝓟359{type})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟359{type}).PlusToken(𝓛8743{String}))
    }
    const 𝓟362{defaultValue} = (𝓛12550{$TypeOf}(𝓟360{defaultValueOrFunction}).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟360{defaultValueOrFunction}() : 𝓟360{defaultValueOrFunction};
    const 𝓟363{defaultSnapshot} = (𝓟673{isStateTreeNode}(𝓟362{defaultValue}) ? 𝓟676{getStateTreeNode}(𝓟362{defaultValue}).snapshot : 𝓟362{defaultValue};
    𝓟1331{typecheck}(𝓟359{type},𝓟363{defaultSnapshot})
  }
  return 𝓟361 = 𝓟304{CONSTRUCTOR}(𝓟359{type},𝓟360{defaultValueOrFunction})
}
function 𝓟364{isOptionalType} (𝓟365{type}: [OOV]any): (𝓟366: 𝓛[ty]8666{Boolean})
{
  return 𝓟366 = 𝓟2822{isType}(𝓟365{type}).AmpersandAmpersandToken(𝓟365{type}.flags.AmpersandToken(𝓟2693{TypeFlags}.Optional).GreaterThanToken(𝓛8745{Number}))
}

Module: packages/mobx-state-tree/src/utils

type 𝓛[ty]0{ANY} = any
type 𝓟[ty]6974{IDisposer} = ()->𝓛[ty]10033{Void}
const 𝓟373{global}: [OOV]any;
const 𝓟374{EMPTY_ARRAY}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8697{ReadonlyArray}) = 𝓛8741{Object}.freeze(𝓛8757{Array}());
const 𝓟375{EMPTY_OBJECT}: 𝓛[ty]8642{Object} = 𝓛8741{Object}.freeze({});
function 𝓟376{fail} (𝓟377{message}): (𝓟378: [OOV]any)
{
  𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String}.PlusToken(𝓟377{message}))
}
function 𝓟379{identity} (𝓟380{_}: [OOV]any): (𝓟381: [OOV]any)
{
  return 𝓟381 = 𝓟380{_}
}
function 𝓟382{nothing} (): (𝓟383: [OOV]any)
{
  return 𝓟383 = 𝓛12563{undefined}
}
function 𝓟384{noop} (): (𝓟385: [miss]𝓛[ty]10033{Void})
{
}
function 𝓟386{isArray} (𝓟387{val}: [OOV]any): (𝓟388: 𝓛[ty]8666{Boolean})
{
  return 𝓟388 = 𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓛8757{Array}.isArray(𝓟387{val}).BarBarToken(𝓟2827{isObservableArray}(𝓟387{val})))) as 𝓛[ty]8666{Boolean}
}
function 𝓟389{asArray} (𝓟390{val}: [OOV]any): (𝓟391: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
{
  if (𝓛12548{ExclamationToken}(𝓟390{val}))
  {
    return 𝓟391 = 𝓟374{EMPTY_ARRAY} as any as 𝓛[ty]8670{Array}
  }
  if (𝓟386{isArray}(𝓟390{val}))
  {
    return 𝓟391 = 𝓟390{val} as 𝓛[ty]8670{Array}
  }
  return 𝓟391 = 𝓛8757{Array}(𝓟390{val}) as 𝓛[ty]8670{Array}
}
function 𝓟392{extend} (𝓟393{a}: [OOV]any,𝓟394{b}: [OOV]any): (𝓟395: [OOV]any)
{
}
function 𝓟396{extend} (𝓟397{a}: [OOV]any,𝓟398{b}: [OOV]any,𝓟399{c}: [OOV]any): (𝓟400: [OOV]any)
{
}
function 𝓟401{extend} (𝓟402{a}: [OOV]any,𝓟403{b}: [OOV]any,𝓟404{c}: [OOV]any,𝓟405{d}: [OOV]any): (𝓟406: [OOV]any)
{
}
function 𝓟407{extend} (𝓟408{a}: [OOV]any,𝓟409{b}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8670{Array})): (𝓟410: [OOV]any)
{
}
function 𝓟411{extend} (𝓟412{a}: [OOV]any,𝓟413{b}: 𝓛[ty]8670{Array}): (𝓟414)
{
  {
    let 𝓟415{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
    while (𝓟415{i}.FirstBinaryOperator(𝓟413{b}.length))
    {
      {
        const 𝓟416{current} = 𝓟413{b}.access(𝓟415{i});
        {
          let 𝓟417{key}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓟416{current});
          while (𝓛8744{Boolean})
          {
            𝓟412{a}.access(𝓟417{key}) ⟵ 𝓟416{current}.access(𝓟417{key});
          }
        }
      }
      𝓛12546{POST_PlusPlusToken}(𝓟415{i})
    }
  }
  return 𝓟414 = 𝓟412{a}
}
function 𝓟418{extendKeepGetter} (𝓟419{a}: [OOV]any,𝓟420{b}: [OOV]any): (𝓟421: [OOV]any)
{
}
function 𝓟422{extendKeepGetter} (𝓟423{a}: [OOV]any,𝓟424{b}: [OOV]any,𝓟425{c}: [OOV]any): (𝓟426: [OOV]any)
{
}
function 𝓟427{extendKeepGetter} (𝓟428{a}: [OOV]any,𝓟429{b}: [OOV]any,𝓟430{c}: [OOV]any,𝓟431{d}: [OOV]any): (𝓟432: [OOV]any)
{
}
function 𝓟433{extendKeepGetter} (𝓟434{a}: [OOV]any,𝓟435{b}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8670{Array})): (𝓟436: [OOV]any)
{
}
function 𝓟437{extendKeepGetter} (𝓟438{a}: [OOV]any,𝓟439{b}: 𝓛[ty]8670{Array}): (𝓟440)
{
  {
    let 𝓟441{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
    while (𝓟441{i}.FirstBinaryOperator(𝓟439{b}.length))
    {
      {
        const 𝓟442{current} = 𝓟439{b}.access(𝓟441{i});
        {
          let 𝓟443{key}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓟442{current});
          while (𝓛8744{Boolean})
          {
            const 𝓟444{descriptor}: [miss]𝓛[ty]8633{PropertyDescriptor} = 𝓛8741{Object}.getOwnPropertyDescriptor(𝓟442{current},𝓟443{key});
            if (𝓛8743{String}.InKeyword(𝓟444{descriptor}))
            {
              𝓛8741{Object}.defineProperty(𝓟438{a},𝓟443{key},{configurable: 𝓛8744{Boolean}})
            }
            𝓟438{a}.access(𝓟443{key}) ⟵ 𝓟442{current}.access(𝓟443{key});
          }
        }
      }
      𝓛12546{POST_PlusPlusToken}(𝓟441{i})
    }
  }
  return 𝓟440 = 𝓟438{a}
}
function 𝓟445{isPlainObject} (𝓟446{value}: [OOV]any): (𝓟447: [miss]𝓛[ty]8666{Boolean})
{
  if (𝓟446{value}.EqualsEqualsEqualsToken(𝓛12563{undefined}).BarBarToken(𝓛12550{$TypeOf}(𝓟446{value}).ExclamationEqualsEqualsToken(𝓛8743{String})))
  {
    return 𝓟447 = 𝓛8744{Boolean}
  }
  const 𝓟448{proto} = 𝓛8741{Object}.getPrototypeOf(𝓟446{value});
  return 𝓟447 = 𝓟448{proto}.EqualsEqualsEqualsToken(𝓛8741{Object}.prototype).BarBarToken(𝓟448{proto}.EqualsEqualsEqualsToken(𝓛12563{undefined}))
}
function 𝓟449{isMutable} (𝓟450{value}: [OOV]any): (𝓟451: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟451 = 𝓟450{value}.ExclamationEqualsEqualsToken(𝓛12563{undefined}).AmpersandAmpersandToken(𝓛12550{$TypeOf}(𝓟450{value}).EqualsEqualsEqualsToken(𝓛8743{String})).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟450{value}.InstanceOfKeyword(𝓛8747{Date}))).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟450{value}.InstanceOfKeyword(𝓛8748{RegExp})))
}
function 𝓟452{isPrimitive} (𝓟453{value}: [OOV]any): (𝓟454: 𝓛[ty]8666{Boolean})
{
  if (𝓟453{value}.EqualsEqualsEqualsToken(𝓛12563{undefined}).BarBarToken(𝓟453{value}.EqualsEqualsEqualsToken(𝓛12563{undefined})))
  {
    return 𝓟454 = 𝓛8744{Boolean}
  }
  if (𝓛12550{$TypeOf}(𝓟453{value}).EqualsEqualsEqualsToken(𝓛8743{String}).BarBarToken(𝓛12550{$TypeOf}(𝓟453{value}).EqualsEqualsEqualsToken(𝓛8743{String})).BarBarToken(𝓛12550{$TypeOf}(𝓟453{value}).EqualsEqualsEqualsToken(𝓛8743{String})).BarBarToken(𝓟453{value}.InstanceOfKeyword(𝓛8747{Date})))
  {
    return 𝓟454 = 𝓛8744{Boolean}
  }
  return 𝓟454 = 𝓛8744{Boolean}
}
function 𝓟455{freeze} (𝓟456{value}: [OOV]any): (𝓟457: [OOV]any)
{
  return 𝓟457 = (𝓟452{isPrimitive}(𝓟456{value}) ? 𝓟456{value} : 𝓛8741{Object}.freeze(𝓟456{value})
}
function 𝓟458{deepFreeze} (𝓟459{value}: [OOV]any): (𝓟460: [OOV]any)
{
  𝓟455{freeze}(𝓟459{value})
  if (𝓟445{isPlainObject}(𝓟459{value}))
  {
    function 𝓟461{$Lambda0} (𝓟462{propKey}): (𝓟463: [miss]𝓛[ty]10033{Void})
    {
      if (𝓛12548{ExclamationToken}(𝓟452{isPrimitive}(𝓟459{value} as any.access(𝓟462{propKey}))).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓛8741{Object}.isFrozen(𝓟459{value} as any.access(𝓟462{propKey})))))
      {
        𝓟458{deepFreeze}(𝓟459{value} as any.access(𝓟462{propKey}))
      }
    }
    𝓛8741{Object}.keys(𝓟459{value}).forEach(𝓟461{$Lambda0})
  }
  return 𝓟460 = 𝓟459{value}
}
function 𝓟464{isSerializable} (𝓟465{value}: [OOV]any): (𝓟466: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟466 = 𝓛12550{$TypeOf}(𝓟465{value}).ExclamationEqualsEqualsToken(𝓛8743{String})
}
function 𝓟467{addHiddenFinalProp} (𝓟468{object}: [OOV]any,𝓟469{propName}: 𝓛[ty]10051{String},𝓟470{value}: [OOV]any): (𝓟471: [miss]𝓛[ty]10033{Void})
{
  𝓛8741{Object}.defineProperty(𝓟468{object},𝓟469{propName},{enumerable: 𝓛8744{Boolean},writable: 𝓛8744{Boolean},configurable: 𝓛8744{Boolean},value: 𝓟470{value}})
}
function 𝓟472{addHiddenWritableProp} (𝓟473{object}: [OOV]any,𝓟474{propName}: 𝓛[ty]10051{String},𝓟475{value}: [OOV]any): (𝓟476: [miss]𝓛[ty]10033{Void})
{
  𝓛8741{Object}.defineProperty(𝓟473{object},𝓟474{propName},{enumerable: 𝓛8744{Boolean},writable: 𝓛8744{Boolean},configurable: 𝓛8744{Boolean},value: 𝓟475{value}})
}
function 𝓟477{addReadOnlyProp} (𝓟478{object}: [OOV]any,𝓟479{propName}: 𝓛[ty]10051{String},𝓟480{value}: [OOV]any): (𝓟481: [miss]𝓛[ty]10033{Void})
{
  𝓛8741{Object}.defineProperty(𝓟478{object},𝓟479{propName},{enumerable: 𝓛8744{Boolean},writable: 𝓛8744{Boolean},configurable: 𝓛8744{Boolean},value: 𝓟480{value}})
}
function 𝓟482{remove} (𝓟483{collection}: 𝓛[ty]8670{Array},𝓟484{item}: [OOV]any): (𝓟485: [miss]𝓛[ty]10033{Void})
{
  const 𝓟486{idx}: [miss]𝓛[ty]8655{Number} = 𝓟483{collection}.indexOf(𝓟484{item});
  if (𝓟486{idx}.ExclamationEqualsEqualsToken(𝓛12557{MinusToken}(𝓛8745{Number})))
  {
    𝓟483{collection}.splice(𝓟486{idx},𝓛8745{Number})
  }
}
function 𝓟487{registerEventHandler} (𝓟488{handlers}: 𝓛[ty]8670{Array},𝓟489{handler}: 𝓛[ty]8696{Function}): (𝓟490: [OOV]𝓟[ty]6974{IDisposer})
{
  𝓟488{handlers}.push(𝓟489{handler})
  function 𝓟491{$Lambda1} (): (𝓟492: [miss]𝓛[ty]10033{Void})
  {
    𝓟482{remove}(𝓟488{handlers},𝓟489{handler})
  }
  return 𝓟490 = 𝓟491{$Lambda1}
}
const 𝓟493{prototypeHasOwnProperty}: [miss]𝓛[ty]8696{Function} = 𝓛8741{Object}.prototype.hasOwnProperty;
function 𝓟494{hasOwnProperty} (𝓟495{object}: 𝓛[ty]8642{Object},𝓟496{propName}: 𝓛[ty]10051{String}): (𝓟497: [OOV]any)
{
  return 𝓟497 = 𝓟493{prototypeHasOwnProperty}.call(𝓟495{object},𝓟496{propName})
}
function 𝓟498{argsToArray} (𝓟499{args}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8638{IArguments})): (𝓟500: (𝓛[ty]8654{Promise} ≠ 𝓛[ty]8670{Array}))
{
  const 𝓟501{res}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}.CONSTRUCTOR(𝓟499{args}.length);
  {
    let 𝓟502{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
    while (𝓟502{i}.FirstBinaryOperator(𝓟499{args}.length))
    {
      𝓟501{res}.access(𝓟502{i}) ⟵ 𝓟499{args}.access(𝓟502{i});
      𝓛12546{POST_PlusPlusToken}(𝓟502{i})
    }
  }
  return 𝓟500 = 𝓟501{res}
}
function 𝓟503{$Lambda2} (): (𝓟504: [miss]𝓛[ty]10033{Void})
{
}
let 𝓟505{deprecated}: [OOV]𝓛[ty]0{ANY} = 𝓟503{$Lambda2};
function 𝓟506{$Lambda3} (𝓟507{id}: 𝓛[ty]10051{String},𝓟508{message}: 𝓛[ty]10051{String}): (𝓟509: 𝓛[ty]10033{Void})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.EqualsEqualsEqualsToken(𝓛8743{String}))
  {
  }
  if (𝓟505{deprecated}.ids.AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟505{deprecated}.ids.hasOwnProperty(𝓟507{id}))))
  {
    𝓛1{<UNKNOWN>}(𝓛8743{String}.PlusToken(𝓟508{message}))
  }
  if (𝓟505{deprecated}.ids)
  {
    𝓟505{deprecated}.ids.access(𝓟507{id}) ⟵ 𝓛8744{Boolean};
  }
}
𝓟505{deprecated} ⟵ 𝓟506{$Lambda3};
𝓟505{deprecated}.ids ⟵ {};

Module: packages/mobx-state-tree/src/core/mst-operations

type 𝓟[ty]6982{IPatchRecorder} = {patches: 𝓛[ty]8697{ReadonlyArray}, undo: (𝓟[ty]6977{IStateTreeNode})->𝓛[ty]10033{Void}, replay: (𝓟[ty]6977{IStateTreeNode})->any, stop: ()->any, inversePatches: 𝓛[ty]8697{ReadonlyArray}}
function 𝓟511{getType} (𝓟512{object}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟513: [OOV]𝓟[ty]6960{IType})
{
  return 𝓟513 = 𝓟676{getStateTreeNode}(𝓟512{object}).type
}
function 𝓟514{getChildType} (𝓟515{object}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟516{child}: 𝓛[ty]10051{String}): (𝓟517: [OOV]𝓟[ty]6960{IType})
{
  return 𝓟517 = 𝓟676{getStateTreeNode}(𝓟515{object}).getChildType(𝓟516{child})
}
function 𝓟518{onPatch} (𝓟519{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟520{callback}: 𝓛[ty]8696{Function}): (𝓟521: [OOV]𝓟[ty]6974{IDisposer})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟519{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟519{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12550{$TypeOf}(𝓟520{callback}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟520{callback}).PlusToken(𝓛8743{String}))
    }
  }
  return 𝓟521 = 𝓟676{getStateTreeNode}(𝓟519{target}).onPatch(𝓟520{callback})
}
function 𝓟522{onSnapshot} (𝓟523{target}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟524{callback}: 𝓛[ty]8696{Function}): (𝓟525: [OOV]𝓟[ty]6974{IDisposer})
{
}
function 𝓟526{onSnapshot} (𝓟527{target}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟528{callback}: 𝓛[ty]8696{Function}): (𝓟529: [OOV]𝓟[ty]6974{IDisposer})
{
}
function 𝓟530{onSnapshot} (𝓟531{target}: [OOV]𝓟[ty]6944{ISnapshottable},𝓟532{callback}: 𝓛[ty]8696{Function}): (𝓟533: [OOV]𝓟[ty]6974{IDisposer})
{
}
function 𝓟534{onSnapshot} (𝓟535{target}: [OOV]𝓟[ty]6944{ISnapshottable},𝓟536{callback}: 𝓛[ty]8696{Function}): (𝓟537: [OOV]𝓟[ty]6974{IDisposer})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟535{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟535{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12550{$TypeOf}(𝓟536{callback}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟536{callback}).PlusToken(𝓛8743{String}))
    }
  }
  return 𝓟537 = 𝓟676{getStateTreeNode}(𝓟535{target}).onSnapshot(𝓟536{callback})
}
function 𝓟538{applyPatch} (𝓟539{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟540{patch}: [OOV]any): (𝓟541: [miss]𝓛[ty]10033{Void})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟539{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟539{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12550{$TypeOf}(𝓟540{patch}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟540{patch}).PlusToken(𝓛8743{String}))
    }
  }
  𝓟676{getStateTreeNode}(𝓟539{target}).applyPatches(𝓟389{asArray}(𝓟540{patch}))
}
function 𝓟542{recordPatches} (𝓟543{subject}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟544: [OOV]𝓟[ty]6982{IPatchRecorder})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟543{subject})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟543{subject}).PlusToken(𝓛8743{String}))
    }
  }
  let 𝓟545{disposer}: [OOV]any = 𝓛12563{undefined};
  function 𝓟546{resume} (): (𝓟547: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟545{disposer})
    {
    }
    function 𝓟548{$Lambda38} (𝓟549{patch},𝓟550{inversePatch}): (𝓟551: [miss]𝓛[ty]10033{Void})
    {
      𝓟552{recorder}.rawPatches.push(𝓛8757{Array}(𝓟549{patch},𝓟550{inversePatch}))
    }
    𝓟545{disposer} ⟵ 𝓟518{onPatch}(𝓟543{subject},𝓟548{$Lambda38});
  }
  let 𝓟552{recorder}: [miss]𝓛[ty]8642{Object} = {rawPatches: 𝓛8757{Array}() as 𝓛[ty]8670{Array},resume: 𝓟546{resume}};
  𝓟546{resume}()
  return 𝓟544 = 𝓟552{recorder}
}
function 𝓟553{protect} (𝓟554{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟555: [miss]𝓛[ty]10033{Void})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟554{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟554{target}).PlusToken(𝓛8743{String}))
    }
  }
  const 𝓟556{node}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟676{getStateTreeNode}(𝓟554{target});
  if (𝓛12548{ExclamationToken}(𝓟556{node}.isRoot))
  {
    𝓟376{fail}(𝓛8743{String})
  }
  𝓟556{node}.isProtectionEnabled ⟵ 𝓛8744{Boolean};
}
function 𝓟557{unprotect} (𝓟558{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟559: [miss]𝓛[ty]10033{Void})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟558{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟558{target}).PlusToken(𝓛8743{String}))
    }
  }
  const 𝓟560{node}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟676{getStateTreeNode}(𝓟558{target});
  if (𝓛12548{ExclamationToken}(𝓟560{node}.isRoot))
  {
    𝓟376{fail}(𝓛8743{String})
  }
  𝓟560{node}.isProtectionEnabled ⟵ 𝓛8744{Boolean};
}
function 𝓟561{isProtected} (𝓟562{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟563: 𝓛[ty]8666{Boolean})
{
  return 𝓟563 = 𝓟676{getStateTreeNode}(𝓟562{target}).isProtected
}
function 𝓟564{applySnapshot} (𝓟565{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟566{snapshot}: [OOV]any): (𝓟567: [miss]𝓛[ty]10033{Void})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟565{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟565{target}).PlusToken(𝓛8743{String}))
    }
  }
  return 𝓟567 = 𝓟676{getStateTreeNode}(𝓟565{target}).applySnapshot(𝓟566{snapshot})
}
function 𝓟568{getSnapshot} (𝓟569{target}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟570: (𝓛[ty]8654{Promise} ≠ 𝓛[ty]8642{Object}))
{
}
function 𝓟571{getSnapshot} (𝓟572{target}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟573: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8670{Array}))
{
}
function 𝓟574{getSnapshot} (𝓟575{target}: [OOV]𝓟[ty]6944{ISnapshottable}): (𝓟576: [OOV]any)
{
}
function 𝓟577{getSnapshot} (𝓟578{target}: [OOV]𝓟[ty]6944{ISnapshottable}): (𝓟579: [OOV]any)
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟578{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟578{target}).PlusToken(𝓛8743{String}))
    }
  }
  return 𝓟579 = 𝓟676{getStateTreeNode}(𝓟578{target}).snapshot
}
function 𝓟580{hasParent} (𝓟581{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟582{depth}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟583: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8666{Boolean}))
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟581{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟581{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12550{$TypeOf}(𝓟582{depth}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟582{depth}).PlusToken(𝓛8743{String}))
    }
    if (𝓟582{depth}.FirstBinaryOperator(𝓛8745{Number}))
    {
      𝓟376{fail}(𝓛12554{$Template}(𝓟582{depth}))
    }
  }
  let 𝓟584{parent}: [OOV]any = 𝓟676{getStateTreeNode}(𝓟581{target}).parent;
  while (𝓟584{parent})
  {
    if (𝓛12556{MinusMinusToken}(𝓟582{depth}).EqualsEqualsEqualsToken(𝓛8745{Number}))
    {
      return 𝓟583 = 𝓛8744{Boolean}
    }
    𝓟584{parent} ⟵ 𝓟584{parent}.parent;
  }
  return 𝓟583 = 𝓛8744{Boolean}
}
function 𝓟585{getParent} (𝓟586{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟587{depth}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8655{Number})): (𝓟588: [OOV]any)
{
}
function 𝓟589{getParent} (𝓟590{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟591{depth}: 𝓛[ty]8655{Number}): (𝓟592: [OOV]any)
{
}
function 𝓟593{getParent} (𝓟594{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟595{depth}): (𝓟596: [OOV]any)
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟594{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟594{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12550{$TypeOf}(𝓟595{depth}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟595{depth}).PlusToken(𝓛8743{String}))
    }
    if (𝓟595{depth}.FirstBinaryOperator(𝓛8745{Number}))
    {
      𝓟376{fail}(𝓛12554{$Template}(𝓟595{depth}))
    }
  }
  let 𝓟597{d}: [miss]𝓛[ty]8655{Number} = 𝓟595{depth};
  let 𝓟598{parent}: [OOV]any = 𝓟676{getStateTreeNode}(𝓟594{target}).parent;
  while (𝓟598{parent})
  {
    if (𝓛12556{MinusMinusToken}(𝓟597{d}).EqualsEqualsEqualsToken(𝓛8745{Number}))
    {
      return 𝓟596 = 𝓟598{parent}.storedValue
    }
    𝓟598{parent} ⟵ 𝓟598{parent}.parent;
  }
  return 𝓟596 = 𝓟376{fail}(𝓛12554{$Template}(𝓟676{getStateTreeNode}(𝓟594{target}),𝓟595{depth}))
}
function 𝓟599{getRoot} (𝓟600{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟601: [OOV]any)
{
}
function 𝓟602{getRoot} (𝓟603{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟604: [OOV]any)
{
}
function 𝓟605{getRoot} (𝓟606{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟607: [OOV]𝓟[ty]6977{IStateTreeNode})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟606{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟606{target}).PlusToken(𝓛8743{String}))
    }
  }
  return 𝓟607 = 𝓟676{getStateTreeNode}(𝓟606{target}).root.storedValue
}
function 𝓟608{getPath} (𝓟609{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟610: 𝓛[ty]10051{String})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟609{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟609{target}).PlusToken(𝓛8743{String}))
    }
  }
  return 𝓟610 = 𝓟676{getStateTreeNode}(𝓟609{target}).path
}
function 𝓟611{getPathParts} (𝓟612{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟613: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}))
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟612{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟612{target}).PlusToken(𝓛8743{String}))
    }
  }
  return 𝓟613 = 𝓟2684{splitJsonPath}(𝓟676{getStateTreeNode}(𝓟612{target}).path)
}
function 𝓟614{isRoot} (𝓟615{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟616: 𝓛[ty]8666{Boolean})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟615{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟615{target}).PlusToken(𝓛8743{String}))
    }
  }
  return 𝓟616 = 𝓟676{getStateTreeNode}(𝓟615{target}).isRoot
}
function 𝓟617{resolvePath} (𝓟618{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟619{path}: 𝓛[ty]10051{String}): (𝓟620: [OOV]any)
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟618{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟618{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12550{$TypeOf}(𝓟619{path}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟619{path}).PlusToken(𝓛8743{String}))
    }
  }
  const 𝓟621{node}: [OOV]𝓟[ty]6979{INode} = 𝓟705{resolveNodeByPath}(𝓟676{getStateTreeNode}(𝓟618{target}),𝓟619{path});
  return 𝓟620 = (𝓟621{node} ? 𝓟621{node}.value : 𝓛12563{undefined}
}
function 𝓟622{resolveIdentifier} (𝓟623{type}: [OOV]𝓟[ty]6960{IType},𝓟624{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟625{identifier}: [OOV]any): (𝓟626: [OOV]any)
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟2822{isType}(𝓟623{type})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟623{type}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟624{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟624{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12548{ExclamationToken}(𝓛12550{$TypeOf}(𝓟625{identifier}).EqualsEqualsEqualsToken(𝓛8743{String}).BarBarToken(𝓛12550{$TypeOf}(𝓟625{identifier}).EqualsEqualsEqualsToken(𝓛8743{String}))))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟625{identifier}).PlusToken(𝓛8743{String}))
    }
  }
  const 𝓟627{node}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟676{getStateTreeNode}(𝓟624{target}).root.identifierCache.resolve(𝓟623{type},𝓛8743{String}.PlusToken(𝓟625{identifier}));
  return 𝓟626 = (𝓟627{node} ? 𝓟627{node}.value : 𝓛12563{undefined}
}
function 𝓟628{tryResolve} (𝓟629{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟630{path}: 𝓛[ty]10051{String}): (𝓟631: [OOV]any)
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟629{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟629{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12550{$TypeOf}(𝓟630{path}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟630{path}).PlusToken(𝓛8743{String}))
    }
  }
  const 𝓟632{node}: [OOV]𝓟[ty]6979{INode} = 𝓟705{resolveNodeByPath}(𝓟676{getStateTreeNode}(𝓟629{target}),𝓟630{path},𝓛8744{Boolean});
  if (𝓟632{node}.EqualsEqualsEqualsToken(𝓛12563{undefined}))
  {
    return 𝓟631 = 𝓛12563{undefined}
  }
  return 𝓟631 = (𝓟632{node} ? 𝓟632{node}.value : 𝓛12563{undefined}
}
function 𝓟633{getRelativePath} (𝓟634{base}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟635{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟636: (𝓛[ty]10033{Void} ≠ 𝓛[ty]10051{String}))
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟635{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟635{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟634{base})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟634{base}).PlusToken(𝓛8743{String}))
    }
  }
  return 𝓟636 = 𝓟689{getRelativePathBetweenNodes}(𝓟676{getStateTreeNode}(𝓟634{base}),𝓟676{getStateTreeNode}(𝓟635{target}))
}
function 𝓟637{clone} (𝓟638{source}: [OOV]any,𝓟639{keepEnvironment}: [OOV]any): (𝓟640: [OOV]any)
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟638{source})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟638{source}).PlusToken(𝓛8743{String}))
    }
  }
  const 𝓟641{node}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟676{getStateTreeNode}(𝓟638{source});
  return 𝓟640 = 𝓟641{node}.type.create(𝓟641{node}.snapshot,(𝓟639{keepEnvironment}.EqualsEqualsEqualsToken(𝓛8744{Boolean}) ? 𝓟641{node}.root._environment : (𝓟639{keepEnvironment}.EqualsEqualsEqualsToken(𝓛8744{Boolean}) ? 𝓛12563{undefined} : 𝓟639{keepEnvironment}) as 𝓛[ty]2{<UNKNOWN>}
}
function 𝓟642{detach} (𝓟643{target}: [OOV]any): (𝓟644: [OOV]any)
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟643{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟643{target}).PlusToken(𝓛8743{String}))
    }
  }
  𝓟676{getStateTreeNode}(𝓟643{target}).detach()
  return 𝓟644 = 𝓟643{target}
}
function 𝓟645{destroy} (𝓟646{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟647: [miss]𝓛[ty]10033{Void})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟646{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟646{target}).PlusToken(𝓛8743{String}))
    }
  }
  const 𝓟648{node}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟676{getStateTreeNode}(𝓟646{target});
  if (𝓟648{node}.isRoot)
  {
    𝓟648{node}.die()
  }
  else
  {
    𝓟648{node}.parent.removeChild(𝓟648{node}.subpath)
  }
}
function 𝓟649{isAlive} (𝓟650{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟651: 𝓛[ty]8666{Boolean})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟650{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟650{target}).PlusToken(𝓛8743{String}))
    }
  }
  return 𝓟651 = 𝓟676{getStateTreeNode}(𝓟650{target}).isAlive
}
function 𝓟652{addDisposer} (𝓟653{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟654{disposer}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟655: [miss]𝓛[ty]10033{Void})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟653{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟653{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12550{$TypeOf}(𝓟654{disposer}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟654{disposer}).PlusToken(𝓛8743{String}))
    }
  }
  𝓟676{getStateTreeNode}(𝓟653{target}).addDisposer(𝓟654{disposer})
}
function 𝓟656{getEnv} (𝓟657{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟658: [OOV]any)
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟657{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟657{target}).PlusToken(𝓛8743{String}))
    }
  }
  const 𝓟659{node}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟676{getStateTreeNode}(𝓟657{target});
  const 𝓟660{env} = 𝓟659{node}.root._environment;
  if (𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓟660{env}))))
  {
    return 𝓟658 = 𝓟375{EMPTY_OBJECT} as 𝓛[ty]2{<UNKNOWN>}
  }
  return 𝓟658 = 𝓟660{env}
}
function 𝓟661{walk} (𝓟662{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟663{processor}: 𝓛[ty]8696{Function}): (𝓟664: [miss]𝓛[ty]10033{Void})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟662{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟662{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12550{$TypeOf}(𝓟663{processor}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟663{processor}).PlusToken(𝓛8743{String}))
    }
  }
  const 𝓟665{node}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟676{getStateTreeNode}(𝓟662{target});
  function 𝓟666{$Lambda39} (𝓟667{child}): (𝓟668: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟673{isStateTreeNode}(𝓟667{child}.storedValue))
    {
      𝓟661{walk}(𝓟667{child}.storedValue,𝓟663{processor})
    }
  }
  𝓟665{node}.getChildren().forEach(𝓟666{$Lambda39})
  𝓟663{processor}(𝓟665{node}.storedValue)
}

Module: packages/mobx-state-tree/src/core/node/node-utils

type 𝓟[ty]6977{IStateTreeNode} = {$treenode: any}
type 𝓟[ty]6979{INode} = {isRoot: 𝓛[ty]8666{Boolean}, parent: any, isAlive: 𝓛[ty]8666{Boolean}, path: 𝓛[ty]10051{String}, root: 𝓟[ty]2343{ObjectNode}, subpath: 𝓛[ty]10051{String}, storedValue: any, _environment: any, die: ()->𝓛[ty]10033{Void}, snapshot: any, setParent: (any,any)->𝓛[ty]10033{Void}, type: 𝓟[ty]6960{IType}, value: any}
type 𝓛[ty]8655{Number} = 𝓛[ty]8655{Number}
const 𝓟672{NodeLifeCycle} = {CREATED: 𝓛8745{Number},INITIALIZING: 𝓛8745{Number},FINALIZED: 𝓛8745{Number},DETACHING: 𝓛8745{Number},DEAD: 𝓛8745{Number}};
function 𝓟673{isStateTreeNode} (𝓟674{value}: [OOV]any): (𝓟675: 𝓛[ty]8666{Boolean})
{
  return 𝓟675 = 𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓟674{value}.AmpersandAmpersandToken(𝓟674{value}.$treenode)))
}
function 𝓟676{getStateTreeNode} (𝓟677{value}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟678: [OOV]𝓟[ty]2343{ObjectNode})
{
  if (𝓟673{isStateTreeNode}(𝓟677{value}))
  {
    return 𝓟678 = 𝓟677{value}.$treenode
  }
  else
  {
    return 𝓟678 = 𝓟376{fail}(𝓛12554{$Template}(𝓟677{value}))
  }
}
function 𝓟679{canAttachNode} (𝓟680{value}: [OOV]any): (𝓟681: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟681 = 𝓟680{value}.AmpersandAmpersandToken(𝓛12550{$TypeOf}(𝓟680{value}).EqualsEqualsEqualsToken(𝓛8743{String})).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟680{value}.InstanceOfKeyword(𝓛8747{Date}))).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟680{value}))).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓛8741{Object}.isFrozen(𝓟680{value})))
}
function 𝓟682{toJSON} (𝓟683{this}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟684: [OOV]any)
{
  return 𝓟684 = 𝓟676{getStateTreeNode}(𝓟683{this}).snapshot
}
function 𝓟685{$Lambda59} (𝓟686{_}: [OOV]any): (𝓟687: [miss]𝓛[ty]10051{String})
{
  return 𝓟687 = 𝓛8743{String}
}
const 𝓟688{doubleDot}: [miss]𝓛[ty]8696{Function} = 𝓟685{$Lambda59};
function 𝓟689{getRelativePathBetweenNodes} (𝓟690{base}: [OOV]𝓟[ty]2343{ObjectNode},𝓟691{target}: [OOV]𝓟[ty]2343{ObjectNode}): (𝓟692: (𝓛[ty]8654{Promise} ≠ 𝓛[ty]10051{String}))
{
  if (𝓟690{base}.root.ExclamationEqualsEqualsToken(𝓟691{target}.root))
  {
    𝓟376{fail}(𝓛12554{$Template}(𝓟690{base},𝓟691{target}))
  }
  const 𝓟693{baseParts}: [miss]𝓛[ty]8670{Array} = 𝓟2684{splitJsonPath}(𝓟690{base}.path);
  const 𝓟694{targetParts}: [miss]𝓛[ty]8670{Array} = 𝓟2684{splitJsonPath}(𝓟691{target}.path);
  let 𝓟695{common}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
  {
    while (𝓟695{common}.FirstBinaryOperator(𝓟693{baseParts}.length))
    {
      {
        if (𝓟693{baseParts}.access(𝓟695{common}).ExclamationEqualsEqualsToken(𝓟694{targetParts}.access(𝓟695{common})))
        {
        }
      }
      𝓛12546{POST_PlusPlusToken}(𝓟695{common})
    }
  }
  return 𝓟692 = 𝓟693{baseParts}.slice(𝓟695{common}).map(𝓟688{doubleDot}).join(𝓛8743{String}).PlusToken(𝓟2681{joinJsonPath}(𝓟694{targetParts}.slice(𝓟695{common})))
}
function 𝓟696{resolveNodeByPath} (𝓟697{base}: [OOV]𝓟[ty]2343{ObjectNode},𝓟698{pathParts}: 𝓛[ty]10051{String}): (𝓟699: [OOV]𝓟[ty]6979{INode})
{
}
function 𝓟700{resolveNodeByPath} (𝓟701{base}: [OOV]𝓟[ty]2343{ObjectNode},𝓟702{pathParts}: 𝓛[ty]10051{String},𝓟703{failIfResolveFails}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8666{Boolean})): (𝓟704: [OOV]any)
{
}
function 𝓟705{resolveNodeByPath} (𝓟706{base}: [OOV]𝓟[ty]2343{ObjectNode},𝓟707{path}: 𝓛[ty]10051{String},𝓟708{failIfResolveFails}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8666{Boolean})): (𝓟709: [OOV]any)
{
  return 𝓟709 = 𝓟719{resolveNodeByPathParts}(𝓟706{base},𝓟2684{splitJsonPath}(𝓟707{path}),𝓟708{failIfResolveFails})
}
function 𝓟710{resolveNodeByPathParts} (𝓟711{base}: [OOV]𝓟[ty]2343{ObjectNode},𝓟712{pathParts}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟713: [OOV]𝓟[ty]6979{INode})
{
}
function 𝓟714{resolveNodeByPathParts} (𝓟715{base}: [OOV]𝓟[ty]2343{ObjectNode},𝓟716{pathParts}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟717{failIfResolveFails}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8666{Boolean})): (𝓟718: [OOV]any)
{
}
function 𝓟719{resolveNodeByPathParts} (𝓟720{base}: [OOV]𝓟[ty]2343{ObjectNode},𝓟721{pathParts}: 𝓛[ty]8670{Array},𝓟722{failIfResolveFails}: 𝓛[ty]8666{Boolean}): (𝓟723: [OOV]any)
{
  let 𝓟724{current}: [OOV]any = 𝓟720{base};
  {
    let 𝓟725{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
    while (𝓟725{i}.FirstBinaryOperator(𝓟721{pathParts}.length))
    {
      {
        if (𝓟721{pathParts}.access(𝓟725{i}).EqualsEqualsEqualsToken(𝓛8743{String}))
        {
          𝓟724{current} ⟵ 𝓟724{current}.root;
        }
        else
        {
          if (𝓟721{pathParts}.access(𝓟725{i}).EqualsEqualsEqualsToken(𝓛8743{String}))
          {
            𝓟724{current} ⟵ 𝓟724{current}.parent;
          }
          else
          {
            if (𝓟721{pathParts}.access(𝓟725{i}).EqualsEqualsEqualsToken(𝓛8743{String}).BarBarToken(𝓟721{pathParts}.access(𝓟725{i}).EqualsEqualsEqualsToken(𝓛8743{String})))
            {
            }
            else
            {
              if (𝓟724{current})
              {
                if (𝓟724{current}.InstanceOfKeyword(𝓛12563{undefined}))
                {
                  𝓟724{current} ⟵ 𝓟724{current}.getChildNode(𝓟721{pathParts}.access(𝓟725{i}));
                }
                else
                {
                  return 𝓟723 = 𝓟376{fail}(𝓛8743{String})
                }
              }
            }
          }
        }
        if (𝓛12548{ExclamationToken}(𝓟724{current}))
        {
          if (𝓟722{failIfResolveFails})
          {
            return 𝓟723 = 𝓟376{fail}(𝓛12554{$Template}(𝓟721{pathParts}.access(𝓟725{i}),𝓟2681{joinJsonPath}(𝓟721{pathParts}.slice(𝓛8745{Number},𝓟725{i}.MinusToken(𝓛8745{Number})))))
          }
          else
          {
            return 𝓟723 = 𝓛12563{undefined}
          }
        }
      }
      𝓛12546{POST_PlusPlusToken}(𝓟725{i})
    }
  }
  return 𝓟723 = 𝓟724{current}
}

Module: packages/mobx-state-tree/src/types/utility-types/union

type 𝓟[ty]6990{ITypeDispatcher} = (any)->𝓟[ty]6960{IType}
function 𝓟773{CONSTRUCTOR} (𝓟774{name}: 𝓛[ty]10051{String},𝓟775{types}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8670{Array}),𝓟776{dispatcher}: [OOV]any): (𝓟[ty]780{Union})
{
  const 𝓟[ty]780{Union};
  const 𝓟[ty]780{Union};
  𝓟[ty]780{Union}.dispatcher ⟵ 𝓛12563{undefined};
  𝓟[ty]780{Union}(𝓟774{name})
  𝓟[ty]780{Union}.dispatcher ⟵ 𝓟776{dispatcher};
  𝓟[ty]780{Union}.types ⟵ 𝓟775{types};
}
class 𝓟[ty]780{Union} extends 𝓟[ty]2778{Type}{
  𝓟782{dispatcher}: [OOV]any;
  𝓟783{types}: 𝓛[ty]8670{Array};
  function 𝓟784{flags} (): (𝓟785)
  {
    let 𝓟786{result}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8655{Number}) = 𝓟2693{TypeFlags}.Union;
    function 𝓟787{$Lambda115} (𝓟788{type}): (𝓟789: [miss]𝓛[ty]10033{Void})
    {
      𝓟786{result}.BarEqualsToken(𝓟788{type}.flags)
    }
    𝓟[ty]780{Union}.types.forEach(𝓟787{$Lambda115})
    return 𝓟785 = 𝓟786{result}
  }
  function 𝓟816{determineType} (𝓟817{value}: [OOV]any): (𝓟818: [OOV]𝓟[ty]6960{IType})
  {
    if (𝓟[ty]780{Union}.dispatcher.ExclamationEqualsEqualsToken(𝓛12563{undefined}))
    {
      return 𝓟818 = 𝓟[ty]780{Union}.dispatcher(𝓟817{value})
    }
    function 𝓟819{$Lambda119} (𝓟820{type}): (𝓟821: [miss]𝓛[ty]8666{Boolean})
    {
      return 𝓟821 = 𝓟820{type}.is(𝓟817{value})
    }
    const 𝓟822{applicableTypes}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]780{Union}.types.filter(𝓟819{$Lambda119});
    if (𝓟822{applicableTypes}.length.GreaterThanToken(𝓛8745{Number}))
    {
      return 𝓟818 = 𝓟376{fail}(𝓛12554{$Template}(𝓛8756{JSON}.stringify(𝓟817{value}),𝓟[ty]780{Union}.name))
    }
    return 𝓟818 = 𝓟822{applicableTypes}.access(𝓛8745{Number})
  }
  function 𝓟801{describe} (): (𝓟802: [miss]𝓛[ty]10051{String})
  {
    function 𝓟803{$Lambda118} (𝓟804{factory}): (𝓟805: [miss]𝓛[ty]10051{String})
    {
      return 𝓟805 = 𝓟804{factory}.describe()
    }
    return 𝓟802 = 𝓛8743{String}.PlusToken(𝓟[ty]780{Union}.types.map(𝓟803{$Lambda118}).join(𝓛8743{String})).PlusToken(𝓛8743{String})
  }
  function 𝓟806{instantiate} (𝓟807{parent}: [OOV]𝓟[ty]6979{INode},𝓟808{subpath}: 𝓛[ty]10051{String},𝓟809{environment}: [OOV]any,𝓟810{value}: [OOV]any): (𝓟811: [OOV]𝓟[ty]6979{INode})
  {
    return 𝓟811 = 𝓟[ty]780{Union}.determineType(𝓟810{value}).instantiate(𝓟807{parent},𝓟808{subpath},𝓟809{environment},𝓟810{value})
  }
  function 𝓟823{isValidSnapshot} (𝓟824{value}: [OOV]any,𝓟825{context}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟826: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
  {
    if (𝓟[ty]780{Union}.dispatcher.ExclamationEqualsEqualsToken(𝓛12563{undefined}))
    {
      return 𝓟826 = 𝓟[ty]780{Union}.dispatcher(𝓟824{value}).validate(𝓟824{value},𝓟825{context})
    }
    function 𝓟827{$Lambda120} (𝓟828{type}): (𝓟829: [miss]𝓛[ty]8670{Array})
    {
      return 𝓟829 = 𝓟828{type}.validate(𝓟824{value},𝓟825{context})
    }
    const 𝓟830{errors}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]780{Union}.types.map(𝓟827{$Lambda120});
    function 𝓟831{$Lambda121} (𝓟832{errorArray}): (𝓟833: [miss]𝓛[ty]8666{Boolean})
    {
      return 𝓟833 = 𝓟832{errorArray}.length.EqualsEqualsEqualsToken(𝓛8745{Number})
    }
    const 𝓟834{applicableTypes}: [miss]𝓛[ty]8670{Array} = 𝓟830{errors}.filter(𝓟831{$Lambda121});
    if (𝓟834{applicableTypes}.length.GreaterThanToken(𝓛8745{Number}))
    {
      return 𝓟826 = 𝓟1319{typeCheckFailure}(𝓟825{context},𝓟824{value},𝓛8743{String})
    }
    else
    {
      if (𝓟834{applicableTypes}.length.EqualsEqualsEqualsToken(𝓛8745{Number}))
      {
        return 𝓟826 = 𝓟1319{typeCheckFailure}(𝓟825{context},𝓟824{value},𝓛8743{String}).concat(𝓟1324{flattenTypeErrors}(𝓟830{errors}))
      }
    }
    return 𝓟826 = 𝓟1317{typeCheckSuccess}()
  }
  function 𝓟812{reconcile} (𝓟813{current}: [OOV]𝓟[ty]6979{INode},𝓟814{newValue}: [OOV]any): (𝓟815: [OOV]𝓟[ty]6979{INode})
  {
    return 𝓟815 = 𝓟[ty]780{Union}.determineType(𝓟814{newValue}).reconcile(𝓟813{current},𝓟814{newValue})
  }
  function 𝓟795{isAssignableFrom} (𝓟796{type}: [OOV]𝓟[ty]6960{IType}): (𝓟797: [miss]𝓛[ty]8666{Boolean})
  {
    function 𝓟798{$Lambda117} (𝓟799{subType}): (𝓟800: [miss]𝓛[ty]8666{Boolean})
    {
      return 𝓟800 = 𝓟799{subType}.isAssignableFrom(𝓟796{type})
    }
    return 𝓟797 = 𝓟[ty]780{Union}.types.some(𝓟798{$Lambda117})
  }
  function 𝓟790{shouldAttachNode} (): (𝓟791)
  {
    function 𝓟792{$Lambda116} (𝓟793{type}): (𝓟794: [miss]𝓛[ty]8666{Boolean})
    {
      return 𝓟794 = 𝓟793{type}.shouldAttachNode
    }
    return 𝓟791 = 𝓟[ty]780{Union}.types.some(𝓟792{$Lambda116})
  }
}
function 𝓟835{union} (𝓟836{dispatch}: [OOV]𝓟[ty]6990{ITypeDispatcher},𝓟837{A}: [OOV]𝓟[ty]6960{IType},𝓟838{B}: [OOV]𝓟[ty]6960{IType}): (𝓟839: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟840{union} (𝓟841{A}: [OOV]𝓟[ty]6960{IType},𝓟842{B}: [OOV]𝓟[ty]6960{IType}): (𝓟843: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟844{union} (𝓟845{dispatch}: [OOV]𝓟[ty]6990{ITypeDispatcher},𝓟846{A}: [OOV]𝓟[ty]6960{IType},𝓟847{B}: [OOV]𝓟[ty]6960{IType},𝓟848{C}: [OOV]𝓟[ty]6960{IType}): (𝓟849: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟850{union} (𝓟851{A}: [OOV]𝓟[ty]6960{IType},𝓟852{B}: [OOV]𝓟[ty]6960{IType},𝓟853{C}: [OOV]𝓟[ty]6960{IType}): (𝓟854: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟855{union} (𝓟856{dispatch}: [OOV]𝓟[ty]6990{ITypeDispatcher},𝓟857{A}: [OOV]𝓟[ty]6960{IType},𝓟858{B}: [OOV]𝓟[ty]6960{IType},𝓟859{C}: [OOV]𝓟[ty]6960{IType},𝓟860{D}: [OOV]𝓟[ty]6960{IType}): (𝓟861: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟862{union} (𝓟863{A}: [OOV]𝓟[ty]6960{IType},𝓟864{B}: [OOV]𝓟[ty]6960{IType},𝓟865{C}: [OOV]𝓟[ty]6960{IType},𝓟866{D}: [OOV]𝓟[ty]6960{IType}): (𝓟867: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟868{union} (𝓟869{dispatch}: [OOV]𝓟[ty]6990{ITypeDispatcher},𝓟870{A}: [OOV]𝓟[ty]6960{IType},𝓟871{B}: [OOV]𝓟[ty]6960{IType},𝓟872{C}: [OOV]𝓟[ty]6960{IType},𝓟873{D}: [OOV]𝓟[ty]6960{IType},𝓟874{E}: [OOV]𝓟[ty]6960{IType}): (𝓟875: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟876{union} (𝓟877{A}: [OOV]𝓟[ty]6960{IType},𝓟878{B}: [OOV]𝓟[ty]6960{IType},𝓟879{C}: [OOV]𝓟[ty]6960{IType},𝓟880{D}: [OOV]𝓟[ty]6960{IType},𝓟881{E}: [OOV]𝓟[ty]6960{IType}): (𝓟882: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟883{union} (𝓟884{dispatch}: [OOV]𝓟[ty]6990{ITypeDispatcher},𝓟885{A}: [OOV]𝓟[ty]6960{IType},𝓟886{B}: [OOV]𝓟[ty]6960{IType},𝓟887{C}: [OOV]𝓟[ty]6960{IType},𝓟888{D}: [OOV]𝓟[ty]6960{IType},𝓟889{E}: [OOV]𝓟[ty]6960{IType},𝓟890{F}: [OOV]𝓟[ty]6960{IType}): (𝓟891: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟892{union} (𝓟893{A}: [OOV]𝓟[ty]6960{IType},𝓟894{B}: [OOV]𝓟[ty]6960{IType},𝓟895{C}: [OOV]𝓟[ty]6960{IType},𝓟896{D}: [OOV]𝓟[ty]6960{IType},𝓟897{E}: [OOV]𝓟[ty]6960{IType},𝓟898{F}: [OOV]𝓟[ty]6960{IType}): (𝓟899: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟900{union} (𝓟901{dispatch}: [OOV]𝓟[ty]6990{ITypeDispatcher},𝓟902{A}: [OOV]𝓟[ty]6960{IType},𝓟903{B}: [OOV]𝓟[ty]6960{IType},𝓟904{C}: [OOV]𝓟[ty]6960{IType},𝓟905{D}: [OOV]𝓟[ty]6960{IType},𝓟906{E}: [OOV]𝓟[ty]6960{IType},𝓟907{F}: [OOV]𝓟[ty]6960{IType},𝓟908{G}: [OOV]𝓟[ty]6960{IType}): (𝓟909: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟910{union} (𝓟911{A}: [OOV]𝓟[ty]6960{IType},𝓟912{B}: [OOV]𝓟[ty]6960{IType},𝓟913{C}: [OOV]𝓟[ty]6960{IType},𝓟914{D}: [OOV]𝓟[ty]6960{IType},𝓟915{E}: [OOV]𝓟[ty]6960{IType},𝓟916{F}: [OOV]𝓟[ty]6960{IType},𝓟917{G}: [OOV]𝓟[ty]6960{IType}): (𝓟918: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟919{union} (𝓟920{dispatch}: [OOV]𝓟[ty]6990{ITypeDispatcher},𝓟921{A}: [OOV]𝓟[ty]6960{IType},𝓟922{B}: [OOV]𝓟[ty]6960{IType},𝓟923{C}: [OOV]𝓟[ty]6960{IType},𝓟924{D}: [OOV]𝓟[ty]6960{IType},𝓟925{E}: [OOV]𝓟[ty]6960{IType},𝓟926{F}: [OOV]𝓟[ty]6960{IType},𝓟927{G}: [OOV]𝓟[ty]6960{IType},𝓟928{H}: [OOV]𝓟[ty]6960{IType}): (𝓟929: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟930{union} (𝓟931{A}: [OOV]𝓟[ty]6960{IType},𝓟932{B}: [OOV]𝓟[ty]6960{IType},𝓟933{C}: [OOV]𝓟[ty]6960{IType},𝓟934{D}: [OOV]𝓟[ty]6960{IType},𝓟935{E}: [OOV]𝓟[ty]6960{IType},𝓟936{F}: [OOV]𝓟[ty]6960{IType},𝓟937{G}: [OOV]𝓟[ty]6960{IType},𝓟938{H}: [OOV]𝓟[ty]6960{IType}): (𝓟939: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟940{union} (𝓟941{dispatch}: [OOV]𝓟[ty]6990{ITypeDispatcher},𝓟942{A}: [OOV]𝓟[ty]6960{IType},𝓟943{B}: [OOV]𝓟[ty]6960{IType},𝓟944{C}: [OOV]𝓟[ty]6960{IType},𝓟945{D}: [OOV]𝓟[ty]6960{IType},𝓟946{E}: [OOV]𝓟[ty]6960{IType},𝓟947{F}: [OOV]𝓟[ty]6960{IType},𝓟948{G}: [OOV]𝓟[ty]6960{IType},𝓟949{H}: [OOV]𝓟[ty]6960{IType},𝓟950{I}: [OOV]𝓟[ty]6960{IType}): (𝓟951: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟952{union} (𝓟953{A}: [OOV]𝓟[ty]6960{IType},𝓟954{B}: [OOV]𝓟[ty]6960{IType},𝓟955{C}: [OOV]𝓟[ty]6960{IType},𝓟956{D}: [OOV]𝓟[ty]6960{IType},𝓟957{E}: [OOV]𝓟[ty]6960{IType},𝓟958{F}: [OOV]𝓟[ty]6960{IType},𝓟959{G}: [OOV]𝓟[ty]6960{IType},𝓟960{H}: [OOV]𝓟[ty]6960{IType},𝓟961{I}: [OOV]𝓟[ty]6960{IType}): (𝓟962: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟963{union} (𝓟964{dispatch}: [OOV]𝓟[ty]6990{ITypeDispatcher},𝓟965{A}: [OOV]𝓟[ty]6960{IType},𝓟966{B}: [OOV]𝓟[ty]6960{IType},𝓟967{C}: [OOV]𝓟[ty]6960{IType},𝓟968{D}: [OOV]𝓟[ty]6960{IType},𝓟969{E}: [OOV]𝓟[ty]6960{IType},𝓟970{F}: [OOV]𝓟[ty]6960{IType},𝓟971{G}: [OOV]𝓟[ty]6960{IType},𝓟972{H}: [OOV]𝓟[ty]6960{IType},𝓟973{I}: [OOV]𝓟[ty]6960{IType},𝓟974{J}: [OOV]𝓟[ty]6960{IType}): (𝓟975: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟976{union} (𝓟977{A}: [OOV]𝓟[ty]6960{IType},𝓟978{B}: [OOV]𝓟[ty]6960{IType},𝓟979{C}: [OOV]𝓟[ty]6960{IType},𝓟980{D}: [OOV]𝓟[ty]6960{IType},𝓟981{E}: [OOV]𝓟[ty]6960{IType},𝓟982{F}: [OOV]𝓟[ty]6960{IType},𝓟983{G}: [OOV]𝓟[ty]6960{IType},𝓟984{H}: [OOV]𝓟[ty]6960{IType},𝓟985{I}: [OOV]𝓟[ty]6960{IType},𝓟986{J}: [OOV]𝓟[ty]6960{IType}): (𝓟987: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟988{union} (𝓟989{types}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8670{Array})): (𝓟990: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟991{union} (𝓟992{dispatchOrType}: [OOV]any,𝓟993{otherTypes}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8670{Array})): (𝓟994: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟995{union} (𝓟996{dispatchOrType}: [OOV]any,𝓟997{otherTypes}: 𝓛[ty]8670{Array}): (𝓟998: [OOV]𝓟[ty]6960{IType})
{
  const 𝓟999{dispatcher}: [OOV]𝓟[ty]6990{ITypeDispatcher} = (𝓟2822{isType}(𝓟996{dispatchOrType}) ? 𝓛12563{undefined} : 𝓟996{dispatchOrType};
  const 𝓟1000{types}: [miss]𝓛[ty]8670{Array} = (𝓟2822{isType}(𝓟996{dispatchOrType}) ? 𝓟997{otherTypes}.concat(𝓟996{dispatchOrType}) : 𝓟997{otherTypes};
  function 𝓟1001{$Lambda122} (𝓟1002{type}): (𝓟1003: [miss]𝓛[ty]10051{String})
  {
    return 𝓟1003 = 𝓟1002{type}.name
  }
  const 𝓟1004{name}: [miss]𝓛[ty]10051{String} = 𝓛8743{String}.PlusToken(𝓟1000{types}.map(𝓟1001{$Lambda122}).join(𝓛8743{String})).PlusToken(𝓛8743{String});
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    function 𝓟1005{$Lambda123} (𝓟1006{type}): (𝓟1007: [miss]𝓛[ty]10033{Void})
    {
      if (𝓛12548{ExclamationToken}(𝓟2822{isType}(𝓟1006{type})))
      {
        𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟1006{type}).PlusToken(𝓛8743{String}))
      }
    }
    𝓟1000{types}.forEach(𝓟1005{$Lambda123})
  }
  return 𝓟998 = 𝓟773{CONSTRUCTOR}(𝓟1004{name},𝓟1000{types},𝓟999{dispatcher})
}
function 𝓟1008{isUnionType} (𝓟1009{type}: [OOV]any): (𝓟1010: 𝓛[ty]8666{Boolean})
{
  return 𝓟1010 = 𝓟1009{type}.flags.AmpersandToken(𝓟2693{TypeFlags}.Union).GreaterThanToken(𝓛8745{Number})
}

Module: packages/mobx-state-tree/src/types/complex-types/map

type 𝓟[ty]6991{IExtendedObservableMap} extends 𝓛[ty]2{<UNKNOWN>} = {put: (any)->any}
type 𝓟[ty]6945{IMapFactoryConfig} = {isMapFactory: 𝓛[ty]8666{Boolean}}
function 𝓟1110{mapToString} (𝓟1111{this}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟1112: [miss]𝓛[ty]10051{String})
{
  return 𝓟1112 = 𝓛12554{$Template}(𝓟676{getStateTreeNode}(𝓟1111{this} as 𝓟[ty]6977{IStateTreeNode}),𝓟1111{this}.size)
}
function 𝓟1113{put} (𝓟1114{this}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟1115{value}: [OOV]any): (𝓟1116: [OOV]any)
{
  if (𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓟1115{value}))))
  {
    𝓟376{fail}(𝓛8743{String})
  }
  let 𝓟1117{node}: [OOV]𝓟[ty]2343{ObjectNode};
  if (𝓟673{isStateTreeNode}(𝓟1115{value}))
  {
    𝓟1117{node} ⟵ 𝓟676{getStateTreeNode}(𝓟1115{value});
  }
  else
  {
    if (𝓟449{isMutable}(𝓟1115{value}))
    {
      const 𝓟1118{targetType}: [OOV]𝓟[ty]6960{IType} = 𝓟676{getStateTreeNode}(𝓟1114{this} as 𝓟[ty]6977{IStateTreeNode}).type as 𝓟[ty]1136{MapType}.subType;
      𝓟1117{node} ⟵ 𝓟676{getStateTreeNode}(𝓟1118{targetType}.create(𝓟1115{value}));
    }
    else
    {
      return 𝓟1116 = 𝓟376{fail}(𝓛8743{String})
    }
  }
  if (𝓛12548{ExclamationToken}(𝓟1117{node}.identifierAttribute))
  {
    𝓟376{fail}(𝓛8743{String})
  }
  𝓟1114{this}.set(𝓟1117{node}.identifier,𝓟1117{node}.value)
  return 𝓟1116 = 𝓟1114{this}
}
function 𝓟1119{CONSTRUCTOR} (𝓟1120{name}: 𝓛[ty]10051{String},𝓟1121{subType}: [OOV]𝓟[ty]6960{IType}): (𝓟[ty]1136{MapType})
{
  const 𝓟[ty]1136{MapType};
  const 𝓟[ty]1136{MapType};
  function 𝓟1125{$Lambda80} (): (𝓟1126: [OOV]any)
  {
    const 𝓟1127{map} = 𝓟2830{observable}.shallowMap();
    𝓟467{addHiddenFinalProp}(𝓟1127{map},𝓛8743{String},𝓟1113{put})
    𝓟467{addHiddenFinalProp}(𝓟1127{map},𝓛8743{String},𝓟1110{mapToString})
    return 𝓟1126 = 𝓟1127{map}
  }
  function 𝓟1128{$Lambda81} (𝓟1129{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1130{snapshot}: [OOV]any): (𝓟1131: [miss]𝓛[ty]10033{Void})
  {
    const 𝓟1132{instance} = 𝓟1129{node}.storedValue as 𝓛[ty]2{<UNKNOWN>};
    𝓟2836{extras}.interceptReads(𝓟1132{instance},𝓟1129{node}.unbox)
    function 𝓟1133{$Lambda82} (𝓟1134{c}): (𝓟1135: [OOV]any)
    {
      return 𝓟1135 = 𝓟[ty]1136{MapType}.willChange(𝓟1134{c})
    }
    𝓟2834{intercept}(𝓟1132{instance},𝓟1133{$Lambda82})
    𝓟1129{node}.applySnapshot(𝓟1130{snapshot})
    𝓟2835{observe}(𝓟1132{instance},𝓟[ty]1136{MapType}.didChange)
  }
  𝓟[ty]1136{MapType}.shouldAttachNode ⟵ 𝓛8744{Boolean};
  𝓟[ty]1136{MapType}.finalizeNewInstance ⟵ 𝓟1128{$Lambda81};
  𝓟[ty]1136{MapType}.createNewInstance ⟵ 𝓟1125{$Lambda80};
  𝓟[ty]1136{MapType}.flags ⟵ 𝓟2693{TypeFlags}.Map;
  𝓟[ty]1136{MapType}(𝓟1120{name})
  𝓟[ty]1136{MapType}.subType ⟵ 𝓟1121{subType};
}
class 𝓟[ty]1136{MapType} extends 𝓟[ty]2699{ComplexType}{
  𝓟1138{flags}: [miss]𝓛[ty]8655{Number};
  𝓟1139{createNewInstance}: [miss]𝓛[ty]8696{Function};
  𝓟1140{finalizeNewInstance}: [miss]𝓛[ty]8696{Function};
  𝓟1141{subType}: [OOV]𝓟[ty]6960{IType};
  𝓟1142{shouldAttachNode}: [miss]𝓛[ty]8666{Boolean};
  function 𝓟1180{didChange} (𝓟1181{change}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟1182: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10033{Void}))
  {
    const 𝓟1183{node}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟1181{change}.object as 𝓟[ty]6977{IStateTreeNode});
    𝓛12549{$Switch}(𝓟1181{change}.type)
    𝓛12561{$Case}(𝓛8743{String})
    return 𝓟1182 = 𝓛10034{Void}
    𝓛12561{$Case}(𝓛8743{String})
    return 𝓟1182 = 𝓛10034{Void}
    𝓛12561{$Case}(𝓛8743{String})
    const 𝓟1184{oldSnapshot} = 𝓟1181{change}.oldValue.snapshot;
    𝓟1181{change}.oldValue.die()
    return 𝓟1182 = 𝓛10034{Void}
  }
  function 𝓟1191{applySnapshot} (𝓟1192{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1193{snapshot}: [OOV]any): (𝓟1194: 𝓛[ty]10033{Void})
  {
    𝓟1331{typecheck}(𝓟[ty]1136{MapType},𝓟1193{snapshot})
    const 𝓟1195{target} = 𝓟1192{node}.storedValue as 𝓛[ty]2{<UNKNOWN>};
    const 𝓟1196{currentKeys}: 𝓛[ty]8642{Object} = {};
    function 𝓟1197{$Lambda84} (𝓟1198{key}): (𝓟1199: [miss]𝓛[ty]10033{Void})
    {
      𝓟1196{currentKeys}.access(𝓟1198{key}) ⟵ 𝓛8744{Boolean};
    }
    𝓟1195{target}.keys().forEach(𝓟1197{$Lambda84})
    function 𝓟1200{$Lambda85} (𝓟1201{key}): (𝓟1202: [miss]𝓛[ty]10033{Void})
    {
      𝓟1195{target}.set(𝓟1201{key},𝓟1193{snapshot}.access(𝓟1201{key}))
      𝓟1196{currentKeys}.access(𝓟1201{key}) ⟵ 𝓛8744{Boolean};
    }
    𝓛8741{Object}.keys(𝓟1193{snapshot}).forEach(𝓟1200{$Lambda85})
    function 𝓟1203{$Lambda86} (𝓟1204{key}): (𝓟1205: [miss]𝓛[ty]10033{Void})
    {
      if (𝓟1196{currentKeys}.access(𝓟1204{key}).EqualsEqualsEqualsToken(𝓛8744{Boolean}))
      {
        𝓟1195{target}.delete(𝓟1204{key})
      }
    }
    𝓛8741{Object}.keys(𝓟1196{currentKeys}).forEach(𝓟1203{$Lambda86})
  }
  function 𝓟1173{getSnapshot} (𝓟1174{node}: [OOV]𝓟[ty]2343{ObjectNode}): (𝓟1175: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8642{Object}))
  {
    const 𝓟1176{res}: 𝓛[ty]8642{Object} = {};
    function 𝓟1177{$Lambda83} (𝓟1178{childNode}): (𝓟1179: [miss]𝓛[ty]10033{Void})
    {
      𝓟1176{res}.access(𝓟1178{childNode}.subpath) ⟵ 𝓟1178{childNode}.snapshot;
    }
    𝓟1174{node}.getChildren().forEach(𝓟1177{$Lambda83})
    return 𝓟1175 = 𝓟1176{res}
  }
  function 𝓟1149{describe} (): (𝓟1150: [miss]𝓛[ty]10051{String})
  {
    return 𝓟1150 = 𝓛8743{String}.PlusToken(𝓟[ty]1136{MapType}.subType.describe()).PlusToken(𝓛8743{String})
  }
  function 𝓟1165{verifyIdentifier} (𝓟1166{expected}: 𝓛[ty]10051{String},𝓟1167{node}: [OOV]𝓟[ty]6979{INode}): (𝓟1168: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟1167{node}.InstanceOfKeyword(𝓛12563{undefined}))
    {
      const 𝓟1169{identifier}: [miss]𝓛[ty]10051{String} = 𝓟1167{node}.identifier;
      if (𝓟1169{identifier}.ExclamationEqualsEqualsToken(𝓛12563{undefined}).AmpersandAmpersandToken(𝓛8743{String}.PlusToken(𝓟1169{identifier}).ExclamationEqualsEqualsToken(𝓛8743{String}.PlusToken(𝓟1166{expected}))))
      {
        𝓟376{fail}(𝓛12554{$Template}(𝓟1169{identifier},𝓟1166{expected}))
      }
    }
  }
  function 𝓟1143{instantiate} (𝓟1144{parent}: [OOV]any,𝓟1145{subpath}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10051{String}),𝓟1146{environment}: [OOV]any,𝓟1147{snapshot}: [OOV]any): (𝓟1148: [OOV]𝓟[ty]6979{INode})
  {
    return 𝓟1148 = 𝓟2551{createNode}(𝓟[ty]1136{MapType},𝓟1144{parent},𝓟1145{subpath},𝓟1146{environment},𝓟1147{snapshot},𝓟[ty]1136{MapType}.createNewInstance,𝓟[ty]1136{MapType}.finalizeNewInstance)
  }
  function 𝓟1154{getChildNode} (𝓟1155{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1156{key}: 𝓛[ty]10051{String}): (𝓟1157: [OOV]𝓟[ty]6979{INode})
  {
    const 𝓟1158{childNode} = 𝓟1155{node}.storedValue.get(𝓟1156{key});
    if (𝓛12548{ExclamationToken}(𝓟1158{childNode}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟1156{key}))
    }
    return 𝓟1157 = 𝓟1158{childNode}
  }
  function 𝓟1206{getChildType} (𝓟1207{key}: 𝓛[ty]10051{String}): (𝓟1208: [OOV]𝓟[ty]6960{IType})
  {
    return 𝓟1208 = 𝓟[ty]1136{MapType}.subType
  }
  function 𝓟1209{isValidSnapshot} (𝓟1210{value}: [OOV]any,𝓟1211{context}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1212: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
  {
    if (𝓛12548{ExclamationToken}(𝓟445{isPlainObject}(𝓟1210{value})))
    {
      return 𝓟1212 = 𝓟1319{typeCheckFailure}(𝓟1211{context},𝓟1210{value},𝓛8743{String})
    }
    function 𝓟1213{$Lambda87} (𝓟1214{path}): (𝓟1215: [miss]𝓛[ty]8670{Array})
    {
      return 𝓟1215 = 𝓟[ty]1136{MapType}.subType.validate(𝓟1210{value}.access(𝓟1214{path}),𝓟1312{getContextForPath}(𝓟1211{context},𝓟1214{path},𝓟[ty]1136{MapType}.subType))
    }
    return 𝓟1212 = 𝓟1324{flattenTypeErrors}(𝓛8741{Object}.keys(𝓟1210{value}).map(𝓟1213{$Lambda87}))
  }
  function 𝓟1151{getChildren} (𝓟1152{node}: [OOV]𝓟[ty]2343{ObjectNode}): (𝓟1153: (𝓛[ty]8654{Promise} ≠ 𝓛[ty]8670{Array}))
  {
    return 𝓟1153 = 𝓟1152{node}.storedValue as 𝓛[ty]2{<UNKNOWN>}.values()
  }
  function 𝓟1185{applyPatchLocally} (𝓟1186{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1187{subpath}: 𝓛[ty]10051{String},𝓟1188{patch}: [OOV]𝓟[ty]6980{IJsonPatch}): (𝓟1189: 𝓛[ty]10033{Void})
  {
    const 𝓟1190{target} = 𝓟1186{node}.storedValue as 𝓛[ty]2{<UNKNOWN>};
    𝓛12549{$Switch}(𝓟1188{patch}.op)
    𝓛12561{$Case}(𝓛8743{String})
    𝓛12561{$Case}(𝓛8743{String})
    𝓟1190{target}.set(𝓟1187{subpath},𝓟1188{patch}.value)
    𝓛12561{$Case}(𝓛8743{String})
    𝓟1190{target}.delete(𝓟1187{subpath})
  }
  function 𝓟1218{removeChild} (𝓟1219{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1220{subpath}: 𝓛[ty]10051{String}): (𝓟1221: [miss]𝓛[ty]10033{Void})
  {
    𝓟1219{node}.storedValue as 𝓛[ty]2{<UNKNOWN>}.delete(𝓟1220{subpath})
  }
  function 𝓟1170{getValue} (𝓟1171{node}: [OOV]𝓟[ty]2343{ObjectNode}): (𝓟1172: [OOV]any)
  {
    return 𝓟1172 = 𝓟1171{node}.storedValue
  }
  function 𝓟1159{willChange} (𝓟1160{change}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟1161: [OOV]any)
  {
    const 𝓟1162{node}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟1160{change}.object as 𝓟[ty]6977{IStateTreeNode});
    𝓟1162{node}.assertWritable()
    𝓛12549{$Switch}(𝓟1160{change}.type)
    𝓛12561{$Case}(𝓛8743{String})
    {
      const 𝓟1163{newValue} = 𝓟1160{change}.newValue;
      const 𝓟1164{oldValue} = 𝓟1160{change}.object.get(𝓟1160{change}.name);
      if (𝓟1163{newValue}.EqualsEqualsEqualsToken(𝓟1164{oldValue}))
      {
        return 𝓟1161 = 𝓛12563{undefined}
      }
      𝓟1331{typecheck}(𝓟[ty]1136{MapType}.subType,𝓟1163{newValue})
      𝓟1160{change}.newValue ⟵ 𝓟[ty]1136{MapType}.subType.reconcile(𝓟1162{node}.getChildNode(𝓟1160{change}.name),𝓟1160{change}.newValue);
      𝓟[ty]1136{MapType}.verifyIdentifier(𝓟1160{change}.name,𝓟1160{change}.newValue as 𝓟[ty]6979{INode})
    }
    𝓛12561{$Case}(𝓛8743{String})
    {
      𝓟1331{typecheck}(𝓟[ty]1136{MapType}.subType,𝓟1160{change}.newValue)
      𝓟1160{change}.newValue ⟵ 𝓟[ty]1136{MapType}.subType.instantiate(𝓟1162{node},𝓟1160{change}.name,𝓛12563{undefined},𝓟1160{change}.newValue);
      𝓟[ty]1136{MapType}.verifyIdentifier(𝓟1160{change}.name,𝓟1160{change}.newValue as 𝓟[ty]6979{INode})
    }
    return 𝓟1161 = 𝓟1160{change}
  }
  function 𝓟1216{getDefaultSnapshot} (): (𝓟1217: [miss]𝓛[ty]8642{Object})
  {
    return 𝓟1217 = {}
  }
}
function 𝓟1222{map} (𝓟1223{subtype}: [OOV]𝓟[ty]6960{IType}): (𝓟1224: [OOV]𝓟[ty]6970{IComplexType})
{
  return 𝓟1224 = 𝓟1119{CONSTRUCTOR}(𝓛12554{$Template}(𝓟1223{subtype}.name),𝓟1223{subtype})
}
function 𝓟1225{isMapType} (𝓟1226{type}: [OOV]any): (𝓟1227: 𝓛[ty]8666{Boolean})
{
  return 𝓟1227 = 𝓟2822{isType}(𝓟1226{type}).AmpersandAmpersandToken(𝓟1226{type}.flags.AmpersandToken(𝓟2693{TypeFlags}.Map).GreaterThanToken(𝓛8745{Number}))
}

Module: packages/mobx-state-tree/src/core/type/type-checker

type 𝓟[ty]6961{IValidationError} = {context: 𝓛[ty]8670{Array}, value: any, message: 𝓛[ty]10051{String}}
type 𝓛[ty]8670{Array} = 𝓛[ty]8670{Array}
type 𝓟[ty]6975{IContextEntry} = {path: 𝓛[ty]10051{String}, type: 𝓟[ty]6960{IType}}
type 𝓛[ty]8670{Array} = 𝓛[ty]8670{Array}
function 𝓟1285{safeStringify} (𝓟1286{value}: [OOV]any): (𝓟1287: [miss]𝓛[ty]10051{String})
{
  {
    return 𝓟1287 = 𝓛8756{JSON}.stringify(𝓟1286{value})
  }
}
function 𝓟1288{prettyPrintValue} (𝓟1289{value}: [OOV]any): (𝓟1290: [miss]𝓛[ty]10051{String})
{
  return 𝓟1290 = (𝓛12550{$TypeOf}(𝓟1289{value}).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓛12554{$Template}((𝓟1289{value}.name ? 𝓛8743{String}.PlusToken(𝓟1289{value}.name) : 𝓛8743{String}) : (𝓟673{isStateTreeNode}(𝓟1289{value}) ? 𝓛12554{$Template}(𝓟1289{value}) : 𝓛12554{$Template}(𝓟1285{safeStringify}(𝓟1289{value}))
}
function 𝓟1291{shortenPrintValue} (𝓟1292{valueInString}: 𝓛[ty]10051{String}): (𝓟1293: [miss]𝓛[ty]10051{String})
{
  return 𝓟1293 = (𝓟1292{valueInString}.length.FirstBinaryOperator(𝓛8745{Number}) ? 𝓟1292{valueInString} : 𝓛12554{$Template}(𝓟1292{valueInString}.substring(𝓛8745{Number},𝓛8745{Number}),𝓟1292{valueInString}.substring(𝓟1292{valueInString}.length.MinusToken(𝓛8745{Number})))
}
function 𝓟1294{toErrorString} (𝓟1295{error}: [OOV]𝓟[ty]6961{IValidationError}): (𝓟1296: (𝓛[ty]10033{Void} ≠ 𝓛[ty]10051{String}))
{
  const 𝓟1297{value} = 𝓟1295{error}.value;
  const 𝓟1298{type}: [OOV]𝓟[ty]6960{IType} = 𝓟1295{error}.context.access(𝓟1295{error}.context.length.MinusToken(𝓛8745{Number})).type as any;
  function 𝓟1299{$Lambda71} (𝓟1300{_}): (𝓟1301: [miss]𝓛[ty]10051{String})
  {
  }
  function 𝓟1302{$Lambda72} (𝓟1303{path}): (𝓟1304: [miss]𝓛[ty]8666{Boolean})
  {
    return 𝓟1304 = 𝓛1{<UNKNOWN>}.GreaterThanToken(𝓛8745{Number})
  }
  const 𝓟1305{fullPath}: [miss]𝓛[ty]10051{String} = 𝓟1295{error}.context.map(𝓟1299{$Lambda71}).filter(𝓟1302{$Lambda72}).join(𝓛8743{String});
  const 𝓟1306{pathPrefix}: [miss]𝓛[ty]10051{String} = (𝓟1305{fullPath}.length.GreaterThanToken(𝓛8745{Number}) ? 𝓛12554{$Template}(𝓟1305{fullPath}) : 𝓛8743{String};
  const 𝓟1307{currentTypename}: [miss]𝓛[ty]10051{String} = (𝓟673{isStateTreeNode}(𝓟1297{value}) ? 𝓛12554{$Template}(𝓟676{getStateTreeNode}(𝓟1297{value}).type.name) : (𝓟452{isPrimitive}(𝓟1297{value}) ? 𝓛8743{String} : 𝓛8743{String};
  const 𝓟1308{isSnapshotCompatible}: [miss]𝓛[ty]8666{Boolean} = 𝓟1298{type}.AmpersandAmpersandToken(𝓟673{isStateTreeNode}(𝓟1297{value})).AmpersandAmpersandToken(𝓟1298{type}.is(𝓟676{getStateTreeNode}(𝓟1297{value}).snapshot));
  return 𝓟1296 = 𝓛12554{$Template}(𝓟1306{pathPrefix},𝓟1307{currentTypename},𝓟1288{prettyPrintValue}(𝓟1297{value}),(𝓟1298{type} ? 𝓛12554{$Template}(𝓟1298{type}.name) : 𝓛8743{String}).PlusToken((𝓟1295{error}.message ? 𝓛12554{$Template}(𝓟1295{error}.message) : 𝓛8743{String}).PlusToken((𝓟1298{type} ? (𝓟172{isPrimitiveType}(𝓟1298{type}) ? 𝓛8743{String} : 𝓛12554{$Template}(𝓟1298{type}.name,𝓟1298{type}.describe()).PlusToken((𝓟1308{isSnapshotCompatible} ? 𝓛8743{String} : 𝓛8743{String}) : 𝓛8743{String})
}
function 𝓟1309{getDefaultContext} (𝓟1310{type}: [OOV]𝓟[ty]6960{IType}): (𝓟1311: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}))
{
  return 𝓟1311 = 𝓛8757{Array}({type: 𝓟1310{type},path: 𝓛8743{String}})
}
function 𝓟1312{getContextForPath} (𝓟1313{context}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}),𝓟1314{path}: 𝓛[ty]10051{String},𝓟1315{type}: [OOV]𝓟[ty]6960{IType}): (𝓟1316: (𝓛[ty]8654{Promise} ≠ 𝓛[ty]8670{Array}))
{
  return 𝓟1316 = 𝓟1313{context}.concat(𝓛8757{Array}({path: 𝓟1314{path},type: 𝓟1315{type}}))
}
function 𝓟1317{typeCheckSuccess} (): (𝓟1318: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}))
{
  return 𝓟1318 = 𝓟374{EMPTY_ARRAY} as any
}
function 𝓟1319{typeCheckFailure} (𝓟1320{context}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟1321{value}: [OOV]any,𝓟1322{message}: 𝓛[ty]10051{String}): (𝓟1323: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array}))
{
  return 𝓟1323 = 𝓛8757{Array}({context: 𝓟1320{context},value: 𝓟1321{value},message: 𝓟1322{message}})
}
function 𝓟1324{flattenTypeErrors} (𝓟1325{errors}: 𝓛[ty]8670{Array}): (𝓟1326: 𝓛[ty]8670{Array})
{
  function 𝓟1327{$Lambda73} (𝓟1328{a},𝓟1329{i}): (𝓟1330: [miss]𝓛[ty]8670{Array})
  {
    return 𝓟1330 = 𝓟1328{a}.concat(𝓟1329{i})
  }
  return 𝓟1326 = 𝓟1325{errors}.reduce(𝓟1327{$Lambda73},𝓛8757{Array}())
}
function 𝓟1331{typecheck} (𝓟1332{type}: [OOV]𝓟[ty]6960{IType},𝓟1333{value}: [OOV]any): (𝓟1334: 𝓛[ty]10033{Void})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.EqualsEqualsEqualsToken(𝓛8743{String}))
  {
  }
  𝓟1335{typecheckPublic}(𝓟1332{type},𝓟1333{value})
}
function 𝓟1335{typecheckPublic} (𝓟1336{type}: [OOV]𝓟[ty]6960{IType},𝓟1337{value}: [OOV]any): (𝓟1338: 𝓛[ty]10033{Void})
{
  const 𝓟1339{errors}: [miss]𝓛[ty]8670{Array} = 𝓟1336{type}.validate(𝓟1337{value},𝓛8757{Array}({path: 𝓛8743{String},type: 𝓟1336{type}}));
  if (𝓟1339{errors}.length.GreaterThanToken(𝓛8745{Number}))
  {
    𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟1337{value})
    𝓟376{fail}(𝓛12554{$Template}(𝓟1291{shortenPrintValue}(𝓟1288{prettyPrintValue}(𝓟1337{value})),𝓟1336{type}.name).PlusToken(𝓟1339{errors}.map(𝓟1294{toErrorString}).join(𝓛8743{String})))
  }
}

Module: packages/mobx-state-tree/src/types/complex-types/array

function 𝓟1340{arrayToString} (𝓟1341{this}: [OOV]any): (𝓟1342: [miss]𝓛[ty]10051{String})
{
  return 𝓟1342 = 𝓛12554{$Template}(𝓟676{getStateTreeNode}(𝓟1341{this}),𝓟1341{this}.length)
}
function 𝓟1343{CONSTRUCTOR} (𝓟1344{name}: 𝓛[ty]10051{String},𝓟1345{subType}: [OOV]𝓟[ty]6960{IType}): (𝓟[ty]1360{ArrayType})
{
  const 𝓟[ty]1360{ArrayType};
  const 𝓟[ty]1360{ArrayType};
  function 𝓟1349{$Lambda74} (): (𝓟1350: [OOV]any)
  {
    const 𝓟1351{array} = 𝓟2830{observable}.shallowArray();
    𝓟467{addHiddenFinalProp}(𝓟1351{array},𝓛8743{String},𝓟1340{arrayToString})
    return 𝓟1350 = 𝓟1351{array}
  }
  function 𝓟1352{$Lambda75} (𝓟1353{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1354{snapshot}: [OOV]any): (𝓟1355: [miss]𝓛[ty]10033{Void})
  {
    const 𝓟1356{instance} = 𝓟1353{node}.storedValue as 𝓛[ty]2{<UNKNOWN>};
    𝓟2836{extras}.getAdministration(𝓟1356{instance}).dehancer ⟵ 𝓟1353{node}.unbox;
    function 𝓟1357{$Lambda76} (𝓟1358{change}): (𝓟1359: [OOV]any)
    {
      return 𝓟1359 = 𝓟[ty]1360{ArrayType}.willChange(𝓟1358{change}) as any
    }
    𝓟2834{intercept}(𝓟1356{instance},𝓟1357{$Lambda76})
    𝓟1353{node}.applySnapshot(𝓟1354{snapshot})
    𝓟2835{observe}(𝓟1356{instance},𝓟[ty]1360{ArrayType}.didChange)
  }
  𝓟[ty]1360{ArrayType}.shouldAttachNode ⟵ 𝓛8744{Boolean};
  𝓟[ty]1360{ArrayType}.finalizeNewInstance ⟵ 𝓟1352{$Lambda75};
  𝓟[ty]1360{ArrayType}.createNewInstance ⟵ 𝓟1349{$Lambda74};
  𝓟[ty]1360{ArrayType}.flags ⟵ 𝓟2693{TypeFlags}.Array;
  𝓟[ty]1360{ArrayType}(𝓟1344{name})
  𝓟[ty]1360{ArrayType}.subType ⟵ 𝓟1345{subType};
}
class 𝓟[ty]1360{ArrayType} extends 𝓟[ty]2699{ComplexType}{
  𝓟1362{flags}: [miss]𝓛[ty]8655{Number};
  𝓟1363{createNewInstance}: [miss]𝓛[ty]8696{Function};
  𝓟1364{finalizeNewInstance}: [miss]𝓛[ty]8696{Function};
  𝓟1365{subType}: [OOV]𝓟[ty]6960{IType};
  𝓟1366{shouldAttachNode}: [miss]𝓛[ty]8666{Boolean};
  function 𝓟1405{didChange} (𝓟1406{this}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8642{Object}),𝓟1407{change}: [OOV]any): (𝓟1408: 𝓛[ty]10033{Void})
  {
    const 𝓟1409{node}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟1407{change}.object as 𝓟[ty]6977{IStateTreeNode});
    𝓛12549{$Switch}(𝓟1407{change}.type)
    𝓛12561{$Case}(𝓛8743{String})
    return 𝓟1408 = 𝓛10034{Void}
    𝓛12561{$Case}(𝓛8743{String})
    {
      let 𝓟1410{i}: [miss]𝓛[ty]8655{Number} = 𝓟1407{change}.removedCount.MinusToken(𝓛8745{Number});
      while (𝓟1410{i}.GreaterThanEqualsToken(𝓛8745{Number}))
      {
        𝓟1409{node}.emitPatch({op: 𝓛8743{String},path: 𝓛8743{String}.PlusToken(𝓟1407{change}.index.PlusToken(𝓟1410{i})),oldValue: 𝓟1407{change}.removed.access(𝓟1410{i}).snapshot},𝓟1409{node})
        𝓛12555{POST_MinusMinusToken}(𝓟1410{i})
      }
    }
    {
      let 𝓟1411{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
      while (𝓟1411{i}.FirstBinaryOperator(𝓟1407{change}.addedCount))
      {
        𝓟1409{node}.emitPatch({op: 𝓛8743{String},path: 𝓛8743{String}.PlusToken(𝓟1407{change}.index.PlusToken(𝓟1411{i})),value: 𝓟1409{node}.getChildNode(𝓛8743{String}.PlusToken(𝓟1407{change}.index.PlusToken(𝓟1411{i}))).snapshot,oldValue: 𝓛12563{undefined}},𝓟1409{node})
        𝓛12546{POST_PlusPlusToken}(𝓟1411{i})
      }
    }
  }
  function 𝓟1419{applySnapshot} (𝓟1420{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1421{snapshot}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1422: 𝓛[ty]10033{Void})
  {
    𝓟1331{typecheck}(𝓟[ty]1360{ArrayType},𝓟1421{snapshot})
    const 𝓟1423{target} = 𝓟1420{node}.storedValue as 𝓛[ty]2{<UNKNOWN>};
    𝓟1423{target}.replace(𝓟1421{snapshot})
  }
  function 𝓟1399{getSnapshot} (𝓟1400{node}: [OOV]𝓟[ty]2343{ObjectNode}): (𝓟1401: [OOV]any)
  {
    function 𝓟1402{$Lambda78} (𝓟1403{childNode}): (𝓟1404: [OOV]any)
    {
      return 𝓟1404 = 𝓟1403{childNode}.snapshot
    }
    return 𝓟1401 = 𝓟1400{node}.getChildren().map(𝓟1402{$Lambda78})
  }
  function 𝓟1367{describe} (): (𝓟1368: [miss]𝓛[ty]10051{String})
  {
    return 𝓟1368 = 𝓟[ty]1360{ArrayType}.subType.describe().PlusToken(𝓛8743{String})
  }
  function 𝓟1369{instantiate} (𝓟1370{parent}: [OOV]any,𝓟1371{subpath}: 𝓛[ty]10051{String},𝓟1372{environment}: [OOV]any,𝓟1373{snapshot}: [OOV]any): (𝓟1374: [OOV]𝓟[ty]6979{INode})
  {
    return 𝓟1374 = 𝓟2551{createNode}(𝓟[ty]1360{ArrayType},𝓟1370{parent},𝓟1371{subpath},𝓟1372{environment},𝓟1373{snapshot},𝓟[ty]1360{ArrayType}.createNewInstance,𝓟[ty]1360{ArrayType}.finalizeNewInstance)
  }
  function 𝓟1378{getChildNode} (𝓟1379{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1380{key}: 𝓛[ty]10051{String}): (𝓟1381: [OOV]𝓟[ty]6979{INode})
  {
    const 𝓟1382{index}: [miss]𝓛[ty]8655{Number} = 𝓛8710{parseInt}(𝓟1380{key},𝓛8745{Number});
    if (𝓟1382{index}.FirstBinaryOperator(𝓟1379{node}.storedValue.length))
    {
      return 𝓟1381 = 𝓟1379{node}.storedValue.access(𝓟1382{index})
    }
    return 𝓟1381 = 𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟1380{key}))
  }
  function 𝓟1424{getChildType} (𝓟1425{key}: 𝓛[ty]10051{String}): (𝓟1426: [OOV]𝓟[ty]6960{IType})
  {
    return 𝓟1426 = 𝓟[ty]1360{ArrayType}.subType
  }
  function 𝓟1427{isValidSnapshot} (𝓟1428{value}: [OOV]any,𝓟1429{context}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1430: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
  {
    if (𝓛12548{ExclamationToken}(𝓟386{isArray}(𝓟1428{value})))
    {
      return 𝓟1430 = 𝓟1319{typeCheckFailure}(𝓟1429{context},𝓟1428{value},𝓛8743{String})
    }
    function 𝓟1431{$Lambda79} (𝓟1432{item}: [OOV]any,𝓟1433{index}: [OOV]any): (𝓟1434: [miss]𝓛[ty]8670{Array})
    {
      return 𝓟1434 = 𝓟[ty]1360{ArrayType}.subType.validate(𝓟1432{item},𝓟1312{getContextForPath}(𝓟1429{context},𝓛8743{String}.PlusToken(𝓟1433{index}),𝓟[ty]1360{ArrayType}.subType))
    }
    return 𝓟1430 = 𝓟1324{flattenTypeErrors}(𝓟1428{value}.map(𝓟1431{$Lambda79}))
  }
  function 𝓟1375{getChildren} (𝓟1376{node}: [OOV]𝓟[ty]2343{ObjectNode}): (𝓟1377: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}))
  {
    return 𝓟1377 = 𝓟1376{node}.storedValue.peek()
  }
  function 𝓟1412{applyPatchLocally} (𝓟1413{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1414{subpath}: 𝓛[ty]10051{String},𝓟1415{patch}: [OOV]𝓟[ty]6980{IJsonPatch}): (𝓟1416: 𝓛[ty]10033{Void})
  {
    const 𝓟1417{target} = 𝓟1413{node}.storedValue as 𝓛[ty]2{<UNKNOWN>};
    const 𝓟1418{index} = (𝓟1414{subpath}.EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟1417{target}.length : 𝓛8710{parseInt}(𝓟1414{subpath});
    𝓛12549{$Switch}(𝓟1415{patch}.op)
    𝓛12561{$Case}(𝓛8743{String})
    𝓟1417{target}.access(𝓟1418{index}) ⟵ 𝓟1415{patch}.value;
    𝓛12561{$Case}(𝓛8743{String})
    𝓟1417{target}.splice(𝓟1418{index},𝓛8745{Number},𝓟1415{patch}.value)
    𝓛12561{$Case}(𝓛8743{String})
    𝓟1417{target}.splice(𝓟1418{index},𝓛8745{Number})
  }
  function 𝓟1437{removeChild} (𝓟1438{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1439{subpath}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String})): (𝓟1440: [miss]𝓛[ty]10033{Void})
  {
    𝓟1438{node}.storedValue.splice(𝓛8710{parseInt}(𝓟1439{subpath},𝓛8745{Number}),𝓛8745{Number})
  }
  function 𝓟1396{getValue} (𝓟1397{node}: [OOV]𝓟[ty]2343{ObjectNode}): (𝓟1398: [OOV]any)
  {
    return 𝓟1398 = 𝓟1397{node}.storedValue
  }
  function 𝓟1383{willChange} (𝓟1384{change}: [OOV]any): (𝓟1385: [OOV]any)
  {
    const 𝓟1386{node}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟1384{change}.object as 𝓟[ty]6977{IStateTreeNode});
    𝓟1386{node}.assertWritable()
    const 𝓟1387{childNodes}: [miss]𝓛[ty]8670{Array} = 𝓟1386{node}.getChildren();
    𝓛12549{$Switch}(𝓟1384{change}.type)
    𝓛12561{$Case}(𝓛8743{String})
    if (𝓟1384{change}.newValue.EqualsEqualsEqualsToken(𝓟1384{change}.object.access(𝓟1384{change}.index)))
    {
      return 𝓟1385 = 𝓛12563{undefined}
    }
    𝓟1384{change}.newValue ⟵ 𝓟1444{reconcileArrayChildren}(𝓟1386{node},𝓟[ty]1360{ArrayType}.subType,𝓛8757{Array}(𝓟1387{childNodes}.access(𝓟1384{change}.index)),𝓛8757{Array}(𝓟1384{change}.newValue),𝓛8757{Array}(𝓟1384{change}.index)).access(𝓛8745{Number});
    𝓛12561{$Case}(𝓛8743{String})
    const 𝓟1388{index} = 𝓟1384{change}.index;
    const 𝓟1389{removedCount} = 𝓟1384{change}.removedCount;
    const 𝓟1390{added} = 𝓟1384{change}.added;
    function 𝓟1391{$Lambda77} (𝓟1392{_},𝓟1393{i}): (𝓟1394: [OOV]any)
    {
      return 𝓟1394 = 𝓟1388{index}.PlusToken(𝓟1393{i})
    }
    𝓟1384{change}.added ⟵ 𝓟1444{reconcileArrayChildren}(𝓟1386{node},𝓟[ty]1360{ArrayType}.subType,𝓟1387{childNodes}.slice(𝓟1388{index},𝓟1388{index}.PlusToken(𝓟1389{removedCount})),𝓟1390{added},𝓟1390{added}.map(𝓟1391{$Lambda77}));
    {
      let 𝓟1395{i} = 𝓟1388{index}.PlusToken(𝓟1389{removedCount});
      while (𝓟1395{i}.FirstBinaryOperator(𝓟1387{childNodes}.length))
      {
        {
          𝓟1387{childNodes}.access(𝓟1395{i}).setParent(𝓟1386{node},𝓛8743{String}.PlusToken(𝓟1395{i}.PlusToken(𝓟1390{added}.length).MinusToken(𝓟1389{removedCount})))
        }
        𝓛12546{POST_PlusPlusToken}(𝓟1395{i})
      }
    }
    return 𝓟1385 = 𝓟1384{change}
  }
  function 𝓟1435{getDefaultSnapshot} (): (𝓟1436: [miss]𝓛[ty]8670{Array})
  {
    return 𝓟1436 = 𝓛8757{Array}()
  }
}
function 𝓟1441{array} (𝓟1442{subtype}: [OOV]𝓟[ty]6960{IType}): (𝓟1443: [OOV]𝓟[ty]6970{IComplexType})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟2822{isType}(𝓟1442{subtype})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟1442{subtype}).PlusToken(𝓛8743{String}))
    }
  }
  return 𝓟1443 = 𝓟1343{CONSTRUCTOR}(𝓟1442{subtype}.name.PlusToken(𝓛8743{String}),𝓟1442{subtype})
}
function 𝓟1444{reconcileArrayChildren} (𝓟1445{parent}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1446{childType}: [OOV]𝓟[ty]6960{IType},𝓟1447{oldNodes}: 𝓛[ty]8670{Array},𝓟1448{newValues}: 𝓛[ty]8670{Array},𝓟1449{newPaths}: 𝓛[ty]8670{Array}): (𝓟1450: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
{
  let 𝓟1451{oldNode}: [OOV]𝓟[ty]6979{INode};
  let 𝓟1452{newValue}: [OOV]any;
  let 𝓟1453{hasNewNode}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
  let 𝓟1454{oldMatch}: [OOV]any = 𝓛12563{undefined};
  {
    let 𝓟1455{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
    while (𝓛8744{Boolean})
    {
      {
        𝓟1453{hasNewNode} ⟵ 𝓟1455{i}.LessThanEqualsToken(𝓟1448{newValues}.length.MinusToken(𝓛8745{Number}));
        𝓟1451{oldNode} ⟵ 𝓟1447{oldNodes}.access(𝓟1455{i});
        𝓟1452{newValue} ⟵ (𝓟1453{hasNewNode} ? 𝓟1448{newValues}.access(𝓟1455{i}) : 𝓛12563{undefined};
        if (𝓟2563{isNode}(𝓟1452{newValue}))
        {
          𝓟1452{newValue} ⟵ 𝓟1452{newValue}.storedValue;
        }
        if (𝓛12548{ExclamationToken}(𝓟1451{oldNode}).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟1453{hasNewNode})))
        {
        }
        else
        {
          if (𝓛12548{ExclamationToken}(𝓟1453{hasNewNode}))
          {
            𝓟1451{oldNode}.die()
            𝓟1447{oldNodes}.splice(𝓟1455{i},𝓛8745{Number})
            𝓛12555{POST_MinusMinusToken}(𝓟1455{i})
          }
          else
          {
            if (𝓛12548{ExclamationToken}(𝓟1451{oldNode}))
            {
              if (𝓟673{isStateTreeNode}(𝓟1452{newValue}).AmpersandAmpersandToken(𝓟676{getStateTreeNode}(𝓟1452{newValue}).parent.EqualsEqualsEqualsToken(𝓟1445{parent})))
              {
                𝓟376{fail}(𝓛12554{$Template}(𝓟1445{parent}.path,𝓟1449{newPaths}.access(𝓟1455{i}),𝓟676{getStateTreeNode}(𝓟1452{newValue}).path))
              }
              𝓟1447{oldNodes}.splice(𝓟1455{i},𝓛8745{Number},𝓟1457{valueAsNode}(𝓟1446{childType},𝓟1445{parent},𝓛8743{String}.PlusToken(𝓟1449{newPaths}.access(𝓟1455{i})),𝓟1452{newValue}))
            }
            else
            {
              if (𝓟1467{areSame}(𝓟1451{oldNode},𝓟1452{newValue}))
              {
                𝓟1447{oldNodes}.access(𝓟1455{i}) ⟵ 𝓟1457{valueAsNode}(𝓟1446{childType},𝓟1445{parent},𝓛8743{String}.PlusToken(𝓟1449{newPaths}.access(𝓟1455{i})),𝓟1452{newValue},𝓟1451{oldNode});
              }
              else
              {
                𝓟1454{oldMatch} ⟵ 𝓛12563{undefined};
                {
                  let 𝓟1456{j}: [miss]𝓛[ty]8655{Number} = 𝓟1455{i};
                  while (𝓟1456{j}.FirstBinaryOperator(𝓟1447{oldNodes}.length))
                  {
                    {
                      if (𝓟1467{areSame}(𝓟1447{oldNodes}.access(𝓟1456{j}),𝓟1452{newValue}))
                      {
                        𝓟1454{oldMatch} ⟵ 𝓟1447{oldNodes}.splice(𝓟1456{j},𝓛8745{Number}).access(𝓛8745{Number});
                      }
                    }
                    𝓛12546{POST_PlusPlusToken}(𝓟1456{j})
                  }
                }
                𝓟1447{oldNodes}.splice(𝓟1455{i},𝓛8745{Number},𝓟1457{valueAsNode}(𝓟1446{childType},𝓟1445{parent},𝓛8743{String}.PlusToken(𝓟1449{newPaths}.access(𝓟1455{i})),𝓟1452{newValue},𝓟1454{oldMatch}))
              }
            }
          }
        }
      }
      𝓛12546{POST_PlusPlusToken}(𝓟1455{i})
    }
  }
  return 𝓟1450 = 𝓟1447{oldNodes}
}
function 𝓟1457{valueAsNode} (𝓟1458{childType}: [OOV]𝓟[ty]6960{IType},𝓟1459{parent}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1460{subpath}: 𝓛[ty]10051{String},𝓟1461{newValue}: [OOV]any,𝓟1462{oldNode}: [OOV]𝓟[ty]6979{INode}): (𝓟1463: [OOV]𝓟[ty]6979{INode})
{
  𝓟1331{typecheck}(𝓟1458{childType},𝓟1461{newValue})
  if (𝓟673{isStateTreeNode}(𝓟1461{newValue}))
  {
    const 𝓟1464{childNode}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟1461{newValue});
    𝓟1464{childNode}.assertAlive()
    if (𝓟1464{childNode}.parent.ExclamationEqualsEqualsToken(𝓛12563{undefined}).AmpersandAmpersandToken(𝓟1464{childNode}.parent.EqualsEqualsEqualsToken(𝓟1459{parent})))
    {
      𝓟1464{childNode}.setParent(𝓟1459{parent},𝓟1460{subpath})
      if (𝓟1462{oldNode}.AmpersandAmpersandToken(𝓟1462{oldNode}.ExclamationEqualsEqualsToken(𝓟1464{childNode})))
      {
        𝓟1462{oldNode}.die()
      }
      return 𝓟1463 = 𝓟1464{childNode}
    }
  }
  if (𝓟1462{oldNode})
  {
    const 𝓟1465{childNode}: [OOV]𝓟[ty]6979{INode} = 𝓟1458{childType}.reconcile(𝓟1462{oldNode},𝓟1461{newValue});
    𝓟1465{childNode}.setParent(𝓟1459{parent},𝓟1460{subpath})
    return 𝓟1463 = 𝓟1465{childNode}
  }
  const 𝓟1466{childNode}: [OOV]𝓟[ty]6979{INode} = 𝓟1458{childType}.instantiate(𝓟1459{parent},𝓟1460{subpath},𝓟1459{parent}._environment,𝓟1461{newValue});
  return 𝓟1463 = 𝓟1466{childNode}
}
function 𝓟1467{areSame} (𝓟1468{oldNode}: [OOV]𝓟[ty]6979{INode},𝓟1469{newValue}: [OOV]any): (𝓟1470: [miss]𝓛[ty]8666{Boolean})
{
  if (𝓟673{isStateTreeNode}(𝓟1469{newValue}))
  {
    return 𝓟1470 = 𝓟676{getStateTreeNode}(𝓟1469{newValue}).EqualsEqualsEqualsToken(𝓟1468{oldNode})
  }
  if (𝓟449{isMutable}(𝓟1469{newValue}).AmpersandAmpersandToken(𝓟1468{oldNode}.snapshot.EqualsEqualsEqualsToken(𝓟1469{newValue})))
  {
    return 𝓟1470 = 𝓛8744{Boolean}
  }
  if (𝓟1468{oldNode}.InstanceOfKeyword(𝓛12563{undefined}).AmpersandAmpersandToken(𝓟1468{oldNode}.identifier.ExclamationEqualsEqualsToken(𝓛12563{undefined})).AmpersandAmpersandToken(𝓟1468{oldNode}.identifierAttribute).AmpersandAmpersandToken(𝓟445{isPlainObject}(𝓟1469{newValue})).AmpersandAmpersandToken(𝓟1469{newValue}.access(𝓟1468{oldNode}.identifierAttribute).EqualsEqualsEqualsToken(𝓟1468{oldNode}.identifier)))
  {
    return 𝓟1470 = 𝓛8744{Boolean}
  }
  return 𝓟1470 = 𝓛8744{Boolean}
}
function 𝓟1471{isArrayType} (𝓟1472{type}: [OOV]any): (𝓟1473: 𝓛[ty]8666{Boolean})
{
  return 𝓟1473 = 𝓟2822{isType}(𝓟1472{type}).AmpersandAmpersandToken(𝓟1472{type}.flags.AmpersandToken(𝓟2693{TypeFlags}.Array).GreaterThanToken(𝓛8745{Number}))
}

Module: packages/mobx-state-tree/src/types/complex-types/model

type 𝓟[ty]6964{ModelTypeConfig} = {name: 𝓛[ty]10051{String}, properties: {access: (𝓛[ty]10051{String})->𝓟[ty]6960{IType}}, initializers: 𝓛[ty]8697{ReadonlyArray}, preProcessor: (any)->any}
type 𝓛[ty]0{ANY} = any
type 𝓟[ty]6989{IModelType} extends 𝓟[ty]6970{IComplexType} = {preProcessSnapshot: (((any)->any))->𝓟[ty]6989{IModelType}, volatile: (((any)->any))->𝓟[ty]6989{IModelType}, extend: (((any)->{actions: any, views: any, state: any}))->𝓟[ty]6989{IModelType}, named: (𝓛[ty]10051{String})->𝓟[ty]6989{IModelType}, views: (((any)->any))->𝓟[ty]6989{IModelType}, actions: (((any)->any))->𝓟[ty]6989{IModelType}, props: (any)->𝓟[ty]6989{IModelType}}
type 𝓛[ty]0{ANY} = any
type 𝓛[ty]0{ANY} = any
const 𝓟1479{PRE_PROCESS_SNAPSHOT}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟1480{HOOK_NAMES}: [miss]𝓛[ty]8642{Object} = {afterAttach: 𝓛8743{String},beforeDetach: 𝓛8743{String},afterCreate: 𝓛8743{String},postProcessSnapshot: 𝓛8743{String},beforeDestroy: 𝓛8743{String}};
function 𝓟1481{objectTypeToString} (𝓟1482{this}: [OOV]any): (𝓟1483: [miss]𝓛[ty]10051{String})
{
  return 𝓟1483 = 𝓟676{getStateTreeNode}(𝓟1482{this}).toString()
}
const 𝓟1484{defaultObjectOptions}: [miss]𝓛[ty]8642{Object} = {name: 𝓛8743{String},properties: {},initializers: 𝓟374{EMPTY_ARRAY}};
function 𝓟1485{toPropertiesObject} (𝓟1486{properties}: [OOV]𝓛[ty]0{ANY}): (𝓟1487: [OOV]any)
{
  function 𝓟1488{$Lambda88} (𝓟1489{properties},𝓟1490{key}): (𝓟1491: [OOV]any)
  {
    if (𝓟1490{key}.InKeyword(𝓟1480{HOOK_NAMES}))
    {
      return 𝓟1491 = 𝓟376{fail}(𝓛12554{$Template}(𝓟1490{key}))
    }
    const 𝓟1492{descriptor}: [miss]𝓛[ty]8633{PropertyDescriptor} = 𝓛8741{Object}.getOwnPropertyDescriptor(𝓟1489{properties},𝓟1490{key});
    if (𝓛8743{String}.InKeyword(𝓟1492{descriptor}))
    {
      𝓟376{fail}(𝓛8743{String})
    }
    const 𝓟1493{value} = 𝓟1492{descriptor}.value;
    if (𝓟1493{value}.EqualsEqualsEqualsToken(𝓛12563{undefined}).BarBarToken(𝓛12563{undefined}))
    {
      𝓟376{fail}(𝓛8743{String})
    }
    else
    {
      if (𝓟452{isPrimitive}(𝓟1493{value}))
      {
        return 𝓟1491 = 𝓛8741{Object}.assign({},𝓟1489{properties},{[key]: 𝓟358{optional}(𝓟169{getPrimitiveFactoryFromValue}(𝓟1493{value}),𝓟1493{value})})
      }
      else
      {
        if (𝓟2822{isType}(𝓟1493{value}))
        {
          return 𝓟1491 = 𝓟1489{properties}
        }
        else
        {
          if (𝓛12550{$TypeOf}(𝓟1493{value}).EqualsEqualsEqualsToken(𝓛8743{String}))
          {
            𝓟376{fail}(𝓛8743{String})
          }
          else
          {
            if (𝓛12550{$TypeOf}(𝓟1493{value}).EqualsEqualsEqualsToken(𝓛8743{String}))
            {
              𝓟376{fail}(𝓛12554{$Template}(𝓟1490{key},𝓟1493{value}))
            }
            else
            {
              𝓟376{fail}(𝓛12554{$Template}(𝓟1490{key}))
            }
          }
        }
      }
    }
  }
  return 𝓟1487 = 𝓛8741{Object}.keys(𝓟1486{properties}).reduce(𝓟1488{$Lambda88},𝓟1486{properties} as any)
}
function 𝓟1494{CONSTRUCTOR} (𝓟1495{opts}: [OOV]𝓟[ty]6964{ModelTypeConfig}): (𝓟[ty]1524{ModelType})
{
  const 𝓟[ty]1524{ModelType};
  const 𝓟[ty]1524{ModelType};
  function 𝓟1499{$Lambda98} (): (𝓟1500: [miss]𝓛[ty]8642{Object})
  {
    const 𝓟1501{instance} = 𝓟2830{observable}.shallowObject(𝓟375{EMPTY_OBJECT});
    𝓟467{addHiddenFinalProp}(𝓟1501{instance},𝓛8743{String},𝓟1481{objectTypeToString})
    return 𝓟1500 = 𝓟1501{instance} as 𝓛[ty]8642{Object}
  }
  function 𝓟1502{$Lambda99} (𝓟1503{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1504{snapshot}: [OOV]any): (𝓟1505: [miss]𝓛[ty]10033{Void})
  {
    const 𝓟1506{instance}: [OOV]𝓟[ty]6977{IStateTreeNode} = 𝓟1503{node}.storedValue as 𝓟[ty]6977{IStateTreeNode};
    function 𝓟1507{$Lambda100} (𝓟1508{name},𝓟1509{type}): (𝓟1510: [miss]𝓛[ty]10033{Void})
    {
      𝓟2841{extendShallowObservable}(𝓟1506{instance},{[name]: 𝓟2830{observable}.ref(𝓟1509{type}.instantiate(𝓟1503{node},𝓟1508{name},𝓟1503{node}._environment,𝓟1504{snapshot}.access(𝓟1508{name})))})
      𝓟2836{extras}.interceptReads(𝓟1506{instance},𝓟1508{name},𝓟1503{node}.unbox)
    }
    𝓟[ty]1524{ModelType}.forAllProps(𝓟1507{$Lambda100})
    function 𝓟1511{$Lambda101} (𝓟1512{self},𝓟1513{fn}): (𝓟1514: [OOV]any)
    {
      return 𝓟1514 = 𝓟1513{fn}(𝓟1512{self})
    }
    𝓟[ty]1524{ModelType}.initializers.reduce(𝓟1511{$Lambda101},𝓟1506{instance})
    function 𝓟1515{$Lambda102} (𝓟1516{change}): (𝓟1517: [OOV]any)
    {
      return 𝓟1517 = 𝓟[ty]1524{ModelType}.willChange(𝓟1516{change})
    }
    𝓟2834{intercept}(𝓟1506{instance},𝓟1515{$Lambda102})
    𝓟2835{observe}(𝓟1506{instance},𝓟[ty]1524{ModelType}.didChange)
  }
  function 𝓟1518{$Lambda103} (𝓟1519{change}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟1520: [miss]𝓛[ty]10033{Void})
  {
    if (𝓛12548{ExclamationToken}(𝓟[ty]1524{ModelType}.properties.access(𝓟1519{change}.name)))
    {
    }
    const 𝓟1521{node}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟1519{change}.object);
    const 𝓟1522{oldValue} = (𝓟1519{change}.oldValue ? 𝓟1519{change}.oldValue.snapshot : 𝓛12563{undefined};
    𝓟1521{node}.emitPatch({op: 𝓛8743{String},path: 𝓟2675{escapeJsonPath}(𝓟1519{change}.name),value: 𝓟1519{change}.newValue.snapshot,oldValue: 𝓟1522{oldValue}},𝓟1521{node})
  }
  𝓟[ty]1524{ModelType}.shouldAttachNode ⟵ 𝓛8744{Boolean};
  𝓟[ty]1524{ModelType}.finalizeNewInstance ⟵ 𝓟1502{$Lambda99};
  𝓟[ty]1524{ModelType}.createNewInstance ⟵ 𝓟1499{$Lambda98};
  𝓟[ty]1524{ModelType}.didChange ⟵ 𝓟1518{$Lambda103};
  𝓟[ty]1524{ModelType}.flags ⟵ 𝓟2693{TypeFlags}.Object;
  𝓟[ty]1524{ModelType}(𝓟1495{opts}.name.BarBarToken(𝓟1484{defaultObjectOptions}.name))
  const 𝓟1523{name}: [miss]𝓛[ty]10051{String} = 𝓟1495{opts}.name.BarBarToken(𝓟1484{defaultObjectOptions}.name);
  if (𝓛12548{ExclamationToken}(𝓛8748{RegExp}.test(𝓟1523{name})))
  {
    𝓟376{fail}(𝓛12554{$Template}(𝓟1523{name}))
  }
  𝓛8741{Object}.assign(𝓟[ty]1524{ModelType},𝓟1484{defaultObjectOptions},𝓟1495{opts})
  𝓟[ty]1524{ModelType}.properties ⟵ 𝓟1485{toPropertiesObject}(𝓟[ty]1524{ModelType}.properties);
  𝓟[ty]1524{ModelType}.propertiesNames ⟵ 𝓛8741{Object}.keys(𝓟[ty]1524{ModelType}.properties);
  𝓛8741{Object}.freeze(𝓟[ty]1524{ModelType}.properties)
}
class 𝓟[ty]1524{ModelType} extends 𝓟[ty]2699{ComplexType} with 𝓟[ty]6989{IModelType}{
  𝓟1526{didChange}: [miss]𝓛[ty]8696{Function};
  𝓟1527{flags}: [miss]𝓛[ty]8655{Number};
  𝓟1528{createNewInstance}: [miss]𝓛[ty]8696{Function};
  𝓟1529{preProcessor}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function});
  𝓟1530{initializers}: 𝓛[ty]8670{Array};
  𝓟1531{finalizeNewInstance}: [miss]𝓛[ty]8696{Function};
  𝓟1532{propertiesNames}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8670{Array});
  𝓟1533{properties}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8642{Object});
  𝓟1534{shouldAttachNode}: [miss]𝓛[ty]8666{Boolean};
  function 𝓟1606{preProcessSnapshot} (𝓟1607{preProcessor}: 𝓛[ty]8696{Function}): (𝓟1608: [OOV]𝓟[ty]6989{IModelType})
  {
    const 𝓟1609{currentPreprocessor}: [miss]𝓛[ty]8696{Function} = 𝓟[ty]1524{ModelType}.preProcessor;
    if (𝓛12548{ExclamationToken}(𝓟1609{currentPreprocessor}))
    {
      return 𝓟1608 = 𝓟[ty]1524{ModelType}.cloneAndEnhance({preProcessor: 𝓟1607{preProcessor}})
    }
    else
    {
      function 𝓟1610{$Lambda97} (𝓟1611{snapshot}): (𝓟1612: [OOV]any)
      {
        return 𝓟1612 = 𝓟1609{currentPreprocessor}(𝓟1607{preProcessor}(𝓟1611{snapshot}))
      }
      return 𝓟1608 = 𝓟[ty]1524{ModelType}.cloneAndEnhance({preProcessor: 𝓟1610{$Lambda97}})
    }
  }
  function 𝓟1535{cloneAndEnhance} (𝓟1536{opts}: [OOV]𝓟[ty]6964{ModelTypeConfig}): (𝓟1537: [OOV]𝓟[ty]1524{ModelType})
  {
    return 𝓟1537 = 𝓟1494{CONSTRUCTOR}({name: 𝓟1536{opts}.name.BarBarToken(𝓟[ty]1524{ModelType}.name),properties: 𝓛8741{Object}.assign({},𝓟[ty]1524{ModelType}.properties,𝓟1536{opts}.properties),initializers: 𝓟[ty]1524{ModelType}.initializers.concat(𝓟1536{opts}.initializers as any.BarBarToken(𝓛8757{Array}())),preProcessor: 𝓟1536{opts}.preProcessor.BarBarToken(𝓟[ty]1524{ModelType}.preProcessor)})
  }
  function 𝓟1566{volatile} (𝓟1567{fn}: 𝓛[ty]8696{Function}): (𝓟1568: [OOV]𝓟[ty]6989{IModelType})
  {
    function 𝓟1569{$Lambda93} (𝓟1570{self}: [OOV]any): (𝓟1571: [OOV]any)
    {
      𝓟[ty]1524{ModelType}.instantiateVolatileState(𝓟1570{self},𝓟1567{fn}(𝓟1570{self}))
      return 𝓟1571 = 𝓟1570{self}
    }
    const 𝓟1572{stateInitializer}: [miss]𝓛[ty]8696{Function} = 𝓟1569{$Lambda93};
    return 𝓟1568 = 𝓟[ty]1524{ModelType}.cloneAndEnhance({initializers: 𝓛8757{Array}(𝓟1572{stateInitializer})})
  }
  function 𝓟1653{applySnapshot} (𝓟1654{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1655{snapshot}: [OOV]any): (𝓟1656: 𝓛[ty]10033{Void})
  {
    const 𝓟1657{s} = 𝓟[ty]1524{ModelType}.applySnapshotPreProcessor(𝓟1655{snapshot});
    𝓟1331{typecheck}(𝓟[ty]1524{ModelType},𝓟1657{s})
    function 𝓟1658{$Lambda106} (𝓟1659{name},𝓟1660{type}): (𝓟1661: [miss]𝓛[ty]10033{Void})
    {
      𝓟1654{node}.storedValue.access(𝓟1659{name}) ⟵ 𝓟1657{s}.access(𝓟1659{name});
    }
    𝓟[ty]1524{ModelType}.forAllProps(𝓟1658{$Lambda106})
  }
  function 𝓟1573{instantiateVolatileState} (𝓟1574{self}: [OOV]any,𝓟1575{state}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8642{Object})): (𝓟1576: [miss]𝓛[ty]10033{Void})
  {
    if (𝓛12548{ExclamationToken}(𝓟445{isPlainObject}(𝓟1575{state})))
    {
      𝓟376{fail}(𝓛8743{String})
    }
    𝓟2841{extendShallowObservable}(𝓟1574{self},𝓟1575{state})
  }
  function 𝓟1640{getSnapshot} (𝓟1641{node}: [OOV]𝓟[ty]2343{ObjectNode}): (𝓟1642: [OOV]any)
  {
    const 𝓟1643{res} = {} as any;
    function 𝓟1644{$Lambda105} (𝓟1645{name},𝓟1646{type}): (𝓟1647: [miss]𝓛[ty]10033{Void})
    {
      𝓟2836{extras}.getAtom(𝓟1641{node}.storedValue,𝓟1645{name}) as any.reportObserved()
      𝓟1643{res}.access(𝓟1645{name}) ⟵ 𝓟[ty]1524{ModelType}.getChildNode(𝓟1641{node},𝓟1645{name}).snapshot;
    }
    𝓟[ty]1524{ModelType}.forAllProps(𝓟1644{$Lambda105})
    if (𝓛12550{$TypeOf}(𝓟1641{node}.storedValue.postProcessSnapshot).EqualsEqualsEqualsToken(𝓛8743{String}))
    {
      return 𝓟1642 = 𝓟1641{node}.storedValue.postProcessSnapshot.call(𝓛12563{undefined},𝓟1643{res})
    }
    return 𝓟1642 = 𝓟1643{res}
  }
  function 𝓟1662{applySnapshotPreProcessor} (𝓟1663{snapshot}: [OOV]any): (𝓟1664: [OOV]any)
  {
    if (𝓟[ty]1524{ModelType}.preProcessor)
    {
      return 𝓟1664 = 𝓟[ty]1524{ModelType}.preProcessor.call(𝓛12563{undefined},𝓟1663{snapshot})
    }
    return 𝓟1664 = 𝓟1663{snapshot}
  }
  function 𝓟1682{describe} (): (𝓟1683: [miss]𝓛[ty]10051{String})
  {
    function 𝓟1684{$Lambda109} (𝓟1685{key}): (𝓟1686: [miss]𝓛[ty]10051{String})
    {
      return 𝓟1686 = 𝓟1685{key}.PlusToken(𝓛8743{String}).PlusToken(𝓟[ty]1524{ModelType}.properties.access(𝓟1685{key}).describe())
    }
    return 𝓟1683 = 𝓛8743{String}.PlusToken(𝓟[ty]1524{ModelType}.propertiesNames.map(𝓟1684{$Lambda109}).join(𝓛8743{String})).PlusToken(𝓛8743{String})
  }
  function 𝓟1596{instantiateViews} (𝓟1597{self}: [OOV]any,𝓟1598{views}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8642{Object})): (𝓟1599: [miss]𝓛[ty]10033{Void})
  {
    if (𝓛12548{ExclamationToken}(𝓟445{isPlainObject}(𝓟1598{views})))
    {
      𝓟376{fail}(𝓛8743{String})
    }
    function 𝓟1600{$Lambda96} (𝓟1601{key}): (𝓟1602: [miss]𝓛[ty]10033{Void})
    {
      const 𝓟1603{descriptor}: [miss]𝓛[ty]8633{PropertyDescriptor} = 𝓛8741{Object}.getOwnPropertyDescriptor(𝓟1598{views},𝓟1601{key});
      const 𝓟1604{value} = 𝓟1603{descriptor}.value;
      if (𝓛8743{String}.InKeyword(𝓟1603{descriptor}))
      {
        if (𝓟2845{isComputed}(𝓟1597{self} as any.$mobx.values.access(𝓟1601{key})))
        {
          𝓟1597{self} as any.$mobx.values.access(𝓟1601{key}) ⟵ 𝓟2844{computed}(𝓟1603{descriptor}.get,{name: 𝓟1601{key},setter: 𝓟1603{descriptor}.set,context: 𝓟1597{self}});
        }
        else
        {
          const 𝓟1605{tmp}: [miss]𝓛[ty]8642{Object} = {};
          𝓛8741{Object}.defineProperty(𝓟1605{tmp},𝓟1601{key},{get: 𝓟1603{descriptor}.get,set: 𝓟1603{descriptor}.set,enumerable: 𝓛8744{Boolean}})
          𝓟2841{extendShallowObservable}(𝓟1597{self},𝓟1605{tmp})
        }
      }
      else
      {
        if (𝓛12550{$TypeOf}(𝓟1604{value}).EqualsEqualsEqualsToken(𝓛8743{String}))
        {
          𝓟467{addHiddenFinalProp}(𝓟1597{self},𝓟1601{key},𝓟1604{value})
        }
        else
        {
          𝓟376{fail}(𝓛8743{String})
        }
      }
    }
    𝓛8741{Object}.keys(𝓟1598{views}).forEach(𝓟1600{$Lambda96})
  }
  function 𝓟1577{extend} (𝓟1578{fn}: 𝓛[ty]8696{Function}): (𝓟1579: [OOV]𝓟[ty]6989{IModelType})
  {
    function 𝓟1580{$Lambda94} (𝓟1581{self}: [OOV]any): (𝓟1582: [OOV]any)
    {
      const 𝓟1583{actions}: [OOV]any = 𝓟1578{fn}(𝓟1581{self}).actions;
      const 𝓟1584{views}: [OOV]any = 𝓟1578{fn}(𝓟1581{self}).views;
      const 𝓟1585{state}: [OOV]any = 𝓟1578{fn}(𝓟1581{self}).state;
      const 𝓟1586{rest}: [miss]𝓛[ty]8642{Object} = 𝓟1578{fn}(𝓟1581{self}).rest;
      {
        let 𝓟1587{key}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓟1586{rest});
        while (𝓛8744{Boolean})
        {
          𝓟376{fail}(𝓛12554{$Template}(𝓟1587{key}))
        }
      }
      if (𝓟1585{state})
      {
        𝓟[ty]1524{ModelType}.instantiateVolatileState(𝓟1581{self},𝓟1585{state})
      }
      if (𝓟1584{views})
      {
        𝓟[ty]1524{ModelType}.instantiateViews(𝓟1581{self},𝓟1584{views})
      }
      if (𝓟1583{actions})
      {
        𝓟[ty]1524{ModelType}.instantiateActions(𝓟1581{self},𝓟1583{actions})
      }
      return 𝓟1582 = 𝓟1581{self}
    }
    const 𝓟1588{initializer}: [miss]𝓛[ty]8696{Function} = 𝓟1580{$Lambda94};
    return 𝓟1579 = 𝓟[ty]1524{ModelType}.cloneAndEnhance({initializers: 𝓛8757{Array}(𝓟1588{initializer})})
  }
  function 𝓟1545{instantiateActions} (𝓟1546{self}: [OOV]any,𝓟1547{actions}: 𝓛[ty]8642{Object}): (𝓟1548: [miss]𝓛[ty]10033{Void})
  {
    if (𝓛12548{ExclamationToken}(𝓟445{isPlainObject}(𝓟1547{actions})))
    {
      𝓟376{fail}(𝓛8743{String})
    }
    function 𝓟1549{$Lambda90} (𝓟1550{name}): (𝓟1551: [OOV]any)
    {
      if (𝓟1550{name}.EqualsEqualsEqualsToken(𝓟1479{PRE_PROCESS_SNAPSHOT}))
      {
        return 𝓟1551 = 𝓟376{fail}(𝓛12554{$Template}(𝓟1479{PRE_PROCESS_SNAPSHOT}))
      }
      let 𝓟1552{action}: [miss]𝓛[ty]8696{Function} = 𝓟1547{actions}.access(𝓟1550{name});
      let 𝓟1553{baseAction} = 𝓟1546{self} as any.access(𝓟1550{name});
      if (𝓟1550{name}.InKeyword(𝓟1480{HOOK_NAMES}).AmpersandAmpersandToken(𝓟1553{baseAction}))
      {
        let 𝓟1554{specializedAction}: [miss]𝓛[ty]8696{Function} = 𝓟1552{action};
        if (𝓟1550{name}.EqualsEqualsEqualsToken(𝓟1480{HOOK_NAMES}.postProcessSnapshot))
        {
          function 𝓟1555{$Lambda91} (𝓟1556{snapshot}: [OOV]any): (𝓟1557: [OOV]any)
          {
            return 𝓟1557 = 𝓟1554{specializedAction}(𝓟1553{baseAction}(𝓟1556{snapshot}))
          }
          𝓟1552{action} ⟵ 𝓟1555{$Lambda91};
        }
        else
        {
          function 𝓟1558{$Lambda92} (): (𝓟1559: [miss]𝓛[ty]10033{Void})
          {
            𝓟1553{baseAction}.apply(𝓛12563{undefined},𝓛10035{arguments})
            𝓟1554{specializedAction}.apply(𝓛12563{undefined},𝓛10035{arguments})
          }
          𝓟1552{action} ⟵ 𝓟1558{$Lambda92};
        }
      }
      𝓟467{addHiddenFinalProp}(𝓟1546{self},𝓟1550{name},𝓟191{createActionInvoker}(𝓟1546{self},𝓟1550{name},𝓟1552{action}))
    }
    𝓛8741{Object}.keys(𝓟1547{actions}).forEach(𝓟1549{$Lambda90})
  }
  function 𝓟1560{named} (𝓟1561{name}: 𝓛[ty]10051{String}): (𝓟1562: [OOV]𝓟[ty]6989{IModelType})
  {
    return 𝓟1562 = 𝓟[ty]1524{ModelType}.cloneAndEnhance({name: 𝓟1561{name}})
  }
  function 𝓟1613{instantiate} (𝓟1614{parent}: [OOV]any,𝓟1615{subpath}: 𝓛[ty]10051{String},𝓟1616{environment}: [OOV]any,𝓟1617{snapshot}: [OOV]any): (𝓟1618: [OOV]𝓟[ty]6979{INode})
  {
    return 𝓟1618 = 𝓟2551{createNode}(𝓟[ty]1524{ModelType},𝓟1614{parent},𝓟1615{subpath},𝓟1616{environment},𝓟[ty]1524{ModelType}.applySnapshotPreProcessor(𝓟1617{snapshot}),𝓟[ty]1524{ModelType}.createNewInstance,𝓟[ty]1524{ModelType}.finalizeNewInstance)
  }
  function 𝓟1632{getChildNode} (𝓟1633{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1634{key}: 𝓛[ty]10051{String}): (𝓟1635: [OOV]𝓟[ty]6979{INode})
  {
    if (𝓛12548{ExclamationToken}(𝓟1634{key}.InKeyword(𝓟[ty]1524{ModelType}.properties)))
    {
      return 𝓟1635 = 𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟1634{key}))
    }
    const 𝓟1636{childNode} = 𝓟1633{node}.storedValue.$mobx.values.access(𝓟1634{key}).value;
    if (𝓛12548{ExclamationToken}(𝓟1636{childNode}))
    {
      return 𝓟1635 = 𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟1634{key}))
    }
    return 𝓟1635 = 𝓟1636{childNode}
  }
  function 𝓟1665{getChildType} (𝓟1666{key}: 𝓛[ty]10051{String}): (𝓟1667: [OOV]𝓟[ty]6960{IType})
  {
    return 𝓟1667 = 𝓟[ty]1524{ModelType}.properties.access(𝓟1666{key})
  }
  function 𝓟1668{isValidSnapshot} (𝓟1669{value}: [OOV]any,𝓟1670{context}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1671: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
  {
    let 𝓟1672{snapshot} = 𝓟[ty]1524{ModelType}.applySnapshotPreProcessor(𝓟1669{value});
    if (𝓛12548{ExclamationToken}(𝓟445{isPlainObject}(𝓟1672{snapshot})))
    {
      return 𝓟1671 = 𝓟1319{typeCheckFailure}(𝓟1670{context},𝓟1672{snapshot},𝓛8743{String})
    }
    function 𝓟1673{$Lambda107} (𝓟1674{key}): (𝓟1675: [miss]𝓛[ty]8670{Array})
    {
      return 𝓟1675 = 𝓟[ty]1524{ModelType}.properties.access(𝓟1674{key}).validate(𝓟1672{snapshot}.access(𝓟1674{key}),𝓟1312{getContextForPath}(𝓟1670{context},𝓟1674{key},𝓟[ty]1524{ModelType}.properties.access(𝓟1674{key})))
    }
    return 𝓟1671 = 𝓟1324{flattenTypeErrors}(𝓟[ty]1524{ModelType}.propertiesNames.map(𝓟1673{$Lambda107}))
  }
  function 𝓟1624{getChildren} (𝓟1625{node}: [OOV]𝓟[ty]2343{ObjectNode}): (𝓟1626: 𝓛[ty]8670{Array})
  {
    const 𝓟1627{res}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
    function 𝓟1628{$Lambda104} (𝓟1629{name},𝓟1630{type}): (𝓟1631: [miss]𝓛[ty]10033{Void})
    {
      𝓟1627{res}.push(𝓟[ty]1524{ModelType}.getChildNode(𝓟1625{node},𝓟1629{name}))
    }
    𝓟[ty]1524{ModelType}.forAllProps(𝓟1628{$Lambda104})
    return 𝓟1626 = 𝓟1627{res}
  }
  function 𝓟1589{views} (𝓟1590{fn}: 𝓛[ty]8696{Function}): (𝓟1591: [OOV]𝓟[ty]6989{IModelType})
  {
    function 𝓟1592{$Lambda95} (𝓟1593{self}: [OOV]any): (𝓟1594: [OOV]any)
    {
      𝓟[ty]1524{ModelType}.instantiateViews(𝓟1593{self},𝓟1590{fn}(𝓟1593{self}))
      return 𝓟1594 = 𝓟1593{self}
    }
    const 𝓟1595{viewInitializer}: [miss]𝓛[ty]8696{Function} = 𝓟1592{$Lambda95};
    return 𝓟1591 = 𝓟[ty]1524{ModelType}.cloneAndEnhance({initializers: 𝓛8757{Array}(𝓟1595{viewInitializer})})
  }
  function 𝓟1538{actions} (𝓟1539{fn}: 𝓛[ty]8696{Function}): (𝓟1540: [OOV]𝓟[ty]6989{IModelType})
  {
    function 𝓟1541{$Lambda89} (𝓟1542{self}: [OOV]any): (𝓟1543: [OOV]any)
    {
      𝓟[ty]1524{ModelType}.instantiateActions(𝓟1542{self},𝓟1539{fn}(𝓟1542{self}))
      return 𝓟1543 = 𝓟1542{self}
    }
    const 𝓟1544{actionInitializer}: [miss]𝓛[ty]8696{Function} = 𝓟1541{$Lambda89};
    return 𝓟1540 = 𝓟[ty]1524{ModelType}.cloneAndEnhance({initializers: 𝓛8757{Array}(𝓟1544{actionInitializer})})
  }
  function 𝓟1648{applyPatchLocally} (𝓟1649{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1650{subpath}: 𝓛[ty]10051{String},𝓟1651{patch}: [OOV]𝓟[ty]6980{IJsonPatch}): (𝓟1652: 𝓛[ty]10033{Void})
  {
    if (𝓛12548{ExclamationToken}(𝓟1651{patch}.op.EqualsEqualsEqualsToken(𝓛8743{String}).BarBarToken(𝓟1651{patch}.op.EqualsEqualsEqualsToken(𝓛8743{String}))))
    {
      𝓟376{fail}(𝓛12554{$Template}(𝓟1651{patch}.op))
    }
    𝓟1649{node}.storedValue.access(𝓟1650{subpath}) ⟵ 𝓟1651{patch}.value;
  }
  function 𝓟1689{removeChild} (𝓟1690{node}: [OOV]𝓟[ty]2343{ObjectNode},𝓟1691{subpath}: 𝓛[ty]10051{String}): (𝓟1692: [miss]𝓛[ty]10033{Void})
  {
    𝓟1690{node}.storedValue.access(𝓟1691{subpath}) ⟵ 𝓛12563{undefined};
  }
  function 𝓟1637{getValue} (𝓟1638{node}: [OOV]𝓟[ty]2343{ObjectNode}): (𝓟1639: [OOV]any)
  {
    return 𝓟1639 = 𝓟1638{node}.storedValue
  }
  function 𝓟1563{props} (𝓟1564{properties}: [OOV]any): (𝓟1565: [OOV]𝓟[ty]6989{IModelType})
  {
    return 𝓟1565 = 𝓟[ty]1524{ModelType}.cloneAndEnhance({properties: 𝓟1564{properties}} as any)
  }
  function 𝓟1619{willChange} (𝓟1620{change}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟1621: [OOV]any)
  {
    const 𝓟1622{node}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟1620{change}.object);
    𝓟1622{node}.assertWritable()
    const 𝓟1623{type}: [OOV]𝓟[ty]6960{IType} = 𝓟[ty]1524{ModelType}.properties.access(𝓟1620{change}.name);
    if (𝓟1623{type})
    {
      𝓟1331{typecheck}(𝓟1623{type},𝓟1620{change}.newValue)
      𝓟1620{change}.newValue ⟵ 𝓟1623{type}.reconcile(𝓟1622{node}.getChildNode(𝓟1620{change}.name),𝓟1620{change}.newValue);
    }
    return 𝓟1621 = 𝓟1620{change}
  }
  function 𝓟1676{forAllProps} (𝓟1677{fn}: 𝓛[ty]8696{Function}): (𝓟1678: [miss]𝓛[ty]10033{Void})
  {
    function 𝓟1679{$Lambda108} (𝓟1680{key}): (𝓟1681: [miss]𝓛[ty]10033{Void})
    {
      return 𝓟1681 = 𝓟1677{fn}(𝓟1680{key},𝓟[ty]1524{ModelType}.properties.access(𝓟1680{key}))
    }
    𝓟[ty]1524{ModelType}.propertiesNames.forEach(𝓟1679{$Lambda108})
  }
  function 𝓟1687{getDefaultSnapshot} (): (𝓟1688: [OOV]any)
  {
    return 𝓟1688 = {}
  }
}
function 𝓟1693{model} (𝓟1694{name}: 𝓛[ty]10051{String},𝓟1695{properties}: [OOV]𝓛[ty]0{ANY}): (𝓟1696: [OOV]𝓟[ty]6989{IModelType})
{
}
function 𝓟1697{model} (𝓟1698{properties}: [OOV]𝓛[ty]0{ANY}): (𝓟1699: [OOV]𝓟[ty]6989{IModelType})
{
}
function 𝓟1700{model} (𝓟1701{args}: 𝓛[ty]8670{Array}): (𝓟1702)
{
  const 𝓟1703{name} = (𝓛12550{$TypeOf}(𝓟1701{args}.access(𝓛8745{Number})).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟1701{args}.shift() : 𝓛8743{String};
  const 𝓟1704{properties} = 𝓟1701{args}.shift().BarBarToken({});
  return 𝓟1702 = 𝓟1494{CONSTRUCTOR}({name: 𝓟1703{name},properties: 𝓟1704{properties}})
}
function 𝓟1705{compose} (𝓟1706{t1}: [OOV]𝓟[ty]6989{IModelType},𝓟1707{t2}: [OOV]𝓟[ty]6989{IModelType},𝓟1708{t3}: [OOV]𝓟[ty]6989{IModelType}): (𝓟1709: [OOV]𝓟[ty]6989{IModelType})
{
}
function 𝓟1710{compose} (𝓟1711{name}: 𝓛[ty]10051{String},𝓟1712{t1}: [OOV]𝓟[ty]6989{IModelType},𝓟1713{t2}: [OOV]𝓟[ty]6989{IModelType},𝓟1714{t3}: [OOV]𝓟[ty]6989{IModelType}): (𝓟1715: [OOV]𝓟[ty]6989{IModelType})
{
}
function 𝓟1716{compose} (𝓟1717{args}: 𝓛[ty]8670{Array}): (𝓟1718: [OOV]𝓟[ty]6989{IModelType})
{
  const 𝓟1719{typeName}: 𝓛[ty]10051{String} = (𝓛12550{$TypeOf}(𝓟1717{args}.access(𝓛8745{Number})).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟1717{args}.shift() : 𝓛8743{String};
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    function 𝓟1720{$Lambda110} (𝓟1721{type}): (𝓟1722: [miss]𝓛[ty]10033{Void})
    {
      if (𝓛12548{ExclamationToken}(𝓟2822{isType}(𝓟1721{type})))
      {
        𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟1721{type}).PlusToken(𝓛8743{String}))
      }
    }
    𝓟1717{args}.forEach(𝓟1720{$Lambda110})
  }
  function 𝓟1723{$Lambda111} (𝓟1724{prev},𝓟1725{cur}): (𝓟1726: [OOV]𝓟[ty]1524{ModelType})
  {
    return 𝓟1726 = 𝓟1724{prev}.cloneAndEnhance({name: 𝓟1724{prev}.name.PlusToken(𝓛8743{String}).PlusToken(𝓟1725{cur}.name),properties: 𝓟1725{cur}.properties,initializers: 𝓟1725{cur}.initializers})
  }
  return 𝓟1718 = 𝓟1717{args} as 𝓛[ty]8670{Array}.reduce(𝓟1723{$Lambda111}).named(𝓟1719{typeName})
}
function 𝓟1727{isObjectType} (𝓟1728{type}: [OOV]any): (𝓟1729: 𝓛[ty]8666{Boolean})
{
  return 𝓟1729 = 𝓟2822{isType}(𝓟1728{type}).AmpersandAmpersandToken(𝓟1728{type}.flags.AmpersandToken(𝓟2693{TypeFlags}.Object).GreaterThanToken(𝓛8745{Number}))
}

Module: packages/mobx-state-tree/src/core/flow

function 𝓟1730{flow} (𝓟1731{generator}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟1732: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8696{Function}))
{
}
function 𝓟1733{flow} (𝓟1734{generator}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟1735: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8696{Function}))
{
}
function 𝓟1736{flow} (𝓟1737{generator}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟1738: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8696{Function}))
{
}
function 𝓟1739{flow} (𝓟1740{generator}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟1741: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8696{Function}))
{
}
function 𝓟1742{flow} (𝓟1743{generator}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟1744: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8696{Function}))
{
}
function 𝓟1745{flow} (𝓟1746{generator}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟1747: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8696{Function}))
{
}
function 𝓟1748{flow} (𝓟1749{generator}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟1750: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8696{Function}))
{
}
function 𝓟1751{flow} (𝓟1752{generator}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟1753: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8696{Function}))
{
}
function 𝓟1754{flow} (𝓟1755{generator}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟1756: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8696{Function}))
{
}
function 𝓟1757{flow} (𝓟1758{asyncAction}: [OOV]any): (𝓟1759: [OOV]any)
{
  return 𝓟1759 = 𝓟1760{createFlowSpawner}(𝓟1758{asyncAction}.name,𝓟1758{asyncAction})
}
function 𝓟1760{createFlowSpawner} (𝓟1761{name}: 𝓛[ty]10051{String},𝓟1762{generator}: 𝓛[ty]8696{Function}): (𝓟1763: [miss]𝓛[ty]8696{Function})
{
  function 𝓟1764{flowSpawner} (𝓟1765{this}: [OOV]any): (𝓟1766: [miss]𝓛[ty]8654{Promise})
  {
    const 𝓟1767{runId}: [miss]𝓛[ty]8655{Number} = 𝓟180{getNextActionId}();
    const 𝓟1768{baseContext}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟189{getActionContext}();
    const 𝓟1769{args}: [miss]𝓛[ty]8638{IArguments} = 𝓛10035{arguments};
    function 𝓟1770{wrap} (𝓟1771{fn}: [OOV]any,𝓟1772{type}: [OOV]𝓛[ty]0{ANY},𝓟1773{arg}: [OOV]any): (𝓟1774: [miss]𝓛[ty]10033{Void})
    {
      𝓟1771{fn}.$mst_middleware ⟵ 𝓟1805{spawner} as any.$mst_middleware;
      𝓟182{runWithActionContext}({name: 𝓟1761{name},context: 𝓟1768{baseContext}.context,id: 𝓟1767{runId},rootId: 𝓟1768{baseContext}.rootId,tree: 𝓟1768{baseContext}.tree,args: 𝓛8757{Array}(𝓟1773{arg}),type: 𝓟1772{type},parentId: 𝓟1768{baseContext}.id},𝓟1771{fn})
    }
    function 𝓟1775{$Lambda33} (𝓟1776{resolve},𝓟1777{reject}): (𝓟1778: [miss]𝓛[ty]10033{Void})
    {
      let 𝓟1779{gen}: [OOV]any;
      function 𝓟1780{asyncActionInit} (): (𝓟1781: [miss]𝓛[ty]10033{Void})
      {
        𝓟1779{gen} ⟵ 𝓟1762{generator}.apply(𝓛12563{undefined},𝓛10035{arguments});
        𝓟1783{onFulfilled}(𝓛12563{undefined})
      }
      const 𝓟1782{init}: [miss]𝓛[ty]8696{Function} = 𝓟1780{asyncActionInit};
      𝓟1782{init} as any.$mst_middleware ⟵ 𝓟1805{spawner} as any.$mst_middleware;
      𝓟182{runWithActionContext}({name: 𝓟1761{name},context: 𝓟1768{baseContext}.context,id: 𝓟1767{runId},rootId: 𝓟1768{baseContext}.rootId,tree: 𝓟1768{baseContext}.tree,args: 𝓟498{argsToArray}(𝓟1769{args}),type: 𝓛8743{String},parentId: 𝓟1768{baseContext}.id},𝓟1782{init})
      function 𝓟1783{onFulfilled} (𝓟1784{res}: [OOV]any): (𝓟1785: [miss]𝓛[ty]10033{Void})
      {
        let 𝓟1786{ret};
        {
          function 𝓟1787{$Lambda34} (𝓟1788{r}: [OOV]any): (𝓟1789: [miss]𝓛[ty]10033{Void})
          {
            𝓟1786{ret} ⟵ 𝓟1779{gen}.next(𝓟1788{r});
          }
          𝓟1770{wrap}(𝓟1787{$Lambda34},𝓛8743{String},𝓟1784{res})
        }
        𝓟1797{next}(𝓟1786{ret})
      }
      function 𝓟1790{onRejected} (𝓟1791{err}: [OOV]any): (𝓟1792: [miss]𝓛[ty]10033{Void})
      {
        let 𝓟1793{ret};
        {
          function 𝓟1794{$Lambda35} (𝓟1795{r}: [OOV]any): (𝓟1796: [miss]𝓛[ty]10033{Void})
          {
            𝓟1793{ret} ⟵ 𝓟1779{gen}.throw(𝓟1795{r});
          }
          𝓟1770{wrap}(𝓟1794{$Lambda35},𝓛8743{String},𝓟1791{err})
        }
        𝓟1797{next}(𝓟1793{ret})
      }
      function 𝓟1797{next} (𝓟1798{ret}: [OOV]any): (𝓟1799: [OOV]any)
      {
        if (𝓟1798{ret}.done)
        {
          function 𝓟1800{$Lambda36} (): (𝓟1801: [miss]𝓛[ty]10033{Void})
          {
            function 𝓟1802{$Lambda37} (𝓟1803{r}: [OOV]any): (𝓟1804: [miss]𝓛[ty]10033{Void})
            {
              𝓟1776{resolve}(𝓟1803{r})
            }
            𝓟1770{wrap}(𝓟1802{$Lambda37},𝓛8743{String},𝓟1798{ret}.value)
          }
          𝓛10082{setImmediate}(𝓟1800{$Lambda36})
        }
        if (𝓛12548{ExclamationToken}(𝓟1798{ret}.value).BarBarToken(𝓛12550{$TypeOf}(𝓟1798{ret}.value.then).ExclamationEqualsEqualsToken(𝓛8743{String})))
        {
          𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟1798{ret}))
        }
        return 𝓟1799 = 𝓟1798{ret}.value.then(𝓟1783{onFulfilled},𝓟1790{onRejected})
      }
    }
    return 𝓟1766 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟1775{$Lambda33})
  }
  const 𝓟1805{spawner}: [miss]𝓛[ty]8696{Function} = 𝓟1764{flowSpawner};
  return 𝓟1763 = 𝓟1805{spawner}
}

Module: packages/mobx-state-tree/src/types/utility-types/enumeration

function 𝓟1806{enumeration} (𝓟1807{name}: 𝓛[ty]10051{String},𝓟1808{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1809: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1810{enumeration} (𝓟1811{options}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8670{Array})): (𝓟1812: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1813{enumeration} (𝓟1814{name}: 𝓛[ty]10051{String},𝓟1815{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1816: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1817{enumeration} (𝓟1818{options}: 𝓛[ty]8670{Array}): (𝓟1819: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1820{enumeration} (𝓟1821{name}: 𝓛[ty]10051{String},𝓟1822{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1823: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1824{enumeration} (𝓟1825{options}: 𝓛[ty]8670{Array}): (𝓟1826: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1827{enumeration} (𝓟1828{name}: 𝓛[ty]10051{String},𝓟1829{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1830: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1831{enumeration} (𝓟1832{options}: 𝓛[ty]8670{Array}): (𝓟1833: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1834{enumeration} (𝓟1835{name}: 𝓛[ty]10051{String},𝓟1836{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1837: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1838{enumeration} (𝓟1839{options}: 𝓛[ty]8670{Array}): (𝓟1840: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1841{enumeration} (𝓟1842{name}: 𝓛[ty]10051{String},𝓟1843{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1844: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1845{enumeration} (𝓟1846{options}: 𝓛[ty]8670{Array}): (𝓟1847: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1848{enumeration} (𝓟1849{name}: 𝓛[ty]10051{String},𝓟1850{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1851: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1852{enumeration} (𝓟1853{options}: 𝓛[ty]8670{Array}): (𝓟1854: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1855{enumeration} (𝓟1856{name}: 𝓛[ty]10051{String},𝓟1857{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1858: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1859{enumeration} (𝓟1860{options}: 𝓛[ty]8670{Array}): (𝓟1861: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1862{enumeration} (𝓟1863{name}: 𝓛[ty]10051{String},𝓟1864{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1865: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1866{enumeration} (𝓟1867{options}: 𝓛[ty]8670{Array}): (𝓟1868: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1869{enumeration} (𝓟1870{name}: 𝓛[ty]10051{String},𝓟1871{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1872: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1873{enumeration} (𝓟1874{options}: 𝓛[ty]8670{Array}): (𝓟1875: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1876{enumeration} (𝓟1877{name}: 𝓛[ty]10051{String},𝓟1878{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1879: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1880{enumeration} (𝓟1881{options}: 𝓛[ty]8670{Array}): (𝓟1882: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1883{enumeration} (𝓟1884{name}: 𝓛[ty]10051{String},𝓟1885{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1886: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1887{enumeration} (𝓟1888{options}: 𝓛[ty]8670{Array}): (𝓟1889: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1890{enumeration} (𝓟1891{name}: 𝓛[ty]10051{String},𝓟1892{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1893: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1894{enumeration} (𝓟1895{options}: 𝓛[ty]8670{Array}): (𝓟1896: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1897{enumeration} (𝓟1898{name}: 𝓛[ty]10051{String},𝓟1899{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1900: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1901{enumeration} (𝓟1902{options}: 𝓛[ty]8670{Array}): (𝓟1903: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1904{enumeration} (𝓟1905{name}: 𝓛[ty]10051{String},𝓟1906{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1907: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1908{enumeration} (𝓟1909{options}: 𝓛[ty]8670{Array}): (𝓟1910: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1911{enumeration} (𝓟1912{name}: 𝓛[ty]10051{String},𝓟1913{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1914: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1915{enumeration} (𝓟1916{options}: 𝓛[ty]8670{Array}): (𝓟1917: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1918{enumeration} (𝓟1919{name}: 𝓛[ty]10051{String},𝓟1920{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1921: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1922{enumeration} (𝓟1923{options}: 𝓛[ty]8670{Array}): (𝓟1924: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1925{enumeration} (𝓟1926{name}: 𝓛[ty]10051{String},𝓟1927{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1928: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1929{enumeration} (𝓟1930{options}: 𝓛[ty]8670{Array}): (𝓟1931: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1932{enumeration} (𝓟1933{name}: 𝓛[ty]10051{String},𝓟1934{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1935: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1936{enumeration} (𝓟1937{options}: 𝓛[ty]8670{Array}): (𝓟1938: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1939{enumeration} (𝓟1940{name}: 𝓛[ty]10051{String},𝓟1941{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1942: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1943{enumeration} (𝓟1944{options}: 𝓛[ty]8670{Array}): (𝓟1945: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1946{enumeration} (𝓟1947{name}: 𝓛[ty]10051{String},𝓟1948{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1949: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1950{enumeration} (𝓟1951{options}: 𝓛[ty]8670{Array}): (𝓟1952: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1953{enumeration} (𝓟1954{name}: 𝓛[ty]10051{String},𝓟1955{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1956: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1957{enumeration} (𝓟1958{options}: 𝓛[ty]8670{Array}): (𝓟1959: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1960{enumeration} (𝓟1961{name}: 𝓛[ty]10051{String},𝓟1962{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1963: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1964{enumeration} (𝓟1965{options}: 𝓛[ty]8670{Array}): (𝓟1966: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1967{enumeration} (𝓟1968{name}: 𝓛[ty]10051{String},𝓟1969{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1970: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1971{enumeration} (𝓟1972{options}: 𝓛[ty]8670{Array}): (𝓟1973: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1974{enumeration} (𝓟1975{name}: 𝓛[ty]10051{String},𝓟1976{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1977: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1978{enumeration} (𝓟1979{options}: 𝓛[ty]8670{Array}): (𝓟1980: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1981{enumeration} (𝓟1982{name}: 𝓛[ty]10051{String},𝓟1983{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1984: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1985{enumeration} (𝓟1986{options}: 𝓛[ty]8670{Array}): (𝓟1987: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1988{enumeration} (𝓟1989{name}: 𝓛[ty]10051{String},𝓟1990{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1991: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1992{enumeration} (𝓟1993{options}: 𝓛[ty]8670{Array}): (𝓟1994: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1995{enumeration} (𝓟1996{name}: 𝓛[ty]10051{String},𝓟1997{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟1998: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟1999{enumeration} (𝓟2000{options}: 𝓛[ty]8670{Array}): (𝓟2001: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2002{enumeration} (𝓟2003{name}: 𝓛[ty]10051{String},𝓟2004{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2005: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2006{enumeration} (𝓟2007{options}: 𝓛[ty]8670{Array}): (𝓟2008: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2009{enumeration} (𝓟2010{name}: 𝓛[ty]10051{String},𝓟2011{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2012: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2013{enumeration} (𝓟2014{options}: 𝓛[ty]8670{Array}): (𝓟2015: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2016{enumeration} (𝓟2017{name}: 𝓛[ty]10051{String},𝓟2018{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2019: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2020{enumeration} (𝓟2021{options}: 𝓛[ty]8670{Array}): (𝓟2022: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2023{enumeration} (𝓟2024{name}: 𝓛[ty]10051{String},𝓟2025{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2026: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2027{enumeration} (𝓟2028{options}: 𝓛[ty]8670{Array}): (𝓟2029: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2030{enumeration} (𝓟2031{name}: 𝓛[ty]10051{String},𝓟2032{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2033: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2034{enumeration} (𝓟2035{options}: 𝓛[ty]8670{Array}): (𝓟2036: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2037{enumeration} (𝓟2038{name}: 𝓛[ty]10051{String},𝓟2039{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2040: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2041{enumeration} (𝓟2042{options}: 𝓛[ty]8670{Array}): (𝓟2043: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2044{enumeration} (𝓟2045{name}: 𝓛[ty]10051{String},𝓟2046{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2047: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2048{enumeration} (𝓟2049{options}: 𝓛[ty]8670{Array}): (𝓟2050: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2051{enumeration} (𝓟2052{name}: 𝓛[ty]10051{String},𝓟2053{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2054: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2055{enumeration} (𝓟2056{options}: 𝓛[ty]8670{Array}): (𝓟2057: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2058{enumeration} (𝓟2059{name}: 𝓛[ty]10051{String},𝓟2060{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2061: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2062{enumeration} (𝓟2063{options}: 𝓛[ty]8670{Array}): (𝓟2064: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2065{enumeration} (𝓟2066{name}: 𝓛[ty]10051{String},𝓟2067{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2068: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2069{enumeration} (𝓟2070{options}: 𝓛[ty]8670{Array}): (𝓟2071: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2072{enumeration} (𝓟2073{name}: 𝓛[ty]10051{String},𝓟2074{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2075: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2076{enumeration} (𝓟2077{options}: 𝓛[ty]8670{Array}): (𝓟2078: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2079{enumeration} (𝓟2080{name}: 𝓛[ty]10051{String},𝓟2081{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2082: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2083{enumeration} (𝓟2084{options}: 𝓛[ty]8670{Array}): (𝓟2085: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2086{enumeration} (𝓟2087{name}: 𝓛[ty]10051{String},𝓟2088{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2089: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2090{enumeration} (𝓟2091{options}: 𝓛[ty]8670{Array}): (𝓟2092: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2093{enumeration} (𝓟2094{name}: 𝓛[ty]10051{String},𝓟2095{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2096: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2097{enumeration} (𝓟2098{options}: 𝓛[ty]8670{Array}): (𝓟2099: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2100{enumeration} (𝓟2101{name}: 𝓛[ty]10051{String},𝓟2102{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2103: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2104{enumeration} (𝓟2105{options}: 𝓛[ty]8670{Array}): (𝓟2106: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2107{enumeration} (𝓟2108{name}: 𝓛[ty]10051{String},𝓟2109{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2110: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2111{enumeration} (𝓟2112{options}: 𝓛[ty]8670{Array}): (𝓟2113: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2114{enumeration} (𝓟2115{name}: 𝓛[ty]10051{String},𝓟2116{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2117: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2118{enumeration} (𝓟2119{options}: 𝓛[ty]8670{Array}): (𝓟2120: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2121{enumeration} (𝓟2122{name}: 𝓛[ty]10051{String},𝓟2123{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2124: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2125{enumeration} (𝓟2126{options}: 𝓛[ty]8670{Array}): (𝓟2127: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2128{enumeration} (𝓟2129{name}: 𝓛[ty]10051{String},𝓟2130{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2131: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2132{enumeration} (𝓟2133{options}: 𝓛[ty]8670{Array}): (𝓟2134: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2135{enumeration} (𝓟2136{name}: 𝓛[ty]10051{String},𝓟2137{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2138: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2139{enumeration} (𝓟2140{options}: 𝓛[ty]8670{Array}): (𝓟2141: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2142{enumeration} (𝓟2143{name}: 𝓛[ty]10051{String},𝓟2144{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2145: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2146{enumeration} (𝓟2147{options}: 𝓛[ty]8670{Array}): (𝓟2148: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2149{enumeration} (𝓟2150{name}: 𝓛[ty]10051{String},𝓟2151{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2152: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2153{enumeration} (𝓟2154{options}: 𝓛[ty]8670{Array}): (𝓟2155: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2156{enumeration} (𝓟2157{options}: 𝓛[ty]8670{Array}): (𝓟2158: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2159{enumeration} (𝓟2160{name}: 𝓛[ty]10051{String},𝓟2161{options}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2162: [OOV]𝓟[ty]6944{ISnapshottable})
{
}
function 𝓟2163{enumeration} (𝓟2164{name}: [OOV]any,𝓟2165{options}: [OOV]any): (𝓟2166: [OOV]𝓟[ty]6944{ISnapshottable})
{
  const 𝓟2167{realOptions}: 𝓛[ty]8670{Array} = (𝓛12550{$TypeOf}(𝓟2164{name}).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟2165{options} : 𝓟2164{name};
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    function 𝓟2168{$Lambda112} (𝓟2169{option}): (𝓟2170: [miss]𝓛[ty]10033{Void})
    {
      if (𝓛12550{$TypeOf}(𝓟2169{option}).ExclamationEqualsEqualsToken(𝓛8743{String}))
      {
        𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟2174{type}).PlusToken(𝓛8743{String}))
      }
    }
    𝓟2167{realOptions}.forEach(𝓟2168{$Lambda112})
  }
  function 𝓟2171{$Lambda113} (𝓟2172{option}): (𝓟2173: [OOV]𝓟[ty]6944{ISnapshottable})
  {
    return 𝓟2173 = 𝓟2202{literal}(𝓛8743{String}.PlusToken(𝓟2172{option}))
  }
  const 𝓟2174{type}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟995{union}(𝓛12551{$Spread}(𝓟2167{realOptions}.map(𝓟2171{$Lambda113})));
  if (𝓛12550{$TypeOf}(𝓟2164{name}).EqualsEqualsEqualsToken(𝓛8743{String}))
  {
    𝓟2174{type}.name ⟵ 𝓟2164{name};
  }
  return 𝓟2166 = 𝓟2174{type}
}

Module: packages/mst-middlewares/src/redux

function 𝓟2208{$Lambda10} (𝓟2209{model}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2210{middlewares}: 𝓛[ty]8670{Array}): (𝓟2211: [miss]𝓛[ty]8642{Object})
{
  if (𝓛12548{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟2209{model})))
  {
    𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
  }
  function 𝓟2212{$Lambda11} (): (𝓟2213: [OOV]any)
  {
    return 𝓟2213 = 𝓛1{<UNKNOWN>}(𝓟2209{model})
  }
  function 𝓟2214{$Lambda12} (𝓟2215{action}: [OOV]any): (𝓟2216: [miss]𝓛[ty]10033{Void})
  {
    function 𝓟2217{$Lambda13} (𝓟2218{newAction}: [OOV]any): (𝓟2219: [OOV]any)
    {
      return 𝓟2219 = 𝓛1{<UNKNOWN>}(𝓟2209{model},𝓟2229{reduxActionToAction}(𝓟2218{newAction}))
    }
    𝓟2233{runMiddleWare}(𝓟2215{action},𝓟2227{runners}.slice(),𝓟2217{$Lambda13})
  }
  function 𝓟2220{$Lambda14} (𝓟2221{listener}: [OOV]any): (𝓟2222: [OOV]any)
  {
    return 𝓟2222 = 𝓛1{<UNKNOWN>}(𝓟2209{model},𝓟2221{listener})
  }
  let 𝓟2223{store}: [miss]𝓛[ty]8642{Object} = {getState: 𝓟2212{$Lambda11},dispatch: 𝓟2214{$Lambda12},subscribe: 𝓟2220{$Lambda14}};
  function 𝓟2224{$Lambda15} (𝓟2225{mw}): (𝓟2226: [OOV]any)
  {
    return 𝓟2226 = 𝓟2225{mw}(𝓟2223{store})
  }
  let 𝓟2227{runners}: [miss]𝓛[ty]8670{Array} = 𝓟2210{middlewares}.map(𝓟2224{$Lambda15});
  return 𝓟2211 = 𝓟2223{store}
}
const 𝓟2228{asReduxStore}: [miss]𝓛[ty]8696{Function} = 𝓟2208{$Lambda10};
function 𝓟2229{reduxActionToAction} (𝓟2230{action}: [OOV]any): (𝓟2231: [miss]𝓛[ty]8642{Object})
{
  const 𝓟2232{actionArgs} = 𝓛8741{Object}.assign({},𝓟2230{action});
  𝓛12560{$Delete}(𝓟2232{actionArgs}.type)
  return 𝓟2231 = {name: 𝓟2230{action}.type,args: 𝓛8757{Array}(𝓟2232{actionArgs})}
}
function 𝓟2233{runMiddleWare} (𝓟2234{action}: [OOV]any,𝓟2235{runners}: 𝓛[ty]8670{Array},𝓟2236{next}: [OOV]any): (𝓟2237: [miss]𝓛[ty]10033{Void})
{
  function 𝓟2238{n} (𝓟2239{retVal}: [OOV]any): (𝓟2240: [miss]𝓛[ty]10033{Void})
  {
    const 𝓟2241{f} = 𝓟2235{runners}.shift();
    if (𝓟2241{f})
    {
      𝓟2241{f}(𝓟2238{n})(𝓟2239{retVal})
    }
    else
    {
      𝓟2236{next}(𝓟2239{retVal})
    }
  }
  𝓟2238{n}(𝓟2234{action})
}
function 𝓟2242{connectReduxDevtools} (𝓟2243{remoteDevDep}: [OOV]any,𝓟2244{model}: [OOV]any): (𝓟2245: [miss]𝓛[ty]10033{Void})
{
  const 𝓟2246{remotedev} = 𝓟2243{remoteDevDep}.connectViaExtension({name: 𝓛1{<UNKNOWN>}(𝓟2244{model}).name});
  let 𝓟2247{applyingSnapshot}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
  function 𝓟2248{$Lambda16} (𝓟2249{message}: [OOV]any): (𝓟2250: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟2249{message}.type.EqualsEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟2260{handleMonitorActions}(𝓟2246{remotedev},𝓟2244{model},𝓟2249{message})
    }
  }
  𝓟2246{remotedev}.subscribe(𝓟2248{$Lambda16})
  const 𝓟2251{initialState} = 𝓛1{<UNKNOWN>}(𝓟2244{model});
  𝓟2246{remotedev}.init(𝓟2251{initialState})
  function 𝓟2252{$Lambda17} (𝓟2253{action}): (𝓟2254: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟2247{applyingSnapshot})
    {
    }
    const 𝓟2255{copy}: [OOV]any = {};
    𝓟2255{copy}.type ⟵ 𝓟2253{action}.name;
    if (𝓟2253{action}.args)
    {
      function 𝓟2256{$Lambda18} (𝓟2257{value},𝓟2258{index}): (𝓟2259: [OOV]any)
      {
        return 𝓟2259 = 𝓟2255{copy}.access(𝓟2258{index}).FirstAssignment(𝓟2257{value})
      }
      𝓟2253{action}.args.forEach(𝓟2256{$Lambda18})
    }
    𝓟2246{remotedev}.send(𝓟2255{copy},𝓛1{<UNKNOWN>}(𝓟2244{model}))
  }
  𝓛1{<UNKNOWN>}(𝓟2244{model},𝓟2252{$Lambda17},𝓛8744{Boolean})
  function 𝓟2260{handleMonitorActions} (𝓟2261{remotedev}: [OOV]any,𝓟2262{model}: [OOV]any,𝓟2263{message}: [OOV]any): (𝓟2264: [OOV]any)
  {
    𝓛12549{$Switch}(𝓟2263{message}.payload.type)
    𝓛12561{$Case}(𝓛8743{String})
    𝓟2267{applySnapshot}(𝓟2262{model},𝓟2251{initialState})
    return 𝓟2264 = 𝓟2261{remotedev}.init(𝓟2251{initialState})
    𝓛12561{$Case}(𝓛8743{String})
    return 𝓟2264 = 𝓟2261{remotedev}.init(𝓛1{<UNKNOWN>}(𝓟2262{model}))
    𝓛12561{$Case}(𝓛8743{String})
    return 𝓟2264 = 𝓟2261{remotedev}.init(𝓟2243{remoteDevDep}.extractState(𝓟2263{message}))
    𝓛12561{$Case}(𝓛8743{String})
    𝓛12561{$Case}(𝓛8743{String})
    𝓟2267{applySnapshot}(𝓟2262{model},𝓟2243{remoteDevDep}.extractState(𝓟2263{message}))
    𝓛12561{$Case}(𝓛8743{String})
    const 𝓟2265{nextLiftedState} = 𝓟2263{message}.payload.nextLiftedState;
    const 𝓟2266{computedStates} = 𝓟2265{nextLiftedState}.computedStates;
    𝓟2267{applySnapshot}(𝓟2262{model},𝓟2266{computedStates}.access(𝓟2266{computedStates}.length.MinusToken(𝓛8745{Number})).state)
    𝓟2261{remotedev}.send(𝓛12563{undefined},𝓟2265{nextLiftedState})
  }
  function 𝓟2267{applySnapshot} (𝓟2268{model}: [OOV]any,𝓟2269{state}: [OOV]any): (𝓟2270: [miss]𝓛[ty]10033{Void})
  {
    𝓟2247{applyingSnapshot} ⟵ 𝓛8744{Boolean};
    𝓛1{<UNKNOWN>}(𝓟2268{model},𝓟2269{state})
    𝓟2247{applyingSnapshot} ⟵ 𝓛8744{Boolean};
  }
}
const 𝓟2271{connectReduxDevtools}: [miss]𝓛[ty]8696{Function} = 𝓟2271{connectReduxDevtools};

Module: packages/mobx-state-tree/src/core/node/scalar-node

function 𝓟2272{CONSTRUCTOR} (𝓟2273{type}: [OOV]𝓟[ty]6960{IType},𝓟2274{parent}: [OOV]any,𝓟2275{subpath}: 𝓛[ty]10051{String},𝓟2276{environment}: [OOV]any,𝓟2277{initialValue}: [OOV]any,𝓟2278{storedValue}: [OOV]any,𝓟2279{canAttachTreeNode}: 𝓛[ty]8666{Boolean},𝓟2280{finalizeNewInstance}: 𝓛[ty]8696{Function}): (𝓟[ty]2285{ScalarNode})
{
  const 𝓟[ty]2285{ScalarNode};
  const 𝓟[ty]2285{ScalarNode};
  𝓟[ty]2285{ScalarNode}.subpath ⟵ 𝓛8743{String};
  𝓟[ty]2285{ScalarNode}.state ⟵ 𝓟672{NodeLifeCycle}.INITIALIZING;
  𝓟[ty]2285{ScalarNode}._environment ⟵ 𝓛12563{undefined};
  𝓟[ty]2285{ScalarNode}._autoUnbox ⟵ 𝓛8744{Boolean};
  𝓟[ty]2285{ScalarNode}.type ⟵ 𝓟2273{type};
  𝓟[ty]2285{ScalarNode}.storedValue ⟵ 𝓟2278{storedValue};
  𝓟[ty]2285{ScalarNode}._parent ⟵ 𝓟2274{parent};
  𝓟[ty]2285{ScalarNode}.subpath ⟵ 𝓟2275{subpath};
  𝓟[ty]2285{ScalarNode}.storedValue ⟵ 𝓟2278{storedValue};
  𝓟[ty]2285{ScalarNode}._environment ⟵ 𝓟2276{environment};
  𝓟[ty]2285{ScalarNode}.unbox ⟵ 𝓟[ty]2285{ScalarNode}.unbox.bind(𝓟[ty]2285{ScalarNode});
  if (𝓟2279{canAttachTreeNode})
  {
    𝓟467{addHiddenFinalProp}(𝓟[ty]2285{ScalarNode}.storedValue,𝓛8743{String},𝓟[ty]2285{ScalarNode})
  }
  let 𝓟2284{sawException}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
  {
    if (𝓟2279{canAttachTreeNode})
    {
      𝓟467{addHiddenFinalProp}(𝓟[ty]2285{ScalarNode}.storedValue,𝓛8743{String},𝓟682{toJSON})
    }
    𝓟2280{finalizeNewInstance}(𝓟[ty]2285{ScalarNode},𝓟2277{initialValue})
    𝓟[ty]2285{ScalarNode}.state ⟵ 𝓟672{NodeLifeCycle}.CREATED;
    𝓟2284{sawException} ⟵ 𝓛8744{Boolean};
  }
  {
    if (𝓟2284{sawException})
    {
      𝓟[ty]2285{ScalarNode}.state ⟵ 𝓟672{NodeLifeCycle}.DEAD;
    }
  }
}
class 𝓟[ty]2285{ScalarNode} extends 𝓟[ty]6979{INode}{
  𝓟2287{_autoUnbox}: [miss]𝓛[ty]8666{Boolean};
  𝓟2288{state}: [miss]𝓛[ty]8655{Number};
  𝓟2289{subpath}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String});
  𝓟2290{storedValue}: [OOV]any;
  𝓟2291{_environment}: [OOV]any;
  𝓟2292{_parent}: [OOV]any;
  𝓟2293{type}: [OOV]𝓟[ty]6960{IType};
  function 𝓟2296{isRoot} (): (𝓟2297: 𝓛[ty]8666{Boolean})
  {
    return 𝓟2297 = 𝓟[ty]2285{ScalarNode}.parent.EqualsEqualsEqualsToken(𝓛12563{undefined})
  }
  function 𝓟2298{parent} (): (𝓟2299: [OOV]any)
  {
    return 𝓟2299 = 𝓟[ty]2285{ScalarNode}._parent
  }
  function 𝓟2311{isAlive} (): (𝓟2312)
  {
    return 𝓟2312 = 𝓟[ty]2285{ScalarNode}.state.ExclamationEqualsEqualsToken(𝓟672{NodeLifeCycle}.DEAD)
  }
  function 𝓟2294{path} (): (𝓟2295: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10051{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟[ty]2285{ScalarNode}.parent))
    {
      return 𝓟2295 = 𝓛8743{String}
    }
    return 𝓟2295 = 𝓟[ty]2285{ScalarNode}.parent.path.PlusToken(𝓛8743{String}).PlusToken(𝓟2675{escapeJsonPath}(𝓟[ty]2285{ScalarNode}.subpath))
  }
  function 𝓟2300{root} (): (𝓟2301: [OOV]𝓟[ty]2343{ObjectNode})
  {
    if (𝓛12548{ExclamationToken}(𝓟[ty]2285{ScalarNode}._parent))
    {
      return 𝓟2301 = 𝓟376{fail}(𝓛8743{String})
    }
    return 𝓟2301 = 𝓟[ty]2285{ScalarNode}._parent.root
  }
  function 𝓟2318{die} (): (𝓟2319: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]2285{ScalarNode}.state ⟵ 𝓟672{NodeLifeCycle}.DEAD;
  }
  function 𝓟2308{snapshot} (): (𝓟2309)
  {
    const 𝓟2310{snapshot} = 𝓟[ty]2285{ScalarNode}.type.getSnapshot(𝓟[ty]2285{ScalarNode});
    if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      return 𝓟2309 = 𝓟455{freeze}(𝓟2310{snapshot})
    }
    return 𝓟2309 = 𝓟2310{snapshot}
  }
  function 𝓟2313{unbox} (𝓟2314{childNode}: [OOV]𝓟[ty]6979{INode}): (𝓟2315: [OOV]any)
  {
    if (𝓟2314{childNode}.AmpersandAmpersandToken(𝓟[ty]2285{ScalarNode}._autoUnbox.EqualsEqualsEqualsToken(𝓛8744{Boolean})))
    {
      return 𝓟2315 = 𝓟2314{childNode}.value
    }
    return 𝓟2315 = 𝓟2314{childNode}
  }
  function 𝓟2302{setParent} (𝓟2303{newParent}: [OOV]any,𝓟2304{subpath}: [OOV]any): (𝓟2305: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟[ty]2285{ScalarNode}.parent.ExclamationEqualsEqualsToken(𝓟2303{newParent}))
    {
      𝓟376{fail}(𝓛8743{String})
    }
    if (𝓟[ty]2285{ScalarNode}.subpath.EqualsEqualsEqualsToken(𝓟2304{subpath}))
    {
    }
    𝓟[ty]2285{ScalarNode}.subpath ⟵ 𝓟2304{subpath}.BarBarToken(𝓛8743{String});
  }
  function 𝓟2316{toString} (): (𝓟2317: 𝓛[ty]10051{String})
  {
    return 𝓟2317 = 𝓛12554{$Template}(𝓟[ty]2285{ScalarNode}.type.name,𝓟[ty]2285{ScalarNode}.path.BarBarToken(𝓛8743{String}),(𝓟[ty]2285{ScalarNode}.isAlive ? 𝓛8743{String} : 𝓛8743{String})
  }
  function 𝓟2306{value} (): (𝓟2307: [OOV]any)
  {
    return 𝓟2307 = 𝓟[ty]2285{ScalarNode}.type.getValue(𝓟[ty]2285{ScalarNode})
  }
}

Module: packages/mobx-state-tree/src/core/node/object-node

let 𝓟2320{nextNodeId}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
function 𝓟2321{CONSTRUCTOR} (𝓟2322{type}: [OOV]𝓟[ty]6960{IType},𝓟2323{parent}: [OOV]any,𝓟2324{subpath}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String}),𝓟2325{environment}: [OOV]any,𝓟2326{initialValue}: [OOV]any,𝓟2327{storedValue}: [OOV]any,𝓟2328{canAttachTreeNode}: 𝓛[ty]8666{Boolean},𝓟2329{finalizeNewInstance}: 𝓛[ty]8696{Function}): (𝓟[ty]2343{ObjectNode})
{
  const 𝓟[ty]2343{ObjectNode};
  const 𝓟[ty]2343{ObjectNode};
  𝓟[ty]2343{ObjectNode}.subpath ⟵ 𝓛8743{String};
  𝓟[ty]2343{ObjectNode}.middlewares ⟵ 𝓟374{EMPTY_ARRAY} as 𝓛[ty]8670{Array};
  𝓟[ty]2343{ObjectNode}.nodeId ⟵ 𝓛12553{PlusPlusToken}(𝓟2320{nextNodeId});
  𝓟[ty]2343{ObjectNode}._environment ⟵ 𝓛12563{undefined};
  𝓟[ty]2343{ObjectNode}.state ⟵ 𝓟672{NodeLifeCycle}.INITIALIZING;
  𝓟[ty]2343{ObjectNode}._isRunningAction ⟵ 𝓛8744{Boolean};
  𝓟[ty]2343{ObjectNode}.isProtectionEnabled ⟵ 𝓛8744{Boolean};
  𝓟[ty]2343{ObjectNode}.identifierAttribute ⟵ 𝓛12563{undefined};
  𝓟[ty]2343{ObjectNode}._parent ⟵ 𝓛12563{undefined};
  𝓟[ty]2343{ObjectNode}._autoUnbox ⟵ 𝓛8744{Boolean};
  𝓟[ty]2343{ObjectNode}.type ⟵ 𝓟2322{type};
  𝓟[ty]2343{ObjectNode}.storedValue ⟵ 𝓟2327{storedValue};
  𝓟[ty]2343{ObjectNode}._parent ⟵ 𝓟2323{parent};
  𝓟[ty]2343{ObjectNode}.subpath ⟵ 𝓟2324{subpath};
  𝓟[ty]2343{ObjectNode}._environment ⟵ 𝓟2325{environment};
  𝓟[ty]2343{ObjectNode}.unbox ⟵ 𝓟[ty]2343{ObjectNode}.unbox.bind(𝓟[ty]2343{ObjectNode});
  𝓟[ty]2343{ObjectNode}.preboot()
  if (𝓛12548{ExclamationToken}(𝓟2323{parent}))
  {
    𝓟[ty]2343{ObjectNode}.identifierCache ⟵ 𝓟726{CONSTRUCTOR}();
  }
  if (𝓟2328{canAttachTreeNode})
  {
    𝓟467{addHiddenFinalProp}(𝓟[ty]2343{ObjectNode}.storedValue,𝓛8743{String},𝓟[ty]2343{ObjectNode})
  }
  let 𝓟2333{sawException}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
  {
    if (𝓟2328{canAttachTreeNode})
    {
      𝓟467{addHiddenFinalProp}(𝓟[ty]2343{ObjectNode}.storedValue,𝓛8743{String},𝓟682{toJSON})
    }
    𝓟[ty]2343{ObjectNode}._isRunningAction ⟵ 𝓛8744{Boolean};
    𝓟2329{finalizeNewInstance}(𝓟[ty]2343{ObjectNode},𝓟2326{initialValue})
    𝓟[ty]2343{ObjectNode}._isRunningAction ⟵ 𝓛8744{Boolean};
    if (𝓟2323{parent})
    {
      𝓟2323{parent}.root.identifierCache.addNodeToCache(𝓟[ty]2343{ObjectNode})
    }
    else
    {
      𝓟[ty]2343{ObjectNode}.identifierCache.addNodeToCache(𝓟[ty]2343{ObjectNode})
    }
    𝓟[ty]2343{ObjectNode}.fireHook(𝓛8743{String})
    𝓟[ty]2343{ObjectNode}.state ⟵ 𝓟672{NodeLifeCycle}.CREATED;
    𝓟2333{sawException} ⟵ 𝓛8744{Boolean};
  }
  {
    if (𝓟2333{sawException})
    {
      𝓟[ty]2343{ObjectNode}.state ⟵ 𝓟672{NodeLifeCycle}.DEAD;
    }
  }
  function 𝓟2334{$Lambda60} (): (𝓟2335: [OOV]any)
  {
    return 𝓟2335 = 𝓟[ty]2343{ObjectNode}.snapshot
  }
  function 𝓟2336{$Lambda61} (𝓟2337{snapshot}): (𝓟2338: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]2343{ObjectNode}.emitSnapshot(𝓟2337{snapshot})
  }
  const 𝓟2339{snapshotDisposer} = 𝓟2846{reaction}(𝓟2334{$Lambda60},𝓟2336{$Lambda61});
  function 𝓟2340{$Lambda62} (𝓟2341{e}: [OOV]any): (𝓟2342: [OOV]any)
  {
    𝓟2341{e}
  }
  𝓟2339{snapshotDisposer}.onError(𝓟2340{$Lambda62})
  𝓟[ty]2343{ObjectNode}.addDisposer(𝓟2339{snapshotDisposer})
}
class 𝓟[ty]2343{ObjectNode} extends 𝓟[ty]6979{INode}{
  𝓟2345{_autoUnbox}: [miss]𝓛[ty]8666{Boolean};
  𝓟2346{applyPatches}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function});
  𝓟2347{isProtectionEnabled}: [miss]𝓛[ty]8666{Boolean};
  𝓟2348{state}: [miss]𝓛[ty]8655{Number};
  𝓟2349{subpath}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10051{String});
  𝓟2350{storedValue}: [OOV]any;
  𝓟2351{applySnapshot}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function});
  𝓟2352{patchSubscribers}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array});
  𝓟2353{identifierAttribute}: [OOV]any;
  𝓟2354{_environment}: [OOV]any;
  𝓟2355{disposers}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array});
  𝓟2356{_isRunningAction}: [miss]𝓛[ty]8666{Boolean};
  𝓟2357{snapshotSubscribers}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array});
  𝓟2358{identifierCache}: [OOV]any;
  𝓟2359{middlewares}: [miss]𝓛[ty]8670{Array};
  𝓟2360{_parent}: [OOV]any;
  𝓟2361{type}: [OOV]𝓟[ty]6960{IType};
  𝓟2362{nodeId}: [miss]𝓛[ty]8655{Number};
  function 𝓟2365{isRoot} (): (𝓟2366: 𝓛[ty]8666{Boolean})
  {
    return 𝓟2366 = 𝓟[ty]2343{ObjectNode}.parent.EqualsEqualsEqualsToken(𝓛12563{undefined})
  }
  function 𝓟2367{parent} (): (𝓟2368: [OOV]any)
  {
    return 𝓟2368 = 𝓟[ty]2343{ObjectNode}._parent
  }
  function 𝓟2377{fireHook} (𝓟2378{name}: 𝓛[ty]10051{String}): (𝓟2379: [miss]𝓛[ty]10033{Void})
  {
    const 𝓟2380{fn} = 𝓟[ty]2343{ObjectNode}.storedValue.AmpersandAmpersandToken(𝓛12550{$TypeOf}(𝓟[ty]2343{ObjectNode}.storedValue).EqualsEqualsEqualsToken(𝓛8743{String})).AmpersandAmpersandToken(𝓟[ty]2343{ObjectNode}.storedValue.access(𝓟2378{name}));
    if (𝓛12550{$TypeOf}(𝓟2380{fn}).EqualsEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟2380{fn}.apply(𝓟[ty]2343{ObjectNode}.storedValue)
    }
  }
  function 𝓟2390{isAlive} (): (𝓟2391)
  {
    return 𝓟2391 = 𝓟[ty]2343{ObjectNode}.state.ExclamationEqualsEqualsToken(𝓟672{NodeLifeCycle}.DEAD)
  }
  function 𝓟2363{path} (): (𝓟2364: 𝓛[ty]10051{String})
  {
    if (𝓛12548{ExclamationToken}(𝓟[ty]2343{ObjectNode}.parent))
    {
      return 𝓟2364 = 𝓛8743{String}
    }
    return 𝓟2364 = 𝓟[ty]2343{ObjectNode}.parent.path.PlusToken(𝓛8743{String}).PlusToken(𝓟2675{escapeJsonPath}(𝓟[ty]2343{ObjectNode}.subpath))
  }
  function 𝓟2369{root} (): (𝓟2370: [OOV]𝓟[ty]2343{ObjectNode})
  {
    let 𝓟2371{p};
    let 𝓟2372{r}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟[ty]2343{ObjectNode};
    while (𝓟2371{p}.FirstAssignment(𝓟2372{r}.parent))
    {
      𝓟2372{r} ⟵ 𝓟2371{p};
    }
    return 𝓟2370 = 𝓟2372{r}
  }
  function 𝓟2388{identifier} (): (𝓟2389: [OOV]any)
  {
    return 𝓟2389 = (𝓟[ty]2343{ObjectNode}.identifierAttribute ? 𝓟[ty]2343{ObjectNode}.storedValue.access(𝓟[ty]2343{ObjectNode}.identifierAttribute) : 𝓛12563{undefined}
  }
  function 𝓟2454{onSnapshot} (𝓟2455{onChange}: 𝓛[ty]8696{Function}): (𝓟2456: [OOV]𝓟[ty]6974{IDisposer})
  {
    return 𝓟2456 = 𝓟487{registerEventHandler}(𝓟[ty]2343{ObjectNode}.snapshotSubscribers,𝓟2455{onChange})
  }
  function 𝓟2457{emitSnapshot} (𝓟2458{snapshot}: [OOV]any): (𝓟2459: [miss]𝓛[ty]10033{Void})
  {
    function 𝓟2460{$Lambda69} (𝓟2461{f}: 𝓛[ty]8696{Function}): (𝓟2462: [OOV]any)
    {
      return 𝓟2462 = 𝓟2461{f}(𝓟2458{snapshot})
    }
    𝓟[ty]2343{ObjectNode}.snapshotSubscribers.forEach(𝓟2460{$Lambda69})
  }
  function 𝓟2463{onPatch} (𝓟2464{handler}: 𝓛[ty]8696{Function}): (𝓟2465: [OOV]𝓟[ty]6974{IDisposer})
  {
    return 𝓟2465 = 𝓟487{registerEventHandler}(𝓟[ty]2343{ObjectNode}.patchSubscribers,𝓟2464{handler})
  }
  function 𝓟2445{aboutToDie} (): (𝓟2446: [miss]𝓛[ty]10033{Void})
  {
    function 𝓟2447{$Lambda68} (𝓟2448{f}): (𝓟2449: [miss]𝓛[ty]10033{Void})
    {
      return 𝓟2449 = 𝓟2448{f}()
    }
    𝓟[ty]2343{ObjectNode}.disposers.splice(𝓛8745{Number}).forEach(𝓟2447{$Lambda68})
    𝓟[ty]2343{ObjectNode}.fireHook(𝓛8743{String})
  }
  function 𝓟2392{assertAlive} (): (𝓟2393: [miss]𝓛[ty]10033{Void})
  {
    if (𝓛12548{ExclamationToken}(𝓟[ty]2343{ObjectNode}.isAlive))
    {
      𝓟376{fail}(𝓛12554{$Template}(𝓟[ty]2343{ObjectNode}))
    }
  }
  function 𝓟2420{detach} (): (𝓟2421: [miss]𝓛[ty]10033{Void})
  {
    if (𝓛12548{ExclamationToken}(𝓟[ty]2343{ObjectNode}.isAlive))
    {
      𝓟376{fail}(𝓛8743{String})
    }
    if (𝓟[ty]2343{ObjectNode}.isRoot)
    {
    }
    else
    {
      𝓟[ty]2343{ObjectNode}.fireHook(𝓛8743{String})
      𝓟[ty]2343{ObjectNode}._environment ⟵ 𝓟[ty]2343{ObjectNode}.root._environment;
      𝓟[ty]2343{ObjectNode}.state ⟵ 𝓟672{NodeLifeCycle}.DETACHING;
      𝓟[ty]2343{ObjectNode}.identifierCache ⟵ 𝓟[ty]2343{ObjectNode}.root.identifierCache.splitCache(𝓟[ty]2343{ObjectNode});
      𝓟[ty]2343{ObjectNode}.parent.removeChild(𝓟[ty]2343{ObjectNode}.subpath)
      𝓟[ty]2343{ObjectNode}._parent ⟵ 𝓛12563{undefined};
      𝓟[ty]2343{ObjectNode}.subpath ⟵ 𝓛8743{String};
      𝓟[ty]2343{ObjectNode}.state ⟵ 𝓟672{NodeLifeCycle}.FINALIZED;
    }
  }
  function 𝓟2476{addDisposer} (𝓟2477{disposer}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8696{Function})): (𝓟2478: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]2343{ObjectNode}.disposers.unshift(𝓟2477{disposer})
  }
  function 𝓟2435{die} (): (𝓟2436: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟[ty]2343{ObjectNode}.state.EqualsEqualsEqualsToken(𝓟672{NodeLifeCycle}.DETACHING))
    {
    }
    if (𝓟673{isStateTreeNode}(𝓟[ty]2343{ObjectNode}.storedValue))
    {
      function 𝓟2437{$Lambda66} (𝓟2438{child}): (𝓟2439: [miss]𝓛[ty]10033{Void})
      {
        const 𝓟2440{node}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟2438{child});
        if (𝓟2440{node}.InstanceOfKeyword(𝓛12563{undefined}))
        {
          𝓟2440{node}.aboutToDie()
        }
      }
      𝓟661{walk}(𝓟[ty]2343{ObjectNode}.storedValue,𝓟2437{$Lambda66})
      function 𝓟2441{$Lambda67} (𝓟2442{child}): (𝓟2443: [miss]𝓛[ty]10033{Void})
      {
        const 𝓟2444{node}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟2442{child});
        if (𝓟2444{node}.InstanceOfKeyword(𝓛12563{undefined}))
        {
          𝓟2444{node}.finalizeDeath()
        }
      }
      𝓟661{walk}(𝓟[ty]2343{ObjectNode}.storedValue,𝓟2441{$Lambda67})
    }
  }
  function 𝓟2394{getChildNode} (𝓟2395{subpath}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String})): (𝓟2396: [OOV]𝓟[ty]6979{INode})
  {
    𝓟[ty]2343{ObjectNode}.assertAlive()
    𝓟[ty]2343{ObjectNode}._autoUnbox ⟵ 𝓛8744{Boolean};
    const 𝓟2397{res}: [OOV]𝓟[ty]6979{INode} = 𝓟[ty]2343{ObjectNode}.type.getChildNode(𝓟[ty]2343{ObjectNode},𝓟2395{subpath});
    𝓟[ty]2343{ObjectNode}._autoUnbox ⟵ 𝓛8744{Boolean};
    return 𝓟2396 = 𝓟2397{res}
  }
  function 𝓟2383{snapshot} (): (𝓟2384)
  {
    if (𝓛12548{ExclamationToken}(𝓟[ty]2343{ObjectNode}.isAlive))
    {
      return 𝓟2384 = 𝓛12563{undefined}
    }
    const 𝓟2385{snapshot} = 𝓟[ty]2343{ObjectNode}.type.getSnapshot(𝓟[ty]2343{ObjectNode});
    if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      return 𝓟2384 = 𝓟455{freeze}(𝓟2385{snapshot})
    }
    return 𝓟2384 = 𝓟2385{snapshot}
  }
  function 𝓟2401{getChildType} (𝓟2402{key}: 𝓛[ty]10051{String}): (𝓟2403: [OOV]𝓟[ty]6960{IType})
  {
    return 𝓟2403 = 𝓟[ty]2343{ObjectNode}.type.getChildType(𝓟2402{key})
  }
  function 𝓟2450{finalizeDeath} (): (𝓟2451: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]2343{ObjectNode}.root.identifierCache.notifyDied(𝓟[ty]2343{ObjectNode})
    const 𝓟2452{self} = 𝓟[ty]2343{ObjectNode};
    const 𝓟2453{oldPath}: [miss]𝓛[ty]10051{String} = 𝓟[ty]2343{ObjectNode}.path;
    𝓟477{addReadOnlyProp}(𝓟[ty]2343{ObjectNode},𝓛8743{String},𝓟[ty]2343{ObjectNode}.snapshot)
    𝓟[ty]2343{ObjectNode}.patchSubscribers.splice(𝓛8745{Number})
    𝓟[ty]2343{ObjectNode}.snapshotSubscribers.splice(𝓛8745{Number})
    𝓟[ty]2343{ObjectNode}.patchSubscribers.splice(𝓛8745{Number})
    𝓟[ty]2343{ObjectNode}.state ⟵ 𝓟672{NodeLifeCycle}.DEAD;
    𝓟[ty]2343{ObjectNode}._parent ⟵ 𝓛12563{undefined};
    𝓟[ty]2343{ObjectNode}.subpath ⟵ 𝓛8743{String};
    𝓛8741{Object}.defineProperty(𝓟[ty]2343{ObjectNode}.storedValue,𝓛8743{String},{})
  }
  function 𝓟2417{finalizeCreation} (): (𝓟2418: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟[ty]2343{ObjectNode}.state.EqualsEqualsEqualsToken(𝓟672{NodeLifeCycle}.CREATED))
    {
      if (𝓟[ty]2343{ObjectNode}.parent)
      {
        if (𝓟[ty]2343{ObjectNode}.parent.state.ExclamationEqualsEqualsToken(𝓟672{NodeLifeCycle}.FINALIZED))
        {
        }
        𝓟[ty]2343{ObjectNode}.fireHook(𝓛8743{String})
      }
      𝓟[ty]2343{ObjectNode}.state ⟵ 𝓟672{NodeLifeCycle}.FINALIZED;
      {
        let 𝓟2419{child}: [OOV]𝓟[ty]6979{INode} = 𝓛12552{$ArrayAccess}(𝓟[ty]2343{ObjectNode}.getChildren());
        while (𝓛8744{Boolean})
        {
          if (𝓟2419{child}.InstanceOfKeyword(𝓛12563{undefined}))
          {
            𝓟2419{child}.finalizeCreation()
          }
        }
      }
    }
  }
  function 𝓟2479{addMiddleWare} (𝓟2480{handler}: [OOV]𝓟[ty]6969{IMiddlewareHandler}): (𝓟2481: [OOV]𝓟[ty]6974{IDisposer})
  {
    return 𝓟2481 = 𝓟487{registerEventHandler}(𝓟[ty]2343{ObjectNode}.middlewares,𝓟2480{handler})
  }
  function 𝓟2398{getChildren} (): (𝓟2399: (𝓛[ty]8654{Promise} ≠ 𝓛[ty]8670{Array}))
  {
    𝓟[ty]2343{ObjectNode}.assertAlive()
    𝓟[ty]2343{ObjectNode}._autoUnbox ⟵ 𝓛8744{Boolean};
    const 𝓟2400{res}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]2343{ObjectNode}.type.getChildren(𝓟[ty]2343{ObjectNode});
    𝓟[ty]2343{ObjectNode}._autoUnbox ⟵ 𝓛8744{Boolean};
    return 𝓟2399 = 𝓟2400{res}
  }
  function 𝓟2411{unbox} (𝓟2412{childNode}: [OOV]𝓟[ty]6979{INode}): (𝓟2413: [OOV]any)
  {
    if (𝓟2412{childNode}.AmpersandAmpersandToken(𝓟[ty]2343{ObjectNode}._autoUnbox.EqualsEqualsEqualsToken(𝓛8744{Boolean})))
    {
      return 𝓟2413 = 𝓟2412{childNode}.value
    }
    return 𝓟2413 = 𝓟2412{childNode}
  }
  function 𝓟2422{preboot} (): (𝓟2423: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]2343{ObjectNode}.disposers ⟵ 𝓛8757{Array}();
    𝓟[ty]2343{ObjectNode}.middlewares ⟵ 𝓛8757{Array}();
    𝓟[ty]2343{ObjectNode}.snapshotSubscribers ⟵ 𝓛8757{Array}();
    𝓟[ty]2343{ObjectNode}.patchSubscribers ⟵ 𝓛8757{Array}();
    function 𝓟2424{$Lambda63} (𝓟2425{patches}: 𝓛[ty]8670{Array}): (𝓟2426: [miss]𝓛[ty]10033{Void})
    {
      function 𝓟2427{$Lambda64} (𝓟2428{patch}): (𝓟2429: [miss]𝓛[ty]10033{Void})
      {
        const 𝓟2430{parts}: [miss]𝓛[ty]8670{Array} = 𝓟2684{splitJsonPath}(𝓟2428{patch}.path);
        const 𝓟2431{node}: [OOV]𝓟[ty]6979{INode} = 𝓟719{resolveNodeByPathParts}(𝓟[ty]2343{ObjectNode},𝓟2430{parts}.slice(𝓛8745{Number},𝓛12557{MinusToken}(𝓛8745{Number})));
        𝓟2431{node} as 𝓟[ty]2343{ObjectNode}.applyPatchLocally(𝓟2430{parts}.access(𝓟2430{parts}.length.MinusToken(𝓛8745{Number})),𝓟2428{patch})
      }
      𝓟2425{patches}.forEach(𝓟2427{$Lambda64})
    }
    𝓟[ty]2343{ObjectNode}.applyPatches ⟵ 𝓟191{createActionInvoker}(𝓟[ty]2343{ObjectNode}.storedValue,𝓛8743{String},𝓟2424{$Lambda63}).bind(𝓟[ty]2343{ObjectNode}.storedValue);
    function 𝓟2432{$Lambda65} (𝓟2433{snapshot}: [OOV]any): (𝓟2434: [miss]𝓛[ty]10033{Void})
    {
      if (𝓟2433{snapshot}.EqualsEqualsEqualsToken(𝓟[ty]2343{ObjectNode}.snapshot))
      {
      }
      return 𝓟2434 = 𝓟[ty]2343{ObjectNode}.type.applySnapshot(𝓟[ty]2343{ObjectNode},𝓟2433{snapshot})
    }
    𝓟[ty]2343{ObjectNode}.applySnapshot ⟵ 𝓟191{createActionInvoker}(𝓟[ty]2343{ObjectNode}.storedValue,𝓛8743{String},𝓟2432{$Lambda65}).bind(𝓟[ty]2343{ObjectNode}.storedValue);
  }
  function 𝓟2466{emitPatch} (𝓟2467{basePatch}: [OOV]𝓛[ty]0{ANY},𝓟2468{source}: [OOV]𝓟[ty]6979{INode}): (𝓟2469: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟[ty]2343{ObjectNode}.patchSubscribers.length)
    {
      const 𝓟2470{localizedPatch}: [OOV]𝓛[ty]0{ANY} = 𝓟411{extend}({},𝓟2467{basePatch},{path: 𝓟2468{source}.path.substr(𝓟[ty]2343{ObjectNode}.path.length).PlusToken(𝓛8743{String}).PlusToken(𝓟2467{basePatch}.path)});
      const 𝓟2471{patch}: [OOV]𝓟[ty]6980{IJsonPatch} = 𝓛12552{$ArrayAccess}(𝓟2666{splitPatch}(𝓟2470{localizedPatch}));
      const 𝓟2472{reversePatch}: [OOV]𝓟[ty]6980{IJsonPatch} = 𝓛12552{$ArrayAccess}(𝓟2666{splitPatch}(𝓟2470{localizedPatch}));
      function 𝓟2473{$Lambda70} (𝓟2474{f}): (𝓟2475: [miss]𝓛[ty]10033{Void})
      {
        return 𝓟2475 = 𝓟2474{f}(𝓟2471{patch},𝓟2472{reversePatch})
      }
      𝓟[ty]2343{ObjectNode}.patchSubscribers.forEach(𝓟2473{$Lambda70})
    }
    if (𝓟[ty]2343{ObjectNode}.parent)
    {
      𝓟[ty]2343{ObjectNode}.parent.emitPatch(𝓟2467{basePatch},𝓟2468{source})
    }
  }
  function 𝓟2373{setParent} (𝓟2374{newParent}: [OOV]any,𝓟2375{subpath}: [OOV]any): (𝓟2376: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟[ty]2343{ObjectNode}.parent.EqualsEqualsEqualsToken(𝓟2374{newParent}).AmpersandAmpersandToken(𝓟[ty]2343{ObjectNode}.subpath.EqualsEqualsEqualsToken(𝓟2375{subpath})))
    {
    }
    if (𝓟2374{newParent})
    {
      if (𝓟[ty]2343{ObjectNode}._parent.AmpersandAmpersandToken(𝓟2374{newParent}.ExclamationEqualsEqualsToken(𝓟[ty]2343{ObjectNode}._parent)))
      {
        𝓟376{fail}(𝓛12554{$Template}(𝓟[ty]2343{ObjectNode},𝓟2374{newParent}.path,𝓟2375{subpath}))
      }
      if (𝓛12548{ExclamationToken}(𝓟[ty]2343{ObjectNode}._parent).AmpersandAmpersandToken(𝓟2374{newParent}.root.EqualsEqualsEqualsToken(𝓟[ty]2343{ObjectNode})))
      {
        𝓟376{fail}(𝓛12554{$Template}(𝓟[ty]2343{ObjectNode},𝓟2374{newParent}.path,𝓟2375{subpath}))
      }
      if (𝓛12548{ExclamationToken}(𝓟[ty]2343{ObjectNode}._parent).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓟[ty]2343{ObjectNode}.root._environment))).AmpersandAmpersandToken(𝓟[ty]2343{ObjectNode}.root._environment.ExclamationEqualsEqualsToken(𝓟2374{newParent}.root._environment)))
      {
        𝓟376{fail}(𝓛8743{String})
      }
    }
    if (𝓟[ty]2343{ObjectNode}.parent.AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟2374{newParent})))
    {
      𝓟[ty]2343{ObjectNode}.die()
    }
    else
    {
      𝓟[ty]2343{ObjectNode}.subpath ⟵ 𝓟2375{subpath}.BarBarToken(𝓛8743{String});
      if (𝓟2374{newParent}.AmpersandAmpersandToken(𝓟2374{newParent}.ExclamationEqualsEqualsToken(𝓟[ty]2343{ObjectNode}._parent)))
      {
        𝓟2374{newParent}.root.identifierCache.mergeCache(𝓟[ty]2343{ObjectNode})
        𝓟[ty]2343{ObjectNode}._parent ⟵ 𝓟2374{newParent};
        𝓟[ty]2343{ObjectNode}.fireHook(𝓛8743{String})
      }
    }
  }
  function 𝓟2482{applyPatchLocally} (𝓟2483{subpath}: 𝓛[ty]10051{String},𝓟2484{patch}: [OOV]𝓟[ty]6980{IJsonPatch}): (𝓟2485: 𝓛[ty]10033{Void})
  {
    𝓟[ty]2343{ObjectNode}.assertWritable()
    𝓟[ty]2343{ObjectNode}.type.applyPatchLocally(𝓟[ty]2343{ObjectNode},𝓟2483{subpath},𝓟2484{patch})
  }
  function 𝓟2414{toString} (): (𝓟2415: 𝓛[ty]10051{String})
  {
    const 𝓟2416{identifier}: [miss]𝓛[ty]10051{String} = (𝓟[ty]2343{ObjectNode}.identifier ? 𝓛12554{$Template}(𝓟[ty]2343{ObjectNode}.identifier) : 𝓛8743{String};
    return 𝓟2415 = 𝓛12554{$Template}(𝓟[ty]2343{ObjectNode}.type.name,𝓟[ty]2343{ObjectNode}.path.BarBarToken(𝓛8743{String}),𝓟2416{identifier},(𝓟[ty]2343{ObjectNode}.isAlive ? 𝓛8743{String} : 𝓛8743{String})
  }
  function 𝓟2404{isProtected} (): (𝓟2405: 𝓛[ty]8666{Boolean})
  {
    return 𝓟2405 = 𝓟[ty]2343{ObjectNode}.root.isProtectionEnabled
  }
  function 𝓟2408{removeChild} (𝓟2409{subpath}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10051{String})): (𝓟2410: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]2343{ObjectNode}.type.removeChild(𝓟[ty]2343{ObjectNode},𝓟2409{subpath})
  }
  function 𝓟2386{isRunningAction} (): (𝓟2387: 𝓛[ty]8666{Boolean})
  {
    if (𝓟[ty]2343{ObjectNode}._isRunningAction)
    {
      return 𝓟2387 = 𝓛8744{Boolean}
    }
    if (𝓟[ty]2343{ObjectNode}.isRoot)
    {
      return 𝓟2387 = 𝓛8744{Boolean}
    }
    return 𝓟2387 = 𝓟[ty]2343{ObjectNode}.parent.isRunningAction()
  }
  function 𝓟2406{assertWritable} (): (𝓟2407: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]2343{ObjectNode}.assertAlive()
    if (𝓛12548{ExclamationToken}(𝓟[ty]2343{ObjectNode}.isRunningAction()).AmpersandAmpersandToken(𝓟[ty]2343{ObjectNode}.isProtected))
    {
      𝓟376{fail}(𝓛12554{$Template}(𝓟[ty]2343{ObjectNode}))
    }
  }
  function 𝓟2381{value} (): (𝓟2382: [OOV]any)
  {
    if (𝓛12548{ExclamationToken}(𝓟[ty]2343{ObjectNode}.isAlive))
    {
      return 𝓟2382 = 𝓛12563{undefined}
    }
    return 𝓟2382 = 𝓟[ty]2343{ObjectNode}.type.getValue(𝓟[ty]2343{ObjectNode})
  }
}

Module: packages/mobx-state-tree/src/middlewares/on-action

type 𝓟[ty]6972{ISerializedActionCall} = {name: 𝓛[ty]10051{String}, path: 𝓛[ty]10051{String}, args: 𝓛[ty]8670{Array}}
type 𝓟[ty]6967{IActionRecorder} = {actions: 𝓛[ty]8697{ReadonlyArray}, stop: ()->any, replay: (𝓟[ty]6977{IStateTreeNode})->any}
function 𝓟2488{serializeArgument} (𝓟2489{node}: [OOV]𝓟[ty]6979{INode},𝓟2490{actionName}: 𝓛[ty]10051{String},𝓟2491{index}: 𝓛[ty]8655{Number},𝓟2492{arg}: [OOV]any): (𝓟2493: [OOV]any)
{
  if (𝓟2492{arg}.InstanceOfKeyword(𝓛8747{Date}))
  {
    return 𝓟2493 = {$MST_DATE: 𝓟2492{arg}.getTime()}
  }
  if (𝓟452{isPrimitive}(𝓟2492{arg}))
  {
    return 𝓟2493 = 𝓟2492{arg}
  }
  if (𝓟673{isStateTreeNode}(𝓟2492{arg}))
  {
    return 𝓟2493 = 𝓟2498{serializeTheUnserializable}(𝓛12554{$Template}(𝓟511{getType}(𝓟2492{arg}).name))
  }
  if (𝓛12550{$TypeOf}(𝓟2492{arg}).EqualsEqualsEqualsToken(𝓛8743{String}))
  {
    return 𝓟2493 = 𝓟2498{serializeTheUnserializable}(𝓛8743{String})
  }
  if (𝓛12550{$TypeOf}(𝓟2492{arg}).EqualsEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟445{isPlainObject}(𝓟2492{arg}))).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟386{isArray}(𝓟2492{arg}))))
  {
    return 𝓟2493 = 𝓟2498{serializeTheUnserializable}(𝓛12554{$Template}(𝓟2492{arg}.AmpersandAmpersandToken(𝓟2492{arg}.constructor).AmpersandAmpersandToken(𝓟2492{arg}.constructor.name).BarBarToken(𝓛8743{String})))
  }
  {
    𝓛8756{JSON}.stringify(𝓟2492{arg})
    return 𝓟2493 = 𝓟2492{arg}
  }
}
function 𝓟2494{deserializeArgument} (𝓟2495{adm}: [OOV]𝓟[ty]6979{INode},𝓟2496{value}: [OOV]any): (𝓟2497: [OOV]any)
{
  if (𝓟2496{value}.AmpersandAmpersandToken(𝓛12550{$TypeOf}(𝓟2496{value}).EqualsEqualsEqualsToken(𝓛8743{String})).AmpersandAmpersandToken(𝓛8743{String}.InKeyword(𝓟2496{value})))
  {
    return 𝓟2497 = 𝓛8747{Date}.CONSTRUCTOR(𝓟2496{value}.access(𝓛8743{String}))
  }
  return 𝓟2497 = 𝓟2496{value}
}
function 𝓟2498{serializeTheUnserializable} (𝓟2499{baseType}: 𝓛[ty]10051{String}): (𝓟2500: [miss]𝓛[ty]8642{Object})
{
  return 𝓟2500 = {$MST_UNSERIALIZABLE: 𝓛8744{Boolean},type: 𝓟2499{baseType}}
}
function 𝓟2501{applyAction} (𝓟2502{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟2503{actions}: [OOV]any): (𝓟2504: 𝓛[ty]10033{Void})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟2502{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟2502{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12550{$TypeOf}(𝓟2503{actions}).ExclamationEqualsEqualsToken(𝓛8743{String}))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟2503{actions}).PlusToken(𝓛8743{String}))
    }
  }
  function 𝓟2505{$Lambda40} (): (𝓟2506: [miss]𝓛[ty]10033{Void})
  {
    function 𝓟2507{$Lambda41} (𝓟2508{action}): (𝓟2509: [OOV]any)
    {
      return 𝓟2509 = 𝓟2510{baseApplyAction}(𝓟2502{target},𝓟2508{action})
    }
    𝓟389{asArray}(𝓟2503{actions}).forEach(𝓟2507{$Lambda41})
  }
  𝓟2847{runInAction}(𝓟2505{$Lambda40})
}
function 𝓟2510{baseApplyAction} (𝓟2511{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟2512{action}: [OOV]𝓟[ty]6972{ISerializedActionCall}): (𝓟2513: [OOV]any)
{
  const 𝓟2514{resolvedTarget} = 𝓟628{tryResolve}(𝓟2511{target},𝓟2512{action}.path.BarBarToken(𝓛8743{String}));
  if (𝓛12548{ExclamationToken}(𝓟2514{resolvedTarget}))
  {
    return 𝓟2513 = 𝓟376{fail}(𝓛12554{$Template}(𝓟2512{action}.path.BarBarToken(𝓛8743{String})))
  }
  const 𝓟2515{node}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟676{getStateTreeNode}(𝓟2514{resolvedTarget});
  if (𝓟2512{action}.name.EqualsEqualsEqualsToken(𝓛8743{String}))
  {
    return 𝓟2513 = 𝓟538{applyPatch}.call(𝓛12563{undefined},𝓟2514{resolvedTarget},𝓟2512{action}.args.access(𝓛8745{Number}))
  }
  if (𝓟2512{action}.name.EqualsEqualsEqualsToken(𝓛8743{String}))
  {
    return 𝓟2513 = 𝓟564{applySnapshot}.call(𝓛12563{undefined},𝓟2514{resolvedTarget},𝓟2512{action}.args.access(𝓛8745{Number}))
  }
  if (𝓛12548{ExclamationToken}(𝓛12550{$TypeOf}(𝓟2514{resolvedTarget}.access(𝓟2512{action}.name)).EqualsEqualsEqualsToken(𝓛8743{String})))
  {
    𝓟376{fail}(𝓛12554{$Template}(𝓟2512{action}.name,𝓟2515{node}.path))
  }
  function 𝓟2516{$Lambda42} (𝓟2517{v}): (𝓟2518: [OOV]any)
  {
    return 𝓟2518 = 𝓟2494{deserializeArgument}(𝓟2515{node},𝓟2517{v})
  }
  return 𝓟2513 = 𝓟2514{resolvedTarget}.access(𝓟2512{action}.name).apply(𝓟2514{resolvedTarget},(𝓟2512{action}.args ? 𝓟2512{action}.args.map(𝓟2516{$Lambda42}) : 𝓛8757{Array}())
}
function 𝓟2519{recordActions} (𝓟2520{subject}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟2521: [OOV]𝓟[ty]6967{IActionRecorder})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟2520{subject})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟2520{subject}).PlusToken(𝓛8743{String}))
    }
  }
  function 𝓟2522{$Lambda43} (): (𝓟2523: [miss]𝓛[ty]10033{Void})
  {
    return 𝓟2523 = 𝓟2528{disposer}()
  }
  function 𝓟2524{$Lambda44} (𝓟2525{target}: [OOV]𝓟[ty]6977{IStateTreeNode}): (𝓟2526: [miss]𝓛[ty]10033{Void})
  {
    𝓟2501{applyAction}(𝓟2525{target},𝓟2527{recorder}.actions)
  }
  let 𝓟2527{recorder}: [miss]𝓛[ty]8642{Object} = {actions: 𝓛8757{Array}() as 𝓛[ty]8670{Array},stop: 𝓟2522{$Lambda43},replay: 𝓟2524{$Lambda44}};
  let 𝓟2528{disposer}: [OOV]𝓟[ty]6974{IDisposer} = 𝓟2529{onAction}(𝓟2520{subject},𝓟2527{recorder}.actions.push.bind(𝓟2527{recorder}.actions));
  return 𝓟2521 = 𝓟2527{recorder}
}
function 𝓟2529{onAction} (𝓟2530{target}: [OOV]𝓟[ty]6977{IStateTreeNode},𝓟2531{listener}: 𝓛[ty]8696{Function},𝓟2532{attachAfter}): (𝓟2533: [OOV]𝓟[ty]6974{IDisposer})
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟2530{target})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟2530{target}).PlusToken(𝓛8743{String}))
    }
    if (𝓛12548{ExclamationToken}(𝓟614{isRoot}(𝓟2530{target})))
    {
      𝓛1{<UNKNOWN>}(𝓛8743{String})
    }
    if (𝓛12548{ExclamationToken}(𝓟561{isProtected}(𝓟2530{target})))
    {
      𝓛1{<UNKNOWN>}(𝓛8743{String})
    }
  }
  function 𝓟2534{fireListener} (𝓟2535{rawCall}: [OOV]𝓟[ty]6976{IMiddlewareEvent}): (𝓟2536: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟2535{rawCall}.type.EqualsEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓟2535{rawCall}.id.EqualsEqualsEqualsToken(𝓟2535{rawCall}.rootId)))
    {
      const 𝓟2537{sourceNode}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟676{getStateTreeNode}(𝓟2535{rawCall}.context);
      function 𝓟2538{$Lambda45} (𝓟2539{arg}: [OOV]any,𝓟2540{index}: 𝓛[ty]8655{Number}): (𝓟2541: [OOV]any)
      {
        return 𝓟2541 = 𝓟2488{serializeArgument}(𝓟2537{sourceNode},𝓟2535{rawCall}.name,𝓟2540{index},𝓟2539{arg})
      }
      𝓟2531{listener}({name: 𝓟2535{rawCall}.name,path: 𝓟689{getRelativePathBetweenNodes}(𝓟676{getStateTreeNode}(𝓟2530{target}),𝓟2537{sourceNode}),args: 𝓟2535{rawCall}.args.map(𝓟2538{$Lambda45})})
    }
  }
  function 𝓟2542{onActionMiddleware} (𝓟2543{rawCall},𝓟2544{next}): (𝓟2545: [OOV]any)
  {
    const 𝓟2546{res} = 𝓟2544{next}(𝓟2543{rawCall});
    𝓟2534{fireListener}(𝓟2543{rawCall})
    return 𝓟2545 = 𝓟2546{res}
  }
  function 𝓟2547{onActionMiddleware} (𝓟2548{rawCall},𝓟2549{next}): (𝓟2550: [OOV]any)
  {
    𝓟2534{fireListener}(𝓟2548{rawCall})
    return 𝓟2550 = 𝓟2549{next}(𝓟2548{rawCall})
  }
  return 𝓟2533 = 𝓟199{addMiddleware}(𝓟2530{target},(𝓟2532{attachAfter} ? 𝓟2547{onActionMiddleware} : 𝓟2547{onActionMiddleware})
}

Module: packages/mobx-state-tree/src/types/utility-types/reference

type 𝓟[ty]6971{ReferenceOptions} = {get: (any,any)->any, set: (any,any)->any}
function 𝓟2567{CONSTRUCTOR} (𝓟2568{mode}: [OOV]any,𝓟2569{value}: [OOV]any): (𝓟[ty]2574{StoredReference})
{
  const 𝓟[ty]2574{StoredReference};
  const 𝓟[ty]2574{StoredReference};
  𝓟[ty]2574{StoredReference}.value ⟵ 𝓟2569{value};
  𝓟[ty]2574{StoredReference}.mode ⟵ 𝓟2568{mode};
  if (𝓟2568{mode}.EqualsEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟2569{value})))
    {
      return 𝓟[ty]2574{StoredReference} = 𝓟376{fail}(𝓛12554{$Template}(𝓟2569{value}))
    }
    const 𝓟2573{targetNode}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟2569{value});
    if (𝓛12548{ExclamationToken}(𝓟2573{targetNode}.identifierAttribute))
    {
      return 𝓟[ty]2574{StoredReference} = 𝓟376{fail}(𝓛8743{String})
    }
  }
}
class 𝓟[ty]2574{StoredReference}{
  𝓟2576{mode}: [OOV]any;
  𝓟2577{value}: [OOV]any;
}
function 𝓟2578{CONSTRUCTOR} (𝓟2579{targetType}: [OOV]𝓟[ty]6960{IType}): (𝓟[ty]2583{BaseReferenceType})
{
  const 𝓟[ty]2583{BaseReferenceType};
  const 𝓟[ty]2583{BaseReferenceType};
  𝓟[ty]2583{BaseReferenceType}.flags ⟵ 𝓟2693{TypeFlags}.Reference;
  𝓟[ty]2583{BaseReferenceType}(𝓛12554{$Template}(𝓟2579{targetType}.name))
}
class 𝓟[ty]2583{BaseReferenceType} extends 𝓟[ty]2778{Type}{
  𝓟2585{flags}: [miss]𝓛[ty]8655{Number};
  function 𝓟2586{describe} (): (𝓟2587: [miss]𝓛[ty]10051{String})
  {
    return 𝓟2587 = 𝓟[ty]2583{BaseReferenceType}.name
  }
  function 𝓟2588{isAssignableFrom} (𝓟2589{type}: [OOV]𝓟[ty]6960{IType}): (𝓟2590: 𝓛[ty]8666{Boolean})
  {
    return 𝓟2590 = 𝓟[ty]2583{BaseReferenceType}.targetType.isAssignableFrom(𝓟2589{type})
  }
  function 𝓟2591{isValidSnapshot} (𝓟2592{value}: [OOV]any,𝓟2593{context}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟2594: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
  {
    return 𝓟2594 = (𝓛12550{$TypeOf}(𝓟2592{value}).EqualsEqualsEqualsToken(𝓛8743{String}).BarBarToken(𝓛12550{$TypeOf}(𝓟2592{value}).EqualsEqualsEqualsToken(𝓛8743{String})) ? 𝓟1317{typeCheckSuccess}() : 𝓟1319{typeCheckFailure}(𝓟2593{context},𝓟2592{value},𝓛8743{String})
  }
}
function 𝓟2595{CONSTRUCTOR} (𝓟2596{targetType}: [OOV]𝓟[ty]6960{IType}): (𝓟[ty]2600{IdentifierReferenceType})
{
  const 𝓟[ty]2600{IdentifierReferenceType};
  const 𝓟[ty]2600{IdentifierReferenceType};
  𝓟[ty]2600{IdentifierReferenceType}.shouldAttachNode ⟵ 𝓛8744{Boolean};
  𝓟[ty]2600{IdentifierReferenceType}(𝓟2596{targetType})
}
class 𝓟[ty]2600{IdentifierReferenceType} extends 𝓟[ty]2583{BaseReferenceType}{
  𝓟2602{shouldAttachNode}: [miss]𝓛[ty]8666{Boolean};
  function 𝓟2603{getValue} (𝓟2604{node}: [OOV]𝓟[ty]6979{INode}): (𝓟2605: [OOV]any)
  {
    if (𝓛12548{ExclamationToken}(𝓟2604{node}.isAlive))
    {
      return 𝓟2605 = 𝓛12563{undefined}
    }
    const 𝓟2606{ref}: [OOV]𝓟[ty]2574{StoredReference} = 𝓟2604{node}.storedValue as 𝓟[ty]2574{StoredReference};
    if (𝓟2606{ref}.mode.EqualsEqualsEqualsToken(𝓛8743{String}))
    {
      return 𝓟2605 = 𝓟2606{ref}.value
    }
    const 𝓟2607{target}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟2604{node}.root.identifierCache.resolve(𝓟[ty]2600{IdentifierReferenceType}.targetType,𝓟2606{ref}.value);
    if (𝓛12548{ExclamationToken}(𝓟2607{target}))
    {
      return 𝓟2605 = 𝓟376{fail}(𝓛12554{$Template}(𝓟[ty]2600{IdentifierReferenceType}.targetType.name,𝓟2606{ref}.value,𝓟2604{node}.path))
    }
    return 𝓟2605 = 𝓟2607{target}.value
  }
  function 𝓟2608{getSnapshot} (𝓟2609{node}: [OOV]𝓟[ty]6979{INode}): (𝓟2610: [OOV]any)
  {
    const 𝓟2611{ref}: [OOV]𝓟[ty]2574{StoredReference} = 𝓟2609{node}.storedValue as 𝓟[ty]2574{StoredReference};
    𝓛12549{$Switch}(𝓟2611{ref}.mode)
    𝓛12561{$Case}(𝓛8743{String})
    return 𝓟2610 = 𝓟2611{ref}.value
    𝓛12561{$Case}(𝓛8743{String})
    return 𝓟2610 = 𝓟676{getStateTreeNode}(𝓟2611{ref}.value).identifier
  }
  function 𝓟2612{instantiate} (𝓟2613{parent}: [OOV]any,𝓟2614{subpath}: 𝓛[ty]10051{String},𝓟2615{environment}: [OOV]any,𝓟2616{snapshot}: [OOV]any): (𝓟2617: [OOV]𝓟[ty]6979{INode})
  {
    return 𝓟2617 = 𝓟2551{createNode}(𝓟[ty]2600{IdentifierReferenceType},𝓟2613{parent},𝓟2614{subpath},𝓟2615{environment},𝓟2567{CONSTRUCTOR}((𝓟673{isStateTreeNode}(𝓟2616{snapshot}) ? 𝓛8743{String} : 𝓛8743{String},𝓟2616{snapshot}))
  }
  function 𝓟2618{reconcile} (𝓟2619{current}: [OOV]𝓟[ty]6979{INode},𝓟2620{newValue}: [OOV]any): (𝓟2621: [OOV]𝓟[ty]6979{INode})
  {
    if (𝓟2619{current}.type.EqualsEqualsEqualsToken(𝓟[ty]2600{IdentifierReferenceType}))
    {
      const 𝓟2622{targetMode} = (𝓟673{isStateTreeNode}(𝓟2620{newValue}) ? 𝓛8743{String} : 𝓛8743{String};
      const 𝓟2623{ref}: [OOV]𝓟[ty]2574{StoredReference} = 𝓟2619{current}.storedValue as 𝓟[ty]2574{StoredReference};
      if (𝓟2622{targetMode}.EqualsEqualsEqualsToken(𝓟2623{ref}.mode).AmpersandAmpersandToken(𝓟2623{ref}.value.EqualsEqualsEqualsToken(𝓟2620{newValue})))
      {
        return 𝓟2621 = 𝓟2619{current}
      }
    }
    const 𝓟2624{newNode}: [OOV]𝓟[ty]6979{INode} = 𝓟[ty]2600{IdentifierReferenceType}.instantiate(𝓟2619{current}.parent,𝓟2619{current}.subpath,𝓟2619{current}._environment,𝓟2620{newValue});
    𝓟2619{current}.die()
    return 𝓟2621 = 𝓟2624{newNode}
  }
}
function 𝓟2625{CONSTRUCTOR} (𝓟2626{targetType}: [OOV]𝓟[ty]6960{IType},𝓟2627{options}: [OOV]𝓟[ty]6971{ReferenceOptions}): (𝓟[ty]2631{CustomReferenceType})
{
  const 𝓟[ty]2631{CustomReferenceType};
  const 𝓟[ty]2631{CustomReferenceType};
  𝓟[ty]2631{CustomReferenceType}.shouldAttachNode ⟵ 𝓛8744{Boolean};
  𝓟[ty]2631{CustomReferenceType}(𝓟2626{targetType})
}
class 𝓟[ty]2631{CustomReferenceType} extends 𝓟[ty]2583{BaseReferenceType}{
  𝓟2633{shouldAttachNode}: [miss]𝓛[ty]8666{Boolean};
  function 𝓟2634{getValue} (𝓟2635{node}: [OOV]𝓟[ty]6979{INode}): (𝓟2636: [OOV]any)
  {
    if (𝓛12548{ExclamationToken}(𝓟2635{node}.isAlive))
    {
      return 𝓟2636 = 𝓛12563{undefined}
    }
    return 𝓟2636 = 𝓟[ty]2631{CustomReferenceType}.options.get(𝓟2635{node}.storedValue,(𝓟2635{node}.parent ? 𝓟2635{node}.parent.storedValue : 𝓛12563{undefined})
  }
  function 𝓟2637{getSnapshot} (𝓟2638{node}: [OOV]𝓟[ty]6979{INode}): (𝓟2639: [OOV]any)
  {
    return 𝓟2639 = 𝓟2638{node}.storedValue
  }
  function 𝓟2640{instantiate} (𝓟2641{parent}: [OOV]any,𝓟2642{subpath}: 𝓛[ty]10051{String},𝓟2643{environment}: [OOV]any,𝓟2644{snapshot}: [OOV]any): (𝓟2645: [OOV]𝓟[ty]6979{INode})
  {
    const 𝓟2646{identifier} = (𝓟673{isStateTreeNode}(𝓟2644{snapshot}) ? 𝓟[ty]2631{CustomReferenceType}.options.set(𝓟2644{snapshot} as 𝓛[ty]2{<UNKNOWN>},(𝓟2641{parent} ? 𝓟2641{parent}.storedValue : 𝓛12563{undefined}) : 𝓟2644{snapshot};
    return 𝓟2645 = 𝓟2551{createNode}(𝓟[ty]2631{CustomReferenceType},𝓟2641{parent},𝓟2642{subpath},𝓟2643{environment},𝓟2646{identifier})
  }
  function 𝓟2647{reconcile} (𝓟2648{current}: [OOV]𝓟[ty]6979{INode},𝓟2649{snapshot}: [OOV]any): (𝓟2650: [OOV]𝓟[ty]6979{INode})
  {
    const 𝓟2651{newIdentifier} = (𝓟673{isStateTreeNode}(𝓟2649{snapshot}) ? 𝓟[ty]2631{CustomReferenceType}.options.set(𝓟2649{snapshot} as 𝓛[ty]2{<UNKNOWN>},(𝓟2648{current} ? 𝓟2648{current}.storedValue : 𝓛12563{undefined}) : 𝓟2649{snapshot};
    if (𝓟2648{current}.type.EqualsEqualsEqualsToken(𝓟[ty]2631{CustomReferenceType}))
    {
      if (𝓟2648{current}.storedValue.EqualsEqualsEqualsToken(𝓟2651{newIdentifier}))
      {
        return 𝓟2650 = 𝓟2648{current}
      }
    }
    const 𝓟2652{newNode}: [OOV]𝓟[ty]6979{INode} = 𝓟[ty]2631{CustomReferenceType}.instantiate(𝓟2648{current}.parent,𝓟2648{current}.subpath,𝓟2648{current}._environment,𝓟2651{newIdentifier});
    𝓟2648{current}.die()
    return 𝓟2650 = 𝓟2652{newNode}
  }
}
function 𝓟2653{reference} (𝓟2654{factory}: [OOV]𝓟[ty]6960{IType},𝓟2655{options}: [OOV]𝓟[ty]6971{ReferenceOptions}): (𝓟2656: [OOV]𝓟[ty]6960{IType})
{
}
function 𝓟2657{reference} (𝓟2658{subType}: [OOV]𝓟[ty]6960{IType},𝓟2659{options}: [OOV]𝓟[ty]6971{ReferenceOptions}): (𝓟2660: [OOV]any)
{
  if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
  {
    if (𝓛12548{ExclamationToken}(𝓟2822{isType}(𝓟2658{subType})))
    {
      𝓟376{fail}(𝓛8743{String}.PlusToken(𝓟2658{subType}).PlusToken(𝓛8743{String}))
    }
    if (𝓛10035{arguments}.length.EqualsEqualsEqualsToken(𝓛8745{Number}).AmpersandAmpersandToken(𝓛12550{$TypeOf}(𝓛10035{arguments}.access(𝓛8745{Number})).EqualsEqualsEqualsToken(𝓛8743{String})))
    {
      𝓟376{fail}(𝓛8743{String})
    }
  }
  if (𝓟2659{options})
  {
    return 𝓟2660 = 𝓟2625{CONSTRUCTOR}(𝓟2658{subType},𝓟2659{options})
  }
  else
  {
    return 𝓟2660 = 𝓟2595{CONSTRUCTOR}(𝓟2658{subType})
  }
}
function 𝓟2661{isReferenceType} (𝓟2662{type}: [OOV]any): (𝓟2663: 𝓛[ty]8666{Boolean})
{
  return 𝓟2663 = 𝓟2662{type}.flags.AmpersandToken(𝓟2693{TypeFlags}.Reference).GreaterThanToken(𝓛8745{Number})
}

Module: packages/mobx-state-tree/src/core/type/type

type 𝓟[ty]6944{ISnapshottable} extends 𝓟[ty]6960{IType} = {}
type 𝓟[ty]6944{ISnapshottable} = {}
type 𝓛[ty]8655{Number} = 𝓛[ty]8655{Number}
type 𝓟[ty]6960{IType} = {name: 𝓛[ty]10051{String}, is: (any)->𝓛[ty]8666{Boolean}, flags: 𝓛[ty]8655{Number}, applySnapshot: (𝓟[ty]6979{INode},any)->𝓛[ty]10033{Void}, getSnapshot: (𝓟[ty]6979{INode})->any, validate: (any,𝓛[ty]8670{Array})->𝓛[ty]8670{Array}, create: (any,any)->any, isType: 𝓛[ty]8666{Boolean}, describe: ()->𝓛[ty]10051{String}, SnapshotType: any, instantiate: (any,𝓛[ty]10051{String},any,any)->𝓟[ty]6979{INode}, getChildNode: (𝓟[ty]6979{INode},𝓛[ty]10051{String})->𝓟[ty]6979{INode}, getChildType: (𝓛[ty]10051{String})->𝓟[ty]6960{IType}, getChildren: (𝓟[ty]6979{INode})->𝓛[ty]8670{Array}, applyPatchLocally: (𝓟[ty]6979{INode},𝓛[ty]10051{String},𝓟[ty]6980{IJsonPatch})->𝓛[ty]10033{Void}, reconcile: (𝓟[ty]6979{INode},any)->𝓟[ty]6979{INode}, removeChild: (𝓟[ty]6979{INode},𝓛[ty]10051{String})->𝓛[ty]10033{Void}, getValue: (𝓟[ty]6979{INode})->any, isAssignableFrom: (𝓟[ty]6960{IType})->𝓛[ty]8666{Boolean}, shouldAttachNode: 𝓛[ty]8666{Boolean}, Type: any}
type 𝓟[ty]6970{IComplexType} extends 𝓟[ty]6960{IType} = {create: (any,any)->any}
const 𝓟2693{TypeFlags} = {Optional: 𝓛8745{Number},Number: 𝓛8745{Number},Undefined: 𝓛8745{Number},Boolean: 𝓛8745{Number},Literal: 𝓛8745{Number},Array: 𝓛8745{Number},Late: 𝓛8745{Number},Map: 𝓛8745{Number},Reference: 𝓛8745{Number},Object: 𝓛8745{Number},Refinement: 𝓛8745{Number},Null: 𝓛8745{Number},Identifier: 𝓛8745{Number},Date: 𝓛8745{Number},Union: 𝓛8745{Number},Frozen: 𝓛8745{Number},String: 𝓛8745{Number}};
function 𝓟2694{CONSTRUCTOR} (𝓟2695{name}: 𝓛[ty]10051{String}): (𝓟[ty]2699{ComplexType})
{
  const 𝓟[ty]2699{ComplexType};
  const 𝓟[ty]2699{ComplexType};
  𝓟[ty]2699{ComplexType}.isType ⟵ 𝓛8744{Boolean};
  𝓟[ty]2699{ComplexType}.name ⟵ 𝓟2695{name};
}
class 𝓟[ty]2699{ComplexType} extends 𝓟[ty]6960{IType}{
  𝓟2701{isType}: [miss]𝓛[ty]8666{Boolean};
  𝓟2702{name}: 𝓛[ty]10051{String};
  𝓟2703{flags}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8655{Number});
  𝓟2704{shouldAttachNode}: 𝓛[ty]8666{Boolean};
  function 𝓟2759{is} (𝓟2760{value}: [OOV]any): (𝓟2761: 𝓛[ty]8666{Boolean})
  {
    return 𝓟2761 = 𝓟[ty]2699{ComplexType}.validate(𝓟2760{value},𝓛8757{Array}({path: 𝓛8743{String},type: 𝓟[ty]2699{ComplexType}})).length.EqualsEqualsEqualsToken(𝓛8745{Number})
  }
  function 𝓟2717{applySnapshot} (𝓟2718{node}: [OOV]𝓟[ty]6979{INode},𝓟2719{snapshot}: [OOV]any): (𝓟2720: 𝓛[ty]10033{Void})
  {
  }
  function 𝓟2733{getSnapshot} (𝓟2734{node}: [OOV]𝓟[ty]6979{INode}): (𝓟2735: [OOV]any)
  {
  }
  function 𝓟2755{validate} (𝓟2756{value}: [OOV]any,𝓟2757{context}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array})): (𝓟2758: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
  {
    if (𝓟673{isStateTreeNode}(𝓟2756{value}))
    {
      return 𝓟2758 = (𝓟511{getType}(𝓟2756{value}).EqualsEqualsEqualsToken(𝓟[ty]2699{ComplexType}).BarBarToken(𝓟[ty]2699{ComplexType}.isAssignableFrom(𝓟511{getType}(𝓟2756{value}))) ? 𝓟1317{typeCheckSuccess}() : 𝓟1319{typeCheckFailure}(𝓟2757{context},𝓟2756{value})
    }
    return 𝓟2758 = 𝓟[ty]2699{ComplexType}.isValidSnapshot(𝓟2756{value},𝓟2757{context})
  }
  function 𝓟2705{create} (𝓟2706{snapshot}: [OOV]any,𝓟2707{environment}: [OOV]any): (𝓟2708: [OOV]any)
  {
    𝓟1331{typecheck}(𝓟[ty]2699{ComplexType},𝓟2706{snapshot})
    return 𝓟2708 = 𝓟[ty]2699{ComplexType}.instantiate(𝓛12563{undefined},𝓛8743{String},𝓟2707{environment},𝓟2706{snapshot}).value
  }
  function 𝓟2715{describe} (): (𝓟2716: (𝓛[ty]10033{Void} ≠ 𝓛[ty]10051{String}))
  {
  }
  function 𝓟2771{SnapshotType} (): (𝓟2772: [OOV]any)
  {
    return 𝓟2772 = 𝓟376{fail}(𝓛8743{String})
  }
  function 𝓟2709{instantiate} (𝓟2710{parent}: [OOV]any,𝓟2711{subpath}: 𝓛[ty]10051{String},𝓟2712{environment}: [OOV]any,𝓟2713{initialValue}: [OOV]any): (𝓟2714: [OOV]𝓟[ty]6979{INode})
  {
  }
  function 𝓟2726{getChildNode} (𝓟2727{node}: [OOV]𝓟[ty]6979{INode},𝓟2728{key}: 𝓛[ty]10051{String}): (𝓟2729: [OOV]𝓟[ty]6979{INode})
  {
  }
  function 𝓟2741{getChildType} (𝓟2742{key}: 𝓛[ty]10051{String}): (𝓟2743: [OOV]𝓟[ty]6960{IType})
  {
  }
  function 𝓟2748{isValidSnapshot} (𝓟2749{value}: [OOV]any,𝓟2750{context}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array})): (𝓟2751: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8670{Array}))
  {
  }
  function 𝓟2723{getChildren} (𝓟2724{node}: [OOV]𝓟[ty]6979{INode}): (𝓟2725: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8670{Array}))
  {
  }
  function 𝓟2736{applyPatchLocally} (𝓟2737{node}: [OOV]𝓟[ty]6979{INode},𝓟2738{subpath}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10051{String}),𝓟2739{patch}: [OOV]𝓟[ty]6980{IJsonPatch}): (𝓟2740: 𝓛[ty]10033{Void})
  {
  }
  function 𝓟2762{reconcile} (𝓟2763{current}: [OOV]𝓟[ty]2343{ObjectNode},𝓟2764{newValue}: [OOV]any): (𝓟2765: [OOV]𝓟[ty]6979{INode})
  {
    if (𝓟2763{current}.snapshot.EqualsEqualsEqualsToken(𝓟2764{newValue}))
    {
      return 𝓟2765 = 𝓟2763{current}
    }
    if (𝓟673{isStateTreeNode}(𝓟2764{newValue}).AmpersandAmpersandToken(𝓟676{getStateTreeNode}(𝓟2764{newValue}).EqualsEqualsEqualsToken(𝓟2763{current})))
    {
      return 𝓟2765 = 𝓟2763{current}
    }
    if (𝓟2763{current}.type.EqualsEqualsEqualsToken(𝓟[ty]2699{ComplexType}).AmpersandAmpersandToken(𝓟449{isMutable}(𝓟2764{newValue})).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟673{isStateTreeNode}(𝓟2764{newValue}))).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟2763{current}.identifierAttribute).BarBarToken(𝓟2763{current}.identifier.EqualsEqualsEqualsToken(𝓟2764{newValue}.access(𝓟2763{current}.identifierAttribute)))))
    {
      𝓟2763{current}.applySnapshot(𝓟2764{newValue})
      return 𝓟2765 = 𝓟2763{current}
    }
    const 𝓟2766{parent}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟2763{current}.parent;
    const 𝓟2767{subpath}: [miss]𝓛[ty]10051{String} = 𝓟2763{current}.subpath;
    𝓟2763{current}.die()
    if (𝓟673{isStateTreeNode}(𝓟2764{newValue}).AmpersandAmpersandToken(𝓟[ty]2699{ComplexType}.isAssignableFrom(𝓟511{getType}(𝓟2764{newValue}))))
    {
      const 𝓟2768{newNode}: [OOV]𝓟[ty]2343{ObjectNode} = 𝓟676{getStateTreeNode}(𝓟2764{newValue});
      𝓟2768{newNode}.setParent(𝓟2766{parent},𝓟2767{subpath})
      return 𝓟2765 = 𝓟2768{newNode}
    }
    return 𝓟2765 = 𝓟[ty]2699{ComplexType}.instantiate(𝓟2766{parent},𝓟2767{subpath},𝓟2763{current}._environment,𝓟2764{newValue})
  }
  function 𝓟2744{removeChild} (𝓟2745{node}: [OOV]𝓟[ty]6979{INode},𝓟2746{subpath}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10051{String})): (𝓟2747: 𝓛[ty]10033{Void})
  {
  }
  function 𝓟2730{getValue} (𝓟2731{node}: [OOV]𝓟[ty]6979{INode}): (𝓟2732: [OOV]any)
  {
  }
  function 𝓟2752{isAssignableFrom} (𝓟2753{type}: [OOV]𝓟[ty]6960{IType}): (𝓟2754: 𝓛[ty]8666{Boolean})
  {
    return 𝓟2754 = 𝓟2753{type}.EqualsEqualsEqualsToken(𝓟[ty]2699{ComplexType})
  }
  function 𝓟2721{getDefaultSnapshot} (): (𝓟2722: [OOV]any)
  {
  }
  function 𝓟2769{Type} (): (𝓟2770: [OOV]any)
  {
    return 𝓟2770 = 𝓟376{fail}(𝓛8743{String})
  }
}
function 𝓟2773{CONSTRUCTOR} (𝓟2774{name}: 𝓛[ty]10051{String}): (𝓟[ty]2778{Type})
{
  const 𝓟[ty]2778{Type};
  const 𝓟[ty]2778{Type};
  𝓟[ty]2778{Type}(𝓟2774{name})
}
class 𝓟[ty]2778{Type} extends 𝓟[ty]2699{ComplexType} with 𝓟[ty]6960{IType}{
  function 𝓟2794{applySnapshot} (𝓟2795{node}: [OOV]𝓟[ty]6979{INode},𝓟2796{snapshot}: [OOV]any): (𝓟2797: 𝓛[ty]10033{Void})
  {
    𝓟376{fail}(𝓛8743{String})
  }
  function 𝓟2789{getSnapshot} (𝓟2790{node}: [OOV]𝓟[ty]6979{INode}): (𝓟2791: [OOV]any)
  {
    return 𝓟2791 = 𝓟2790{node}.storedValue
  }
  function 𝓟2780{instantiate} (𝓟2781{parent}: [OOV]any,𝓟2782{subpath}: 𝓛[ty]10051{String},𝓟2783{environment}: [OOV]any,𝓟2784{initialValue}: [OOV]any): (𝓟2785: [OOV]𝓟[ty]6979{INode})
  {
  }
  function 𝓟2806{getChildNode} (𝓟2807{node}: [OOV]𝓟[ty]6979{INode},𝓟2808{key}: 𝓛[ty]10051{String}): (𝓟2809: [OOV]𝓟[ty]6979{INode})
  {
    return 𝓟2809 = 𝓟376{fail}(𝓛12554{$Template}(𝓟2808{key},𝓟[ty]2778{Type}.name))
  }
  function 𝓟2810{getChildType} (𝓟2811{key}: 𝓛[ty]10051{String}): (𝓟2812: [OOV]𝓟[ty]6960{IType})
  {
    return 𝓟2812 = 𝓟376{fail}(𝓛12554{$Template}(𝓟2811{key},𝓟[ty]2778{Type}.name))
  }
  function 𝓟2803{getChildren} (𝓟2804{node}: [OOV]𝓟[ty]6979{INode}): (𝓟2805: (𝓛[ty]8654{Promise} ≠ 𝓛[ty]8670{Array}))
  {
    return 𝓟2805 = 𝓟374{EMPTY_ARRAY} as any
  }
  function 𝓟2798{applyPatchLocally} (𝓟2799{node}: [OOV]𝓟[ty]6979{INode},𝓟2800{subpath}: 𝓛[ty]10051{String},𝓟2801{patch}: [OOV]𝓟[ty]6980{IJsonPatch}): (𝓟2802: 𝓛[ty]10033{Void})
  {
    𝓟376{fail}(𝓛8743{String})
  }
  function 𝓟2813{reconcile} (𝓟2814{current}: [OOV]𝓟[ty]6979{INode},𝓟2815{newValue}: [OOV]any): (𝓟2816: [OOV]𝓟[ty]6979{INode})
  {
    if (𝓟2814{current}.type.EqualsEqualsEqualsToken(𝓟[ty]2778{Type}).AmpersandAmpersandToken(𝓟2814{current}.storedValue.EqualsEqualsEqualsToken(𝓟2815{newValue})))
    {
      return 𝓟2816 = 𝓟2814{current}
    }
    const 𝓟2817{res}: [OOV]𝓟[ty]6979{INode} = 𝓟[ty]2778{Type}.instantiate(𝓟2814{current}.parent,𝓟2814{current}.subpath,𝓟2814{current}._environment,𝓟2815{newValue});
    𝓟2814{current}.die()
    return 𝓟2816 = 𝓟2817{res}
  }
  function 𝓟2818{removeChild} (𝓟2819{node}: [OOV]𝓟[ty]6979{INode},𝓟2820{subpath}: 𝓛[ty]10051{String}): (𝓟2821: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10033{Void}))
  {
    return 𝓟2821 = 𝓟376{fail}(𝓛12554{$Template}(𝓟2820{subpath},𝓟[ty]2778{Type}.name))
  }
  function 𝓟2786{getValue} (𝓟2787{node}: [OOV]𝓟[ty]6979{INode}): (𝓟2788: [OOV]any)
  {
    return 𝓟2788 = 𝓟2787{node}.storedValue
  }
  function 𝓟2792{getDefaultSnapshot} (): (𝓟2793: [OOV]any)
  {
    return 𝓟2793 = 𝓛12563{undefined}
  }
}
function 𝓟2822{isType} (𝓟2823{value}: [OOV]any): (𝓟2824: 𝓛[ty]8666{Boolean})
{
  return 𝓟2824 = 𝓛12550{$TypeOf}(𝓟2823{value}).EqualsEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓟2823{value}).AmpersandAmpersandToken(𝓟2823{value}.isType.EqualsEqualsEqualsToken(𝓛8744{Boolean}))
}

LibAcc: 0.5912=295/499, ProjAcc: 1.0000=0/0, Missing: 1332

Module: packages/mobx-state-tree/src/middlewares/create-action-tracking-middleware

Module: packages/mobx-state-tree/src/types/utility-types/maybe

Module: packages/mst-middlewares/src/atomic

Module: packages/mobx-state-tree/src/types/utility-types/refinement

Module: packages/mobx-state-tree/src/types/primitives

Module: packages/mobx-state-tree/src/core/action

Module: packages/mobx-state-tree/src/types/utility-types/identifier

Module: packages/mobx-state-tree/src/types/utility-types/frozen

Module: packages/mobx-state-tree/src/types/utility-types/optional

Module: packages/mst-middlewares/src/simple-action-logger

Module: packages/mobx-state-tree/src/utils

Module: packages/mobx-state-tree/src/core/mst-operations

Module: packages/mobx-state-tree/src/core/node/node-utils

Module: packages/mobx-state-tree/src/core/node/identifier-cache

Module: packages/mobx-state-tree/src/types/utility-types/union

Module: packages/mobx-state-tree/src/types/utility-types/late

Module: packages/mobx-state-tree/src/core/process

Module: packages/mst-middlewares/src/time-traveller

Module: packages/mobx-state-tree/src/types/complex-types/map

Module: packages/mst-middlewares/src/undo-manager

Module: packages/mobx-state-tree/src/core/type/type-checker

Module: packages/mobx-state-tree/src/internal

Module: packages/mobx-state-tree/src/types/complex-types/array

Module: packages/mobx-state-tree/src/types/complex-types/model

Module: packages/mobx-state-tree/src/core/flow

Module: packages/mobx-state-tree/src/types/utility-types/enumeration

Module: packages/mst-middlewares/src/action-logger

Module: packages/mobx-state-tree/src/types/utility-types/literal

Module: packages/mst-middlewares/src/redux

Module: packages/mobx-state-tree/src/core/node/scalar-node

Module: packages/mst-middlewares/src/index

Module: packages/mobx-state-tree/src/core/node/object-node

Module: packages/mobx-state-tree/src/middlewares/on-action

Module: packages/mobx-state-tree/src/core/node/create-node

Module: packages/mobx-state-tree/src/types/utility-types/reference

Module: packages/mobx-state-tree/src/core/json-patch

Module: packages/mobx-state-tree/src/core/type/type

Module: packages/mobx-state-tree/src/index