Module: src/debug

function 𝓟1{require} (𝓟2{name}: 𝓛[ty]10051{String}): (𝓟3: [OOV]any)
{
}
const 𝓟4{cloneDeep} = 𝓟1{require}(𝓛8743{String});
function 𝓟5{reportChange} (𝓟6{change}: [OOV]𝓟[ty]596{IDebugChange}): (𝓟7: [miss]𝓛[ty]10033{Void})
{
  if (𝓟624{globalState}.currentDebugOutputAction)
  {
    𝓟624{globalState}.currentDebugOutputAction.changeList.push(𝓟6{change})
  }
  else
  {
    𝓟624{globalState}.event.emit(𝓛8743{String},{id: 𝓟566{createUniqueId}(),name: 𝓛12643{undefined},changeList: 𝓛8757{Array}(𝓟6{change}),type: 𝓛8743{String}})
  }
}
function 𝓟8{getCallStack} (𝓟9{target}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8642{Object})): (𝓟10: [miss]𝓛[ty]8670{Array})
{
  const 𝓟11{callStack}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
  if (𝓛12569{ExclamationToken}(𝓟624{globalState}.parentInfo.has(𝓟9{target})))
  {
    𝓟11{callStack}.unshift(𝓟9{target}.constructor.name)
  }
  else
  {
    let 𝓟12{currentTarget}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8642{Object}) = 𝓟9{target};
    let 𝓟13{runCount}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
    while (𝓟624{globalState}.parentInfo.has(𝓟12{currentTarget}))
    {
      const 𝓟14{parentInfo}: [miss]𝓛[ty]8642{Object} = 𝓟624{globalState}.parentInfo.get(𝓟12{currentTarget});
      𝓟11{callStack}.unshift(𝓟14{parentInfo}.key)
      if (𝓛12569{ExclamationToken}(𝓟624{globalState}.parentInfo.has(𝓟14{parentInfo}.parent)))
      {
        𝓟11{callStack}.unshift(𝓟14{parentInfo}.parent.constructor.name)
      }
      𝓟12{currentTarget} ⟵ 𝓟14{parentInfo}.parent;
      𝓛12556{POST_PlusPlusToken}(𝓟13{runCount})
      if (𝓛12596{GreaterThanEqualsToken}(𝓟13{runCount},𝓟624{globalState}.getCallstackMaxCount))
      {
      }
    }
  }
  return 𝓟10 = 𝓟11{callStack}
}
function 𝓟15{$Lambda1} (𝓟16{info}): (𝓟17: [miss]𝓛[ty]10033{Void})
{
  if (𝓛12569{ExclamationToken}(𝓟624{globalState}.useDebug))
  {
  }
  if (𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟16{info}.value,𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟16{info}.value),𝓛8743{String})))
  {
    𝓟624{globalState}.parentInfo.set(𝓟16{info}.value,{parent: 𝓟16{info}.target,key: 𝓟16{info}.key})
  }
}
𝓟624{globalState}.event.on(𝓛8743{String},𝓟15{$Lambda1})
function 𝓟18{$Lambda2} (𝓟19{debugName}): (𝓟20: [miss]𝓛[ty]10033{Void})
{
  if (𝓛12569{ExclamationToken}(𝓟624{globalState}.useDebug))
  {
  }
  𝓟624{globalState}.currentDebugName ⟵ 𝓛12546{BarBarToken}(𝓟19{debugName},𝓛12643{undefined});
}
𝓟624{globalState}.event.on(𝓛8743{String},𝓟18{$Lambda2})
function 𝓟21{$Lambda3} (): (𝓟22: [miss]𝓛[ty]10033{Void})
{
  if (𝓛12569{ExclamationToken}(𝓟624{globalState}.useDebug))
  {
  }
  const 𝓟23{debugOutputBundleAction}: [OOV]𝓟[ty]595{IDebugInfo} = {name: 𝓟624{globalState}.currentDebugName,changeList: 𝓛8757{Array}(),type: 𝓛8743{String}};
  𝓟624{globalState}.debugOutputActionMapBatchDeep.set(𝓟624{globalState}.batchDeep,𝓟23{debugOutputBundleAction})
  𝓟624{globalState}.currentDebugOutputAction ⟵ 𝓟23{debugOutputBundleAction};
  if (𝓛12559{EqualsEqualsEqualsToken}(𝓟624{globalState}.batchDeep,𝓛8745{Number}))
  {
    𝓟23{debugOutputBundleAction}.id ⟵ 𝓟566{createUniqueId}();
    𝓟624{globalState}.currentDebugId ⟵ 𝓟23{debugOutputBundleAction}.id;
  }
  if (𝓛12595{GreaterThanToken}(𝓟624{globalState}.batchDeep,𝓛8745{Number}))
  {
    𝓟624{globalState}.debugOutputActionMapBatchDeep.get(𝓛12616{MinusToken}(𝓟624{globalState}.batchDeep,𝓛8745{Number})).changeList.push({type: 𝓛8743{String},action: 𝓟23{debugOutputBundleAction}})
  }
}
𝓟624{globalState}.event.on(𝓛8743{String},𝓟21{$Lambda3})
function 𝓟24{$Lambda4} (): (𝓟25: [miss]𝓛[ty]10033{Void})
{
  if (𝓛12569{ExclamationToken}(𝓟624{globalState}.useDebug))
  {
  }
  𝓟624{globalState}.currentDebugOutputAction ⟵ 𝓛12546{BarBarToken}(𝓟624{globalState}.debugOutputActionMapBatchDeep.get(𝓟624{globalState}.batchDeep),𝓛12643{undefined});
  if (𝓛12569{ExclamationToken}(𝓟548{inAction}()))
  {
    let 𝓟26{cloneDebugInfo}: [OOV]any = 𝓛12643{undefined};
    {
      𝓟26{cloneDebugInfo} ⟵ 𝓛8756{JSON}.parse(𝓛8756{JSON}.stringify(𝓟624{globalState}.debugOutputActionMapBatchDeep.get(𝓛8745{Number})));
    }
    𝓟624{globalState}.event.emit(𝓛8743{String},𝓟26{cloneDebugInfo})
    𝓟624{globalState}.currentDebugOutputAction ⟵ 𝓛12643{undefined};
    𝓟624{globalState}.debugOutputActionMapBatchDeep.clear()
  }
}
𝓟624{globalState}.event.on(𝓛8743{String},𝓟24{$Lambda4})
function 𝓟27{$Lambda5} (𝓟28{info}): (𝓟29: [miss]𝓛[ty]10033{Void})
{
  if (𝓛12569{ExclamationToken}(𝓟624{globalState}.useDebug))
  {
  }
  const 𝓟30{callStack}: [miss]𝓛[ty]8670{Array} = 𝓟8{getCallStack}(𝓟28{info}.target);
  𝓟5{reportChange}({key: 𝓟28{info}.key,callStack: 𝓟30{callStack},oldValue: 𝓟4{cloneDeep}(𝓟28{info}.oldValue),type: 𝓛8743{String},value: 𝓟4{cloneDeep}(𝓟28{info}.value)})
}
𝓟624{globalState}.event.on(𝓛8743{String},𝓟27{$Lambda5})
function 𝓟31{$Lambda6} (𝓟32{info}): (𝓟33: [miss]𝓛[ty]10033{Void})
{
  if (𝓛12569{ExclamationToken}(𝓟624{globalState}.useDebug))
  {
  }
  const 𝓟34{callStack}: [miss]𝓛[ty]8670{Array} = 𝓟8{getCallStack}(𝓟32{info}.target);
  𝓟5{reportChange}({type: 𝓛8743{String},callStack: 𝓟34{callStack},key: 𝓟32{info}.key})
}
𝓟624{globalState}.event.on(𝓛8743{String},𝓟31{$Lambda6})

Module: demos/atom/computed-async

type 𝓟[ty]35{IComputedAsyncValue} = {value: any, status: {busy: 𝓛[ty]8666{Boolean}, failed: 𝓛[ty]8666{Boolean}, error: any}}
type 𝓟[ty]36{IComputedAsyncOptions} = {name: 𝓛[ty]10051{String}, delay: 𝓛[ty]8655{Number}, rethrow: 𝓛[ty]8666{Boolean}, error: (any)->any, fetch: ()->any, init: any, revert: 𝓛[ty]8666{Boolean}}
function 𝓟37{isPromiseLike} (𝓟38{result}: [OOV]any): (𝓟39: 𝓛[ty]8666{Boolean})
{
  return 𝓟39 = 𝓛12592{AmpersandAmpersandToken}(𝓟38{result},𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟38{result} as any.then),𝓛8743{String}))
}
function 𝓟40{CONSTRUCTOR} (𝓟41{options}: [OOV]𝓟[ty]36{IComputedAsyncOptions}): (𝓟[ty]49{ComputedAsync})
{
  const 𝓟[ty]49{ComputedAsync};
  const 𝓟[ty]49{ComputedAsync};
  𝓟[ty]49{ComputedAsync}.status ⟵ 𝓟309{observable}({busy: 𝓛8744{Boolean},failed: 𝓛8744{Boolean},error: 𝓛12643{undefined}});
  𝓟[ty]49{ComputedAsync}.version ⟵ 𝓛8745{Number};
  function 𝓟45{$Lambda19} (): (𝓟46: [miss]𝓛[ty]10033{Void})
  {
    return 𝓟46 = 𝓟[ty]49{ComputedAsync}.wake()
  }
  function 𝓟47{$Lambda20} (): (𝓟48: [miss]𝓛[ty]10033{Void})
  {
    return 𝓟48 = 𝓟[ty]49{ComputedAsync}.sleep()
  }
  𝓟[ty]49{ComputedAsync}.atom ⟵ 𝓟411{CONSTRUCTOR}(𝓟45{$Lambda19},𝓟47{$Lambda20});
  𝓟[ty]49{ComputedAsync}.cachedValue ⟵ 𝓟41{options}.init;
}
class 𝓟[ty]49{ComputedAsync} extends 𝓟[ty]35{IComputedAsyncValue}{
  𝓟51{monitor}: [OOV]any;
  𝓟52{version}: [miss]𝓛[ty]8655{Number};
  𝓟53{status}: [miss]𝓛[ty]8642{Object};
  𝓟54{atom}: 𝓟[ty]417{Atom};
  𝓟55{cachedValue}: [OOV]any;
  function 𝓟60{observe} (): (𝓟61: 𝓛[ty]10033{Void})
  {
    const 𝓟62{thisVersion}: [miss]𝓛[ty]8655{Number} = 𝓛12590{PlusPlusToken}(𝓟[ty]49{ComputedAsync}.version);
    if (𝓟[ty]49{ComputedAsync}.options.revert)
    {
      𝓟[ty]49{ComputedAsync}.cachedValue ⟵ 𝓟[ty]49{ComputedAsync}.options.init;
      𝓟[ty]49{ComputedAsync}.atom.reportChanged()
    }
    function 𝓟63{$Lambda22} (𝓟64{f}: 𝓛[ty]8696{Function}): (𝓟65: [miss]𝓛[ty]8696{Function})
    {
      function 𝓟66{$Lambda23} (𝓟67{arg}: [OOV]any): (𝓟68: [miss]𝓛[ty]10033{Void})
      {
        if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]49{ComputedAsync}.version,𝓟62{thisVersion}))
        {
          𝓟64{f}(𝓟67{arg})
        }
      }
      return 𝓟65 = 𝓟66{$Lambda23}
    }
    const 𝓟69{current}: [miss]𝓛[ty]8696{Function} = 𝓟63{$Lambda22};
    {
      const 𝓟70{possiblePromise} = 𝓟[ty]49{ComputedAsync}.options.fetch();
      if (𝓛12569{ExclamationToken}(𝓟37{isPromiseLike}(𝓟70{possiblePromise})))
      {
        𝓟[ty]49{ComputedAsync}.stopped(𝓛8744{Boolean},𝓛12643{undefined},𝓟70{possiblePromise})
      }
      else
      {
        𝓟[ty]49{ComputedAsync}.starting()
        function 𝓟71{$Lambda24} (𝓟72{v}: [OOV]any): (𝓟73: [miss]𝓛[ty]10033{Void})
        {
          return 𝓟73 = 𝓟[ty]49{ComputedAsync}.stopped(𝓛8744{Boolean},𝓛12643{undefined},𝓟72{v})
        }
        function 𝓟74{$Lambda25} (𝓟75{e}: [OOV]any): (𝓟76: [miss]𝓛[ty]10033{Void})
        {
          return 𝓟76 = 𝓟[ty]49{ComputedAsync}.handleError(𝓟75{e})
        }
        𝓟70{possiblePromise}.then(𝓟69{current}(𝓟71{$Lambda24}),𝓟69{current}(𝓟74{$Lambda25}))
      }
    }
  }
  function 𝓟56{wake} (): (𝓟57: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]49{ComputedAsync}.sleep()
    function 𝓟58{$Lambda21} (): (𝓟59: [miss]𝓛[ty]10033{Void})
    {
      return 𝓟59 = 𝓟[ty]49{ComputedAsync}.observe()
    }
    𝓟[ty]49{ComputedAsync}.monitor ⟵ 𝓟273{observe}(𝓟58{$Lambda21},𝓟[ty]49{ComputedAsync}.options.delay);
  }
  function 𝓟88{sleep} (): (𝓟89: [miss]𝓛[ty]10033{Void})
  {
    const 𝓟90{monitor} = 𝓟[ty]49{ComputedAsync}.monitor;
    𝓟[ty]49{ComputedAsync}.monitor ⟵ 𝓛12643{undefined};
    if (𝓟90{monitor})
    {
      𝓟90{monitor}.unobserve()
    }
  }
  function 𝓟84{handleError} (𝓟85{e}: [OOV]any): (𝓟86: [miss]𝓛[ty]10033{Void})
  {
    let 𝓟87{newValue}: [OOV]any = 𝓟[ty]49{ComputedAsync}.options.init;
    if (𝓟[ty]49{ComputedAsync}.options.error)
    {
      {
        𝓟87{newValue} ⟵ 𝓟[ty]49{ComputedAsync}.options.error(𝓟85{e});
      }
    }
    𝓟[ty]49{ComputedAsync}.stopped(𝓛8744{Boolean},𝓟85{e},𝓟87{newValue})
  }
  function 𝓟79{stopped} (𝓟80{f}: 𝓛[ty]8666{Boolean},𝓟81{e}: [OOV]any,𝓟82{v}: [OOV]any): (𝓟83: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]49{ComputedAsync}.status.busy ⟵ 𝓛8744{Boolean};
    𝓟[ty]49{ComputedAsync}.status.failed ⟵ 𝓟80{f};
    𝓟[ty]49{ComputedAsync}.status.error ⟵ 𝓟81{e};
    if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟82{v},𝓟[ty]49{ComputedAsync}.cachedValue))
    {
      𝓟[ty]49{ComputedAsync}.cachedValue ⟵ 𝓟82{v};
      𝓟[ty]49{ComputedAsync}.atom.reportChanged()
    }
  }
  function 𝓟77{starting} (): (𝓟78: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]49{ComputedAsync}.status.busy ⟵ 𝓛8744{Boolean};
  }
  function 𝓟91{value} (): (𝓟92)
  {
    𝓟[ty]49{ComputedAsync}.atom.reportObserved()
    if (𝓛12592{AmpersandAmpersandToken}(𝓟[ty]49{ComputedAsync}.status.failed,𝓟[ty]49{ComputedAsync}.options.rethrow))
    {
      𝓟[ty]49{ComputedAsync}.status.error
    }
    return 𝓟92 = 𝓟[ty]49{ComputedAsync}.cachedValue
  }
}
function 𝓟93{computedAsync} (𝓟94{init}: [OOV]any,𝓟95{fetch}: (𝓟[ty]452{Store2} ≠ 𝓛[ty]8696{Function}),𝓟96{delay}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟97: [OOV]𝓟[ty]35{IComputedAsyncValue})
{
}
function 𝓟98{computedAsync} (𝓟99{options}: [OOV]𝓟[ty]36{IComputedAsyncOptions}): (𝓟100: [OOV]𝓟[ty]35{IComputedAsyncValue})
{
}
function 𝓟101{computedAsync} (𝓟102{init}: [OOV]any,𝓟103{fetch}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟104{delay}: 𝓛[ty]8655{Number}): (𝓟105)
{
  if (𝓛12559{EqualsEqualsEqualsToken}(𝓛10035{arguments}.length,𝓛8745{Number}))
  {
    return 𝓟105 = 𝓟40{CONSTRUCTOR}(𝓟102{init} as 𝓟[ty]36{IComputedAsyncOptions})
  }
  return 𝓟105 = 𝓟40{CONSTRUCTOR}({init: 𝓟102{init} as 𝓛[ty]2{<UNKNOWN>},fetch: 𝓟103{fetch},delay: 𝓟104{delay}})
}

Module: src/reaction

type 𝓟[ty]106{IFunc} = (𝓛[ty]8670{Array})->any
function 𝓟107{CONSTRUCTOR} (𝓟108{name}: 𝓛[ty]10051{String},𝓟109{callback}: [OOV]𝓟[ty]106{IFunc},𝓟110{delay}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟[ty]114{Reaction})
{
  const 𝓟[ty]114{Reaction};
  const 𝓟[ty]114{Reaction};
  𝓟[ty]114{Reaction}.delay ⟵ 𝓛12643{undefined};
  𝓟[ty]114{Reaction}.keyBinders ⟵ 𝓛2997{Set}.CONSTRUCTOR();
  𝓟[ty]114{Reaction}.name ⟵ 𝓟108{name};
  𝓟[ty]114{Reaction}.callback ⟵ 𝓟109{callback};
  𝓟[ty]114{Reaction}.delay ⟵ 𝓛12546{BarBarToken}(𝓟110{delay},𝓛12643{undefined});
}
class 𝓟[ty]114{Reaction}{
  𝓟116{name}: 𝓛[ty]10051{String};
  𝓟117{delay}: [OOV]any;
  𝓟118{keyBinders}: [miss]𝓛[ty]5956{Set};
  𝓟119{callback}: [OOV]any;
  function 𝓟133{addBinder} (𝓟134{keyBinder}: (𝓛[ty]10051{String} ≠ 𝓛[ty]5956{Set})): (𝓟135: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]114{Reaction}.keyBinders.add(𝓟134{keyBinder})
  }
  function 𝓟131{run} (): (𝓟132: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟[ty]114{Reaction}.callback)
    {
      𝓟[ty]114{Reaction}.callback()
    }
  }
  function 𝓟120{track} (𝓟121{callback}: [OOV]𝓟[ty]106{IFunc}): (𝓟122: [miss]𝓛[ty]10033{Void})
  {
    if (𝓛12569{ExclamationToken}(𝓟121{callback}))
    {
    }
    if (𝓟550{inTrack}())
    {
      𝓟624{globalState}.pendingTracks.add(𝓟[ty]114{Reaction}.track.bind(𝓟[ty]114{Reaction},𝓟121{callback}))
    }
    𝓟624{globalState}.currentReaction ⟵ 𝓟[ty]114{Reaction};
    𝓟[ty]114{Reaction}.clearBinding()
    {
      𝓟121{callback}({debugId: 𝓟624{globalState}.currentDebugId})
    }
    {
      𝓟624{globalState}.currentReaction ⟵ 𝓛12643{undefined};
    }
    let 𝓟123{currentRunCount}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
    const 𝓟124{MAX_RUN_COUNT}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
    const 𝓟125{pendingTacksCopy}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}.from(𝓟624{globalState}.pendingTracks);
    𝓟624{globalState}.pendingTracks.clear()
    function 𝓟126{$Lambda11} (𝓟127{eachTack}): (𝓟128: [miss]𝓛[ty]10033{Void})
    {
      𝓛12556{POST_PlusPlusToken}(𝓟123{currentRunCount})
      if (𝓛12596{GreaterThanEqualsToken}(𝓟123{currentRunCount},𝓟124{MAX_RUN_COUNT}))
      {
        𝓛1{<UNKNOWN>}(𝓛8743{String})
        𝓟624{globalState}.pendingTracks.clear()
      }
      𝓟127{eachTack}()
    }
    𝓟125{pendingTacksCopy}.forEach(𝓟126{$Lambda11})
  }
  function 𝓟129{dispose} (): (𝓟130: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]114{Reaction}.clearBinding()
    𝓟[ty]114{Reaction}.callback ⟵ 𝓛12643{undefined};
  }
  function 𝓟136{clearBinding} (): (𝓟137: [miss]𝓛[ty]10033{Void})
  {
    function 𝓟138{$Lambda12} (𝓟139{keyBinder}): (𝓟140: [miss]𝓛[ty]10033{Void})
    {
      𝓟139{keyBinder}.delete(𝓟[ty]114{Reaction})
    }
    𝓟[ty]114{Reaction}.keyBinders.forEach(𝓟138{$Lambda12})
    𝓟[ty]114{Reaction}.keyBinders.clear()
  }
}

Module: demos/debug/index

𝓟562{useStrict}()
𝓟558{startDebug}()
function 𝓟141{$Lambda31} (𝓟142{info}): (𝓟143: [miss]𝓛[ty]10033{Void})
{
  𝓛1{<UNKNOWN>}(𝓛8745{Number},𝓟142{info})
}
𝓟624{globalState}.event.on(𝓛8743{String},𝓟141{$Lambda31})
function 𝓟144{CONSTRUCTOR} (): (𝓟[ty]148{Store1})
{
  const 𝓟[ty]148{Store1};
  const 𝓟[ty]148{Store1};
  𝓟[ty]148{Store1}.age ⟵ 𝓛8745{Number};
}
class 𝓟[ty]148{Store1}{
  𝓟150{age}: [miss]𝓛[ty]8655{Number};
}
function 𝓟151{CONSTRUCTOR} (): (𝓟[ty]155{Action1})
{
  const 𝓟[ty]155{Action1};
  const 𝓟[ty]155{Action1};
}
class 𝓟[ty]155{Action1}{
  𝓟157{Store1}: (𝓟[ty]164{Store2} ≠ 𝓟[ty]148{Store1});
  function 𝓟158{test1} (): (𝓟159: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]155{Action1}.Store1.age ⟵ 𝓛8745{Number};
  }
}
function 𝓟160{CONSTRUCTOR} (): (𝓟[ty]164{Store2})
{
  const 𝓟[ty]164{Store2};
  const 𝓟[ty]164{Store2};
  𝓟[ty]164{Store2}.name ⟵ 𝓛8743{String};
}
class 𝓟[ty]164{Store2}{
  𝓟166{name}: [miss]𝓛[ty]10051{String};
}
function 𝓟167{CONSTRUCTOR} (): (𝓟[ty]171{Action2})
{
  const 𝓟[ty]171{Action2};
  const 𝓟[ty]171{Action2};
}
class 𝓟[ty]171{Action2}{
  𝓟173{Store2}: 𝓟[ty]164{Store2};
  𝓟174{Store1}: (𝓟[ty]164{Store2} ≠ 𝓟[ty]148{Store1});
  function 𝓟175{test2} (): (𝓟176: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]171{Action2}.Store2.name ⟵ 𝓛8743{String};
    𝓟[ty]171{Action2}.Store1.age ⟵ 𝓛8745{Number};
  }
}
const 𝓟177{stores} = 𝓟642{combineStores}({Store1: 𝓛12643{undefined},Action1: 𝓛12643{undefined},Store2: 𝓛12643{undefined},Action2: 𝓛12643{undefined}});
𝓟177{stores}.Action2.test2()

Module: src/built-ins/weak-set

type 𝓟[ty]198{IcustomObject} = {$raw: any, access: (𝓛[ty]10051{String})->any}
const 𝓟199{native}: [OOV]any = 𝓛2998{WeakSet}.prototype;
const 𝓟200{getters}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String});
const 𝓟201{all}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String},𝓛8743{String}).concat(𝓟200{getters});
function 𝓟202{shim} (𝓟203{target}: [OOV]any,𝓟204{bindCurrentReaction}: [OOV]any,𝓟205{queueRunReactions}: [OOV]any,𝓟206{proxyValue}: [OOV]any): (𝓟207: [OOV]any)
{
  𝓟203{target}.$raw ⟵ {};
  {
    const 𝓟208{method}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟201{all});
    while (𝓛8744{Boolean})
    {
      function 𝓟209{$Lambda55} (): (𝓟210: [miss]𝓛[ty]10033{Void})
      {
        𝓟199{native}.access(𝓟208{method}).apply(𝓟203{target},𝓛10035{arguments})
      }
      𝓟203{target}.$raw.access(𝓟208{method}) ⟵ 𝓟209{$Lambda55};
    }
  }
  {
    const 𝓟211{getter}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟200{getters});
    while (𝓛8744{Boolean})
    {
      function 𝓟212{$Lambda56} (𝓟213{value}: 𝓛[ty]10051{String}): (𝓟214: [OOV]any)
      {
        let 𝓟215{result} = 𝓟199{native}.access(𝓟211{getter}).apply(𝓛12552{this},𝓛10035{arguments});
        𝓟624{globalState}.event.emit(𝓛8743{String},{target: 𝓟203{target},key: 𝓛12643{undefined},value: 𝓟215{result}})
        𝓟215{result} ⟵ 𝓟206{proxyValue}(𝓛12552{this},𝓟213{value},𝓟215{result});
        𝓟204{bindCurrentReaction}(𝓛12552{this},𝓟213{value})
        return 𝓟214 = 𝓟215{result}
      }
      𝓟203{target}.access(𝓟211{getter}) ⟵ 𝓟212{$Lambda56};
    }
  }
  function 𝓟216{$Lambda57} (𝓟217{value}: 𝓛[ty]10051{String}): (𝓟218: [OOV]any)
  {
    const 𝓟219{has} = 𝓛12552{this}.has(𝓟217{value});
    const 𝓟220{result} = 𝓟199{native}.add.apply(𝓛12552{this},𝓛10035{arguments});
    𝓟624{globalState}.event.emit(𝓛8743{String},{target: 𝓟203{target},key: 𝓛12643{undefined},value: 𝓟217{value},oldValue: 𝓛12643{undefined}})
    if (𝓛12569{ExclamationToken}(𝓟219{has}))
    {
      𝓟205{queueRunReactions}(𝓛12552{this},𝓟217{value})
    }
    return 𝓟218 = 𝓟220{result}
  }
  𝓟203{target}.add ⟵ 𝓟216{$Lambda57};
  function 𝓟221{$Lambda58} (𝓟222{value}: 𝓛[ty]10051{String}): (𝓟223: [OOV]any)
  {
    const 𝓟224{has} = 𝓛12552{this}.has(𝓟222{value});
    const 𝓟225{result} = 𝓟199{native}.delete.apply(𝓛12552{this},𝓛10035{arguments});
    𝓟624{globalState}.event.emit(𝓛8743{String},{target: 𝓟203{target},key: 𝓛12643{undefined}})
    if (𝓟224{has})
    {
      𝓟205{queueRunReactions}(𝓛12552{this},𝓟222{value})
    }
    return 𝓟223 = 𝓟225{result}
  }
  𝓟203{target}.delete ⟵ 𝓟221{$Lambda58};
  return 𝓟207 = 𝓟203{target}
}

Module: src/observer

const 𝓟226{MAX_RUN_COUNT}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
function 𝓟227{createObservableObject} (𝓟228{obj}: [OOV]any): (𝓟229: [OOV]any)
{
  if (𝓟542{isPrimitive}(𝓟228{obj}))
  {
    𝓛8754{TypeError}(𝓛12607{$Template}(𝓟228{obj}))
  }
  if (𝓟624{globalState}.proxies.has(𝓟228{obj}))
  {
    return 𝓟229 = 𝓟624{globalState}.proxies.get(𝓟228{obj})
  }
  return 𝓟229 = 𝓟236{toObservable}(𝓟228{obj})
}
function 𝓟230{createObservableObjectDecorator} (𝓟231{target}: [OOV]any): (𝓟232: [OOV]any)
{
  function 𝓟233{wrap} (𝓟234{args}: 𝓛[ty]8670{Array}): (𝓟235: [OOV]any)
  {
    return 𝓟235 = 𝓟227{createObservableObject}(𝓟231{target}.CONSTRUCTOR(𝓛12587{$Spread}(𝓟234{args})))
  }
  return 𝓟232 = 𝓟233{wrap} as any
}
function 𝓟236{toObservable} (𝓟237{obj}: [OOV]any): (𝓟238: [OOV]any)
{
  if (𝓛12595{GreaterThanToken}(𝓛8741{Object}.getOwnPropertySymbols(𝓟237{obj}).indexOf(𝓟624{globalState}.ignoreDynamicSymbol),𝓛12616{MinusToken}(𝓛8745{Number})))
  {
    return 𝓟238 = 𝓟237{obj}
  }
  let 𝓟239{dynamicObject}: [OOV]any;
  const 𝓟240{builtIn} = 𝓟568{defaultVar}.get(𝓟237{obj}.constructor);
  if (𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟240{builtIn}),𝓛8743{String}),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟240{builtIn}),𝓛8743{String})))
  {
    𝓟239{dynamicObject} ⟵ 𝓟240{builtIn}(𝓟237{obj},𝓟265{bindCurrentReaction},𝓟248{queueRunReactions},𝓟241{getProxyValue});
  }
  else
  {
    if (𝓛12569{ExclamationToken}(𝓟240{builtIn}))
    {
      𝓟239{dynamicObject} ⟵ 𝓛10041{Proxy}.CONSTRUCTOR(𝓟237{obj},{});
    }
    else
    {
      𝓟239{dynamicObject} ⟵ 𝓟237{obj};
    }
  }
  𝓟624{globalState}.proxies.set(𝓟237{obj},𝓟239{dynamicObject})
  𝓟624{globalState}.proxies.set(𝓟239{dynamicObject},𝓟239{dynamicObject})
  𝓟624{globalState}.originObjects.set(𝓟239{dynamicObject},𝓟237{obj})
  𝓟624{globalState}.objectReactionBindings.set(𝓟237{obj},𝓛2995{Map}.CONSTRUCTOR())
  return 𝓟238 = 𝓟239{dynamicObject}
}
function 𝓟241{getProxyValue} (𝓟242{target}: [OOV]any,𝓟243{key}: [OOV]𝓛[ty]8640{PropertyKey},𝓟244{value}: [OOV]any): (𝓟245: [OOV]any)
{
  if (𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓛12233{window}),𝓛8743{String}),𝓛1{<UNKNOWN>}(𝓟244{value},𝓛11662{HTMLElement})))
  {
    return 𝓟245 = 𝓟244{value}
  }
  const 𝓟246{resultIsObject} = 𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟244{value}),𝓛8743{String}),𝓟244{value});
  const 𝓟247{existProxy} = 𝓛12592{AmpersandAmpersandToken}(𝓟246{resultIsObject},𝓟624{globalState}.proxies.get(𝓟244{value}));
  if (𝓟246{resultIsObject})
  {
    return 𝓟245 = 𝓛12546{BarBarToken}(𝓟247{existProxy},𝓟236{toObservable}(𝓟244{value}))
  }
  return 𝓟245 = 𝓟244{value}
}
function 𝓟248{queueRunReactions} (𝓟249{target}: [OOV]any,𝓟250{key}: [OOV]𝓛[ty]8640{PropertyKey}): (𝓟251: [miss]𝓛[ty]10033{Void})
{
  if (𝓛12592{AmpersandAmpersandToken}(𝓟624{globalState}.strictMode,𝓛12559{EqualsEqualsEqualsToken}(𝓟624{globalState}.batchDeep,𝓛8745{Number})))
  {
    𝓛8749{Error}(𝓛8743{String})
  }
  const 𝓟252{keyBinder}: [miss]𝓛[ty]5956{Set} = 𝓟552{getBinder}(𝓟249{target},𝓟250{key}).keyBinder;
  function 𝓟253{$Lambda7} (𝓟254{reaction}): (𝓟255: [miss]𝓛[ty]10033{Void})
  {
    if (𝓟548{inAction}())
    {
      𝓟624{globalState}.pendingReactions.add(𝓟254{reaction})
    }
    else
    {
      if (𝓛12559{EqualsEqualsEqualsToken}(𝓟624{globalState}.pendingReactions.size,𝓛8745{Number}))
      {
        𝓟256{runReaction}(𝓟254{reaction})
      }
      else
      {
        𝓟624{globalState}.pendingReactions.add(𝓟254{reaction})
        𝓟259{runPendingReactions}()
      }
    }
  }
  𝓛8757{Array}.from(𝓟252{keyBinder}).forEach(𝓟253{$Lambda7})
}
function 𝓟256{runReaction} (𝓟257{reaction}: 𝓟[ty]114{Reaction}): (𝓟258: [miss]𝓛[ty]10033{Void})
{
  𝓟257{reaction}.run()
}
function 𝓟259{runPendingReactions} (): (𝓟260: [miss]𝓛[ty]10033{Void})
{
  let 𝓟261{currentRunCount}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
  function 𝓟262{$Lambda8} (𝓟263{observer}): (𝓟264: [miss]𝓛[ty]10033{Void})
  {
    𝓛12556{POST_PlusPlusToken}(𝓟261{currentRunCount})
    if (𝓛12596{GreaterThanEqualsToken}(𝓟261{currentRunCount},𝓟226{MAX_RUN_COUNT}))
    {
      𝓟624{globalState}.pendingReactions.clear()
    }
    𝓟256{runReaction}(𝓟263{observer})
  }
  𝓟624{globalState}.pendingReactions.forEach(𝓟262{$Lambda8})
  𝓟624{globalState}.pendingReactions.clear()
}
function 𝓟265{bindCurrentReaction} (𝓟266{object}: [OOV]any,𝓟267{key}: [OOV]𝓛[ty]8640{PropertyKey}): (𝓟268: [miss]𝓛[ty]10033{Void})
{
  if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟624{globalState}.currentReaction),𝓟548{inAction}()))
  {
  }
  const 𝓟269{keyBinder}: [miss]𝓛[ty]5956{Set} = 𝓟552{getBinder}(𝓟266{object},𝓟267{key}).keyBinder;
  if (𝓛12569{ExclamationToken}(𝓟269{keyBinder}.has(𝓟624{globalState}.currentReaction)))
  {
    𝓟269{keyBinder}.add(𝓟624{globalState}.currentReaction)
    𝓟624{globalState}.currentReaction.addBinder(𝓟269{keyBinder})
  }
}
function 𝓟270{isObservable} (𝓟271{obj}: [OOV]any): (𝓟272: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟272 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟624{globalState}.proxies.get(𝓟271{obj}),𝓟271{obj})
}
function 𝓟273{observe} (𝓟274{callback}: [OOV]𝓟[ty]540{Func},𝓟275{delay}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟276: [miss]𝓛[ty]8642{Object})
{
  function 𝓟277{$Lambda9} (): (𝓟278: [miss]𝓛[ty]10033{Void})
  {
    𝓟279{reaction}.track(𝓟274{callback})
  }
  const 𝓟279{reaction}: [miss]𝓟[ty]114{Reaction} = 𝓟107{CONSTRUCTOR}(𝓛8743{String},𝓟277{$Lambda9},𝓟275{delay});
  if (𝓟548{inAction}())
  {
    𝓟624{globalState}.pendingReactions.add(𝓟279{reaction})
  }
  else
  {
    𝓟279{reaction}.run()
  }
  function 𝓟280{$Lambda10} (): (𝓟281: [miss]𝓛[ty]10033{Void})
  {
    𝓟279{reaction}.dispose()
  }
  return 𝓟276 = {unobserve: 𝓟280{$Lambda10}}
}
function 𝓟282{startBatch} (): (𝓟283: [miss]𝓛[ty]10033{Void})
{
  if (𝓛12559{EqualsEqualsEqualsToken}(𝓟624{globalState}.batchDeep,𝓛8745{Number}))
  {
    𝓟624{globalState}.pendingReactions ⟵ 𝓛2997{Set}.CONSTRUCTOR();
  }
  𝓛12556{POST_PlusPlusToken}(𝓟624{globalState}.batchDeep)
  𝓟624{globalState}.event.emit(𝓛8743{String},𝓛12643{undefined})
}
function 𝓟284{endBatch} (): (𝓟285: [miss]𝓛[ty]10033{Void})
{
  if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12615{MinusMinusToken}(𝓟624{globalState}.batchDeep),𝓛8745{Number}))
  {
    𝓟259{runPendingReactions}()
  }
  𝓟624{globalState}.event.emit(𝓛8743{String},𝓛12643{undefined})
}
function 𝓟286{Action} (𝓟287{fn}: (𝓟[ty]164{Store2} ≠ 𝓛[ty]8696{Function})): (𝓟288: 𝓛[ty]10033{Void})
{
}
function 𝓟289{Action} (𝓟290{target}: [OOV]any,𝓟291{propertyKey}: 𝓛[ty]10051{String},𝓟292{descriptor}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8633{PropertyDescriptor})): (𝓟293: [OOV]any)
{
}
function 𝓟294{Action} (𝓟295{arg1}: [OOV]any,𝓟296{arg2}: [OOV]any,𝓟297{arg3}: [OOV]any): (𝓟298)
{
  if (𝓛12559{EqualsEqualsEqualsToken}(𝓟296{arg2},𝓛12643{undefined}))
  {
    return 𝓟298 = 𝓟305{runInAction}.call(𝓛12643{undefined},𝓟295{arg1},𝓟295{arg1}.name)
  }
  return 𝓟298 = 𝓟299{actionDecorator}.call(𝓛12643{undefined},𝓟295{arg1},𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟295{arg1}.constructor.name,𝓛8743{String}),𝓟296{arg2}),𝓟297{arg3})
}
function 𝓟299{actionDecorator} (𝓟300{target}: [OOV]any,𝓟301{propertyKey}: 𝓛[ty]10051{String},𝓟302{descriptor}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8633{PropertyDescriptor})): (𝓟303: [miss]𝓛[ty]8642{Object})
{
  const 𝓟304{func} = 𝓟302{descriptor}.value;
  return 𝓟303 = {}
}
function 𝓟305{runInAction} (𝓟306{fn}: 𝓛[ty]8696{Function},𝓟307{debugName}: 𝓛[ty]10051{String}): (𝓟308: [OOV]any)
{
  𝓟624{globalState}.event.emit(𝓛8743{String},𝓟307{debugName})
  𝓟282{startBatch}()
  {
    return 𝓟308 = 𝓟306{fn}()
  }
  {
    𝓟284{endBatch}()
  }
}
function 𝓟309{observable} (𝓟310{target}: [OOV]any): (𝓟311: [OOV]any)
{
  if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟310{target}),𝓛8743{String}))
  {
    return 𝓟311 = 𝓟230{createObservableObjectDecorator}(𝓟310{target})
  }
  else
  {
    return 𝓟311 = 𝓟227{createObservableObject}(𝓟310{target} as any) as 𝓛[ty]2{<UNKNOWN>}
  }
}
function 𝓟312{Static} (𝓟313{obj}: [OOV]any): (𝓟314: [OOV]any)
{
  𝓛8741{Object}.defineProperty(𝓟313{obj},𝓟624{globalState}.ignoreDynamicSymbol,{value: 𝓛8744{Boolean}})
  return 𝓟314 = 𝓟313{obj}
}

Module: src/built-ins/map

type 𝓟[ty]315{IcustomObject} = {$raw: any, access: (𝓛[ty]10051{String})->any}
const 𝓟316{native}: [OOV]any = 𝓛2995{Map}.prototype;
const 𝓟317{masterKey} = 𝓛10031{Symbol}(𝓛8743{String});
const 𝓟318{getters}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String},𝓛8743{String});
const 𝓟319{iterators}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛10031{Symbol}.iterator);
const 𝓟320{all}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String},𝓛8743{String},𝓛8743{String}).concat(𝓟318{getters},𝓟319{iterators} as any);
function 𝓟321{shim} (𝓟322{target}: [OOV]any,𝓟323{bindCurrentReaction}: [OOV]any,𝓟324{queueRunReactions}: [OOV]any,𝓟325{proxyValue}: [OOV]any): (𝓟326: [OOV]any)
{
  𝓟322{target}.$raw ⟵ {};
  {
    const 𝓟327{method}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟320{all});
    while (𝓛8744{Boolean})
    {
      function 𝓟328{$Lambda39} (): (𝓟329: [miss]𝓛[ty]10033{Void})
      {
        𝓟316{native}.access(𝓟327{method}).apply(𝓟322{target},𝓛10035{arguments})
      }
      𝓟322{target}.$raw.access(𝓟327{method}) ⟵ 𝓟328{$Lambda39};
    }
  }
  {
    const 𝓟330{getter}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟318{getters});
    while (𝓛8744{Boolean})
    {
      function 𝓟331{$Lambda40} (𝓟332{key}: 𝓛[ty]10051{String}): (𝓟333: [OOV]any)
      {
        let 𝓟334{value} = 𝓟316{native}.access(𝓟330{getter}).apply(𝓛12552{this},𝓛10035{arguments});
        𝓟624{globalState}.event.emit(𝓛8743{String},{target: 𝓟322{target},key: 𝓟332{key},value: 𝓟334{value}})
        𝓟334{value} ⟵ 𝓟325{proxyValue}(𝓛12552{this},𝓟332{key},𝓟334{value});
        𝓟323{bindCurrentReaction}(𝓛12552{this},𝓟332{key})
        return 𝓟333 = 𝓟334{value}
      }
      𝓟322{target}.access(𝓟330{getter}) ⟵ 𝓟331{$Lambda40};
    }
  }
  {
    const 𝓟335{iterator} = 𝓛12589{$ArrayAccess}(𝓟319{iterators});
    while (𝓛8744{Boolean})
    {
      function 𝓟336{$Lambda41} (): (𝓟337: [OOV]any)
      {
        𝓟323{bindCurrentReaction}(𝓛12552{this},𝓟317{masterKey})
        return 𝓟337 = 𝓟316{native}.access(𝓟335{iterator}).apply(𝓛12552{this},𝓛10035{arguments})
      }
      𝓟322{target}.access(𝓟335{iterator}) ⟵ 𝓟336{$Lambda41};
    }
  }
  function 𝓟338{$Lambda42} (𝓟339{key}: 𝓛[ty]10051{String},𝓟340{value}: [OOV]any): (𝓟341: [OOV]any)
  {
    const 𝓟342{oldValue} = 𝓛12552{this}.get(𝓟339{key});
    const 𝓟343{result} = 𝓟316{native}.set.apply(𝓛12552{this},𝓛10035{arguments});
    𝓟624{globalState}.event.emit(𝓛8743{String},{target: 𝓟322{target},key: 𝓟339{key},oldValue: 𝓟342{oldValue},value: 𝓟340{value}})
    if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟342{oldValue},𝓟340{value}))
    {
      𝓟324{queueRunReactions}(𝓛12552{this},𝓟339{key})
      𝓟324{queueRunReactions}(𝓛12552{this},𝓟317{masterKey})
    }
    return 𝓟341 = 𝓟343{result}
  }
  𝓟322{target}.set ⟵ 𝓟338{$Lambda42};
  function 𝓟344{$Lambda43} (𝓟345{key}: 𝓛[ty]10051{String}): (𝓟346: [OOV]any)
  {
    const 𝓟347{has} = 𝓛12552{this}.has(𝓟345{key});
    const 𝓟348{result} = 𝓟316{native}.delete.apply(𝓛12552{this},𝓛10035{arguments});
    𝓟624{globalState}.event.emit(𝓛8743{String},{target: 𝓟322{target},key: 𝓟345{key}})
    if (𝓟347{has})
    {
      𝓟324{queueRunReactions}(𝓛12552{this},𝓟345{key})
      𝓟324{queueRunReactions}(𝓛12552{this},𝓟317{masterKey})
    }
    return 𝓟346 = 𝓟348{result}
  }
  𝓟322{target}.delete ⟵ 𝓟344{$Lambda43};
  function 𝓟349{$Lambda44} (): (𝓟350: [OOV]any)
  {
    const 𝓟351{size} = 𝓛12552{this}.size;
    const 𝓟352{result} = 𝓟316{native}.clear.apply(𝓛12552{this},𝓛10035{arguments});
    if (𝓟351{size})
    {
      𝓟324{queueRunReactions}(𝓛12552{this},𝓟317{masterKey})
    }
    return 𝓟350 = 𝓟352{result}
  }
  𝓟322{target}.clear ⟵ 𝓟349{$Lambda44};
  function 𝓟353{get} (): (𝓟354: [OOV]any)
  {
    const 𝓟355{proto} = 𝓛8741{Object}.getPrototypeOf(𝓛12552{this});
    const 𝓟356{size} = 𝓛3030{get}(𝓟355{proto},𝓛8743{String},𝓛12552{this});
    𝓟323{bindCurrentReaction}(𝓛12552{this},𝓟317{masterKey})
    return 𝓟354 = 𝓟356{size}
  }
  𝓛8741{Object}.defineProperty(𝓟322{target},𝓛8743{String},{get: 𝓟353{get}})
  return 𝓟326 = 𝓟322{target}
}

Module: src/event/index

type 𝓟[ty]357{IEvent} = {callback: (any)->𝓛[ty]10033{Void}}
type 𝓟[ty]358{EventType} = any
type 𝓟[ty]359{ICallback} = (any)->𝓛[ty]10033{Void}
function 𝓟360{CONSTRUCTOR} (): (𝓟[ty]364{Event})
{
  const 𝓟[ty]364{Event};
  const 𝓟[ty]364{Event};
  𝓟[ty]364{Event}.events ⟵ 𝓛2995{Map}.CONSTRUCTOR();
}
class 𝓟[ty]364{Event}{
  𝓟366{events}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]3199{Map});
  function 𝓟391{on} (𝓟392{eventType}: [OOV]𝓟[ty]358{EventType},𝓟393{callback}: [OOV]𝓟[ty]359{ICallback}): (𝓟394: 𝓛[ty]10033{Void})
  {
    const 𝓟395{event}: [OOV]𝓟[ty]357{IEvent} = {callback: 𝓟393{callback}};
    if (𝓟[ty]364{Event}.events.get(𝓟392{eventType}))
    {
      𝓟[ty]364{Event}.events.get(𝓟392{eventType}).push(𝓟395{event})
    }
    else
    {
      𝓟[ty]364{Event}.events.set(𝓟392{eventType},𝓛8757{Array}(𝓟395{event}))
    }
  }
  function 𝓟396{off} (𝓟397{eventType}: [OOV]𝓟[ty]358{EventType},𝓟398{callback}: [OOV]𝓟[ty]359{ICallback}): (𝓟399: [miss]𝓛[ty]8666{Boolean})
  {
    if (𝓛12569{ExclamationToken}(𝓟[ty]364{Event}.events.get(𝓟397{eventType})))
    {
      return 𝓟399 = 𝓛8744{Boolean}
    }
    function 𝓟400{$Lambda59} (𝓟401{event}): (𝓟402: [miss]𝓛[ty]8666{Boolean})
    {
      return 𝓟402 = 𝓛12612{ExclamationEqualsEqualsToken}(𝓟401{event}.callback,𝓟398{callback})
    }
    const 𝓟403{events}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]364{Event}.events.get(𝓟397{eventType}).filter(𝓟400{$Lambda59});
    𝓟[ty]364{Event}.events.set(𝓟397{eventType},𝓟403{events})
    return 𝓟399 = 𝓛8744{Boolean}
  }
  function 𝓟404{emit} (𝓟405{eventType}: [OOV]𝓟[ty]358{EventType},𝓟406{context}: [OOV]any): (𝓟407: [miss]𝓛[ty]8666{Boolean})
  {
    if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟405{eventType}),𝓛12569{ExclamationToken}(𝓟[ty]364{Event}.events.get(𝓟405{eventType}))))
    {
      return 𝓟407 = 𝓛8744{Boolean}
    }
    function 𝓟408{$Lambda60} (𝓟409{event}): (𝓟410: [miss]𝓛[ty]10033{Void})
    {
      𝓟409{event}.callback(𝓟406{context})
    }
    𝓟[ty]364{Event}.events.get(𝓟405{eventType}).forEach(𝓟408{$Lambda60})
  }
}

Module: demos/action/index

function 𝓟432{CONSTRUCTOR} (): (𝓟[ty]436{Store1})
{
  const 𝓟[ty]436{Store1};
  const 𝓟[ty]436{Store1};
  𝓟[ty]436{Store1}.age ⟵ 𝓛8745{Number};
}
class 𝓟[ty]436{Store1}{
  𝓟438{age}: [miss]𝓛[ty]8655{Number};
}
function 𝓟439{CONSTRUCTOR} (): (𝓟[ty]443{Action1})
{
  const 𝓟[ty]443{Action1};
  const 𝓟[ty]443{Action1};
}
class 𝓟[ty]443{Action1}{
  𝓟445{Store1}: (𝓟[ty]164{Store2} ≠ 𝓟[ty]436{Store1});
  function 𝓟446{test1} (): (𝓟447: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]443{Action1}.Store1.age ⟵ 𝓛8745{Number};
  }
}
function 𝓟448{CONSTRUCTOR} (): (𝓟[ty]452{Store2})
{
  const 𝓟[ty]452{Store2};
  const 𝓟[ty]452{Store2};
  𝓟[ty]452{Store2}.name ⟵ 𝓛8743{String};
}
class 𝓟[ty]452{Store2}{
  𝓟454{name}: [miss]𝓛[ty]10051{String};
}
function 𝓟455{CONSTRUCTOR} (): (𝓟[ty]461{Action2})
{
  const 𝓟[ty]461{Action2};
  const 𝓟[ty]461{Action2};
  function 𝓟459{$Lambda14} (): (𝓟460: [miss]𝓛[ty]10033{Void})
  {
    𝓟[ty]461{Action2}.Store2.name ⟵ 𝓛8743{String};
    𝓟[ty]461{Action2}.Store1.age ⟵ 𝓛8745{Number};
  }
  𝓟[ty]461{Action2}.test2 ⟵ 𝓟459{$Lambda14};
}
class 𝓟[ty]461{Action2}{
  𝓟463{Store2}: 𝓟[ty]452{Store2};
  𝓟464{Store1}: (𝓟[ty]164{Store2} ≠ 𝓟[ty]436{Store1});
  𝓟465{test2}: [miss]𝓛[ty]8696{Function};
}
const 𝓟466{stores} = 𝓟642{combineStores}({Store1: 𝓛12643{undefined},Action1: 𝓛12643{undefined},Store2: 𝓛12643{undefined},Action2: 𝓛12643{undefined}});
function 𝓟467{$Lambda15} (): (𝓟468: [miss]𝓛[ty]10033{Void})
{
  𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟466{stores}.Store1.age,𝓟466{stores}.Store2.name)
}
𝓟273{observe}(𝓟467{$Lambda15})
𝓟466{stores}.Action2.test2()

Module: src/built-ins/set

type 𝓟[ty]469{IcustomObject} = {$raw: any, access: (𝓛[ty]10051{String})->any}
const 𝓟470{native}: [OOV]any = 𝓛2997{Set}.prototype;
const 𝓟471{masterValue} = 𝓛10031{Symbol}(𝓛8743{String});
const 𝓟472{getters}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String});
const 𝓟473{iterators}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛8743{String},𝓛10031{Symbol}.iterator);
const 𝓟474{all}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String},𝓛8743{String},𝓛8743{String}).concat(𝓟472{getters},𝓟473{iterators} as any);
function 𝓟475{shim} (𝓟476{target}: [OOV]any,𝓟477{bindCurrentReaction}: [OOV]any,𝓟478{queueRunReactions}: [OOV]any,𝓟479{proxyValue}: [OOV]any): (𝓟480: [OOV]any)
{
  𝓟476{target}.$raw ⟵ {};
  {
    const 𝓟481{method}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟474{all});
    while (𝓛8744{Boolean})
    {
      function 𝓟482{$Lambda45} (): (𝓟483: [miss]𝓛[ty]10033{Void})
      {
        𝓟470{native}.access(𝓟481{method}).apply(𝓟476{target},𝓛10035{arguments})
      }
      𝓟476{target}.$raw.access(𝓟481{method}) ⟵ 𝓟482{$Lambda45};
    }
  }
  {
    const 𝓟484{getter}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟472{getters});
    while (𝓛8744{Boolean})
    {
      function 𝓟485{$Lambda46} (𝓟486{value}: 𝓛[ty]10051{String}): (𝓟487: [OOV]any)
      {
        let 𝓟488{result} = 𝓟470{native}.access(𝓟484{getter}).apply(𝓛12552{this},𝓛10035{arguments});
        𝓟624{globalState}.event.emit(𝓛8743{String},{target: 𝓟476{target},key: 𝓛12643{undefined},value: 𝓟488{result}})
        𝓟488{result} ⟵ 𝓟479{proxyValue}(𝓛12552{this},𝓟486{value},𝓟488{result});
        𝓟477{bindCurrentReaction}(𝓛12552{this},𝓟486{value})
        return 𝓟487 = 𝓟488{result}
      }
      𝓟476{target}.access(𝓟484{getter}) ⟵ 𝓟485{$Lambda46};
    }
  }
  {
    const 𝓟489{iterator} = 𝓛12589{$ArrayAccess}(𝓟473{iterators});
    while (𝓛8744{Boolean})
    {
      function 𝓟490{$Lambda47} (): (𝓟491: [OOV]any)
      {
        𝓟477{bindCurrentReaction}(𝓛12552{this},𝓟471{masterValue})
        return 𝓟491 = 𝓟470{native}.access(𝓟489{iterator}).apply(𝓛12552{this},𝓛10035{arguments})
      }
      𝓟476{target}.access(𝓟489{iterator}) ⟵ 𝓟490{$Lambda47};
    }
  }
  function 𝓟492{$Lambda48} (𝓟493{value}: 𝓛[ty]10051{String}): (𝓟494: [OOV]any)
  {
    const 𝓟495{has} = 𝓛12552{this}.has(𝓟493{value});
    const 𝓟496{result} = 𝓟470{native}.add.apply(𝓛12552{this},𝓛10035{arguments});
    𝓟624{globalState}.event.emit(𝓛8743{String},{target: 𝓟476{target},key: 𝓛12643{undefined},value: 𝓟493{value},oldValue: 𝓛12643{undefined}})
    if (𝓛12569{ExclamationToken}(𝓟495{has}))
    {
      𝓟478{queueRunReactions}(𝓛12552{this},𝓟493{value})
      𝓟478{queueRunReactions}(𝓛12552{this},𝓟471{masterValue})
    }
    return 𝓟494 = 𝓟496{result}
  }
  𝓟476{target}.add ⟵ 𝓟492{$Lambda48};
  function 𝓟497{$Lambda49} (𝓟498{value}: 𝓛[ty]10051{String}): (𝓟499: [OOV]any)
  {
    const 𝓟500{has} = 𝓛12552{this}.has(𝓟498{value});
    const 𝓟501{result} = 𝓟470{native}.delete.apply(𝓛12552{this},𝓛10035{arguments});
    𝓟624{globalState}.event.emit(𝓛8743{String},{target: 𝓟476{target},key: 𝓛12643{undefined}})
    if (𝓟500{has})
    {
      𝓟478{queueRunReactions}(𝓛12552{this},𝓟498{value})
      𝓟478{queueRunReactions}(𝓛12552{this},𝓟471{masterValue})
    }
    return 𝓟499 = 𝓟501{result}
  }
  𝓟476{target}.delete ⟵ 𝓟497{$Lambda49};
  function 𝓟502{$Lambda50} (): (𝓟503: [OOV]any)
  {
    const 𝓟504{size} = 𝓛12552{this}.size;
    const 𝓟505{result} = 𝓟470{native}.clear.apply(𝓛12552{this},𝓛10035{arguments});
    if (𝓟504{size})
    {
      𝓟478{queueRunReactions}(𝓛12552{this},𝓟471{masterValue})
    }
    return 𝓟503 = 𝓟505{result}
  }
  𝓟476{target}.clear ⟵ 𝓟502{$Lambda50};
  function 𝓟506{get} (): (𝓟507: [OOV]any)
  {
    const 𝓟508{proto} = 𝓛8741{Object}.getPrototypeOf(𝓛12552{this});
    const 𝓟509{size} = 𝓛3030{get}(𝓟508{proto},𝓛8743{String},𝓛12552{this});
    𝓟477{bindCurrentReaction}(𝓛12552{this},𝓟471{masterValue})
    return 𝓟507 = 𝓟509{size}
  }
  𝓛8741{Object}.defineProperty(𝓟476{target},𝓛8743{String},{get: 𝓟506{get}})
  return 𝓟480 = 𝓟476{target}
}

Module: src/built-ins/weak-map

type 𝓟[ty]510{IcustomObject} = {$raw: any, access: (𝓛[ty]10051{String})->any}
const 𝓟511{native}: [OOV]any = 𝓛2996{WeakMap}.prototype;
const 𝓟512{getters}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String},𝓛8743{String});
const 𝓟513{all}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String},𝓛8743{String}).concat(𝓟512{getters});
function 𝓟514{shim} (𝓟515{target}: [OOV]any,𝓟516{bindCurrentReaction}: [OOV]any,𝓟517{queueRunReactions}: [OOV]any,𝓟518{proxyValue}: [OOV]any): (𝓟519: [OOV]any)
{
  𝓟515{target}.$raw ⟵ {};
  {
    const 𝓟520{method}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟513{all});
    while (𝓛8744{Boolean})
    {
      function 𝓟521{$Lambda51} (): (𝓟522: [miss]𝓛[ty]10033{Void})
      {
        𝓟511{native}.access(𝓟520{method}).apply(𝓟515{target},𝓛10035{arguments})
      }
      𝓟515{target}.$raw.access(𝓟520{method}) ⟵ 𝓟521{$Lambda51};
    }
  }
  {
    const 𝓟523{getter}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟512{getters});
    while (𝓛8744{Boolean})
    {
      function 𝓟524{$Lambda52} (𝓟525{key}: 𝓛[ty]10051{String}): (𝓟526: [OOV]any)
      {
        let 𝓟527{value} = 𝓟511{native}.access(𝓟523{getter}).apply(𝓛12552{this},𝓛10035{arguments});
        𝓟624{globalState}.event.emit(𝓛8743{String},{target: 𝓟515{target},key: 𝓛12643{undefined},value: 𝓟527{value}})
        𝓟527{value} ⟵ 𝓟518{proxyValue}(𝓛12552{this},𝓟525{key},𝓟527{value});
        𝓟516{bindCurrentReaction}(𝓛12552{this},𝓟525{key})
        return 𝓟526 = 𝓟527{value}
      }
      𝓟515{target}.access(𝓟523{getter}) ⟵ 𝓟524{$Lambda52};
    }
  }
  function 𝓟528{$Lambda53} (𝓟529{key}: 𝓛[ty]10051{String},𝓟530{value}: [OOV]any): (𝓟531: [OOV]any)
  {
    const 𝓟532{oldValue} = 𝓛12552{this}.get(𝓟529{key});
    const 𝓟533{result} = 𝓟511{native}.set.apply(𝓛12552{this},𝓛10035{arguments});
    𝓟624{globalState}.event.emit(𝓛8743{String},{target: 𝓟515{target},key: 𝓟529{key},oldValue: 𝓟532{oldValue},value: 𝓟530{value}})
    if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟532{oldValue},𝓟530{value}))
    {
      𝓟517{queueRunReactions}(𝓛12552{this},𝓟529{key})
    }
    return 𝓟531 = 𝓟533{result}
  }
  𝓟515{target}.set ⟵ 𝓟528{$Lambda53};
  function 𝓟534{$Lambda54} (𝓟535{key}: 𝓛[ty]10051{String}): (𝓟536: [OOV]any)
  {
    const 𝓟537{has} = 𝓛12552{this}.has(𝓟535{key});
    const 𝓟538{result} = 𝓟511{native}.delete.apply(𝓛12552{this},𝓛10035{arguments});
    𝓟624{globalState}.event.emit(𝓛8743{String},{target: 𝓟515{target},key: 𝓟535{key}})
    if (𝓟537{has})
    {
      𝓟517{queueRunReactions}(𝓛12552{this},𝓟535{key})
    }
    return 𝓟536 = 𝓟538{result}
  }
  𝓟515{target}.delete ⟵ 𝓟534{$Lambda54};
  return 𝓟519 = 𝓟515{target}
}

Module: src/utils

type 𝓛[ty]3199{Map} = 𝓛[ty]3199{Map}
type 𝓟[ty]540{Func} = (𝓛[ty]8670{Array})->any
type 𝓛[ty]5956{Set} = 𝓛[ty]5956{Set}
function 𝓟542{isPrimitive} (𝓟543{value}: [OOV]any): (𝓟544: 𝓛[ty]8666{Boolean})
{
  if (𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟543{value},𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓟543{value},𝓛12643{undefined})))
  {
    return 𝓟544 = 𝓛8744{Boolean}
  }
  if (𝓛12546{BarBarToken}(𝓛12546{BarBarToken}(𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟543{value}),𝓛8743{String}),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟543{value}),𝓛8743{String})),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟543{value}),𝓛8743{String})),𝓛1{<UNKNOWN>}(𝓟543{value},𝓛8747{Date})))
  {
    return 𝓟544 = 𝓛8744{Boolean}
  }
  return 𝓟544 = 𝓛8744{Boolean}
}
function 𝓟545{$Lambda13} (): (𝓟546: [miss]𝓛[ty]10033{Void})
{
}
const 𝓟547{noop}: [miss]𝓛[ty]8696{Function} = 𝓟545{$Lambda13};
function 𝓟548{inAction} (): (𝓟549: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟549 = 𝓛12612{ExclamationEqualsEqualsToken}(𝓟624{globalState}.batchDeep,𝓛8745{Number})
}
function 𝓟550{inTrack} (): (𝓟551: [miss]𝓛[ty]8666{Boolean})
{
  return 𝓟551 = 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟624{globalState}.currentReaction))
}
function 𝓟552{getBinder} (𝓟553{object}: [OOV]any,𝓟554{key}: [OOV]𝓛[ty]8640{PropertyKey}): (𝓟555: [miss]𝓛[ty]8642{Object})
{
  let 𝓟556{keysForObject}: [miss]𝓛[ty]3199{Map} = 𝓟624{globalState}.objectReactionBindings.get(𝓟553{object});
  if (𝓛12569{ExclamationToken}(𝓟556{keysForObject}))
  {
    𝓟556{keysForObject} ⟵ 𝓛2995{Map}.CONSTRUCTOR();
    𝓟624{globalState}.objectReactionBindings.set(𝓟553{object},𝓟556{keysForObject})
  }
  let 𝓟557{reactionsForKey}: [miss]𝓛[ty]5956{Set} = 𝓟556{keysForObject}.get(𝓟554{key});
  if (𝓛12569{ExclamationToken}(𝓟557{reactionsForKey}))
  {
    𝓟557{reactionsForKey} ⟵ 𝓛2997{Set}.CONSTRUCTOR();
    𝓟556{keysForObject}.set(𝓟554{key},𝓟557{reactionsForKey})
  }
  return 𝓟555 = {binder: 𝓟556{keysForObject},keyBinder: 𝓟557{reactionsForKey}}
}
function 𝓟558{startDebug} (): (𝓟559: [miss]𝓛[ty]10033{Void})
{
  𝓟624{globalState}.useDebug ⟵ 𝓛8744{Boolean};
}
function 𝓟560{stopDebug} (): (𝓟561: [miss]𝓛[ty]10033{Void})
{
  𝓟624{globalState}.useDebug ⟵ 𝓛8744{Boolean};
}
function 𝓟562{useStrict} (): (𝓟563: [miss]𝓛[ty]10033{Void})
{
  𝓟624{globalState}.strictMode ⟵ 𝓛8744{Boolean};
}
function 𝓟564{cancelStrict} (): (𝓟565: [miss]𝓛[ty]10033{Void})
{
  𝓟624{globalState}.strictMode ⟵ 𝓛8744{Boolean};
}
function 𝓟566{createUniqueId} (): (𝓟567: [miss]𝓛[ty]8655{Number})
{
  return 𝓟567 = 𝓛12556{POST_PlusPlusToken}(𝓟624{globalState}.uniqueIdCounter)
}

Module: demos/atom/index

function 𝓟569{$Async_fetchName} (𝓟570{name}: 𝓛[ty]10051{String}): (𝓟571: [miss]𝓛[ty]8654{Promise})
{
  𝓛12557{$Await}(𝓛1062{Promise}.resolve(𝓛8745{Number}))
  return 𝓟571 = 𝓛12641{PlusToken}(𝓛8743{String},𝓟570{name})
}
function 𝓟572{$Async_fetchAge} (𝓟573{age}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟574: [miss]𝓛[ty]8654{Promise})
{
  𝓛12557{$Await}(𝓛1062{Promise}.resolve(𝓛8745{Number}))
  return 𝓟574 = 𝓛12641{PlusToken}(𝓛8743{String},𝓟573{age})
}
function 𝓟575{CONSTRUCTOR} (): (𝓟[ty]583{Test})
{
  const 𝓟[ty]583{Test};
  const 𝓟[ty]583{Test};
  function 𝓟579{$Async_$Lambda26} (): (𝓟580: [miss]𝓛[ty]8654{Promise})
  {
    return 𝓟580 = 𝓛12557{$Await}(𝓛1{<UNKNOWN>}(𝓟[ty]583{Test}.store.userName))
  }
  function 𝓟581{$Async_$Lambda27} (): (𝓟582: [miss]𝓛[ty]8654{Promise})
  {
    return 𝓟582 = 𝓛12557{$Await}(𝓛1{<UNKNOWN>}(𝓟[ty]583{Test}.store.userAge))
  }
  𝓟[ty]583{Test}.store ⟵ 𝓟644{observable}({userName: 𝓛8743{String},userAge: 𝓛8745{Number}});
  𝓟[ty]583{Test}.age ⟵ 𝓟101{computedAsync}(𝓛8743{String},𝓛1{<UNKNOWN>});
  𝓟[ty]583{Test}.name ⟵ 𝓟101{computedAsync}(𝓛8743{String},𝓛1{<UNKNOWN>});
}
class 𝓟[ty]583{Test}{
  𝓟585{store}: [miss]𝓛[ty]8642{Object};
  𝓟586{name}: [OOV]𝓛[ty]2{<UNKNOWN>};
  𝓟587{age}: [OOV]𝓛[ty]2{<UNKNOWN>};
}
const 𝓟588{test}: [miss]𝓟[ty]583{Test} = 𝓟575{CONSTRUCTOR}();
function 𝓟589{$Lambda28} (): (𝓟590: [miss]𝓛[ty]10033{Void})
{
  𝓛1{<UNKNOWN>}(𝓟588{test}.name.value,𝓟588{test}.age.value)
}
𝓟645{observe}(𝓟589{$Lambda28})
function 𝓟591{$Lambda29} (): (𝓟592: [miss]𝓛[ty]10033{Void})
{
  𝓟588{test}.store.userName ⟵ 𝓛8743{String};
}
𝓛12490{setTimeout}(𝓟591{$Lambda29},𝓛8745{Number})
function 𝓟593{$Lambda30} (): (𝓟594: [miss]𝓛[ty]10033{Void})
{
  𝓟588{test}.store.userAge ⟵ 𝓛8745{Number};
}
𝓛12490{setTimeout}(𝓟593{$Lambda30},𝓛8745{Number})

Module: src/global-state

type 𝓟[ty]595{IDebugInfo} = {id: 𝓛[ty]8655{Number}, name: any, changeList: 𝓛[ty]8670{Array}, type: 𝓛[ty]10051{String}}
type 𝓟[ty]596{IDebugChange} = {key: 𝓛[ty]8640{PropertyKey}, callStack: 𝓛[ty]8670{Array}, oldValue: any, type: 𝓛[ty]10051{String}, value: any, action: 𝓟[ty]595{IDebugInfo}}
const 𝓟597{tag}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
let 𝓟598{global}: [OOV]any;
const 𝓟599{globalOrWindow}: [OOV]any = 𝓛12546{BarBarToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓛12226{self}),𝓛8743{String}),𝓛12559{EqualsEqualsEqualsToken}(𝓛12226{self}.self,𝓛12226{self})),𝓛12226{self}),𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟598{global}),𝓛8743{String}),𝓛12559{EqualsEqualsEqualsToken}(𝓟598{global}.global,𝓟598{global})),𝓟598{global}));
function 𝓟600{CONSTRUCTOR} (): (𝓟[ty]604{GlobalState})
{
  const 𝓟[ty]604{GlobalState};
  const 𝓟[ty]604{GlobalState};
  𝓟[ty]604{GlobalState}.currentReaction ⟵ 𝓛12643{undefined};
  𝓟[ty]604{GlobalState}.pendingTracks ⟵ 𝓛2997{Set}.CONSTRUCTOR();
  𝓟[ty]604{GlobalState}.objectReactionBindings ⟵ 𝓛2996{WeakMap}.CONSTRUCTOR();
  𝓟[ty]604{GlobalState}.event ⟵ 𝓟360{CONSTRUCTOR}();
  𝓟[ty]604{GlobalState}.parentInfo ⟵ 𝓛2996{WeakMap}.CONSTRUCTOR();
  𝓟[ty]604{GlobalState}.batchDeep ⟵ 𝓛8745{Number};
  𝓟[ty]604{GlobalState}.debugOutputActionMapBatchDeep ⟵ 𝓛2995{Map}.CONSTRUCTOR();
  𝓟[ty]604{GlobalState}.pendingReactions ⟵ 𝓛2997{Set}.CONSTRUCTOR();
  𝓟[ty]604{GlobalState}.uniqueIdCounter ⟵ 𝓛8745{Number};
  𝓟[ty]604{GlobalState}.strictMode ⟵ 𝓛8744{Boolean};
  𝓟[ty]604{GlobalState}.currentDebugId ⟵ 𝓛12643{undefined};
  𝓟[ty]604{GlobalState}.useDebug ⟵ 𝓛8744{Boolean};
  𝓟[ty]604{GlobalState}.getCallstackMaxCount ⟵ 𝓛8745{Number};
  𝓟[ty]604{GlobalState}.proxies ⟵ 𝓛2996{WeakMap}.CONSTRUCTOR();
  𝓟[ty]604{GlobalState}.currentDebugOutputAction ⟵ 𝓛12643{undefined};
  𝓟[ty]604{GlobalState}.ignoreDynamicSymbol ⟵ 𝓛10031{Symbol}();
  𝓟[ty]604{GlobalState}.currentDebugName ⟵ 𝓛12643{undefined};
  𝓟[ty]604{GlobalState}.originObjects ⟵ 𝓛2996{WeakMap}.CONSTRUCTOR();
}
class 𝓟[ty]604{GlobalState}{
  𝓟606{proxies}: [miss]𝓛[ty]3191{WeakMap};
  𝓟607{objectReactionBindings}: [miss]𝓛[ty]3191{WeakMap};
  𝓟608{event}: [miss]𝓟[ty]364{Event};
  𝓟609{debugOutputActionMapBatchDeep}: [miss]𝓛[ty]3199{Map};
  𝓟610{pendingReactions}: [miss]𝓛[ty]5956{Set};
  𝓟611{parentInfo}: [miss]𝓛[ty]3191{WeakMap};
  𝓟612{uniqueIdCounter}: [miss]𝓛[ty]8655{Number};
  𝓟613{pendingTracks}: [miss]𝓛[ty]5956{Set};
  𝓟614{currentDebugOutputAction}: [OOV]any;
  𝓟615{batchDeep}: [miss]𝓛[ty]8655{Number};
  𝓟616{originObjects}: [miss]𝓛[ty]3191{WeakMap};
  𝓟617{strictMode}: [miss]𝓛[ty]8666{Boolean};
  𝓟618{currentDebugId}: [OOV]any;
  𝓟619{currentDebugName}: [OOV]any;
  𝓟620{getCallstackMaxCount}: [miss]𝓛[ty]8655{Number};
  𝓟621{useDebug}: [miss]𝓛[ty]8666{Boolean};
  𝓟622{currentReaction}: [OOV]any;
  𝓟623{ignoreDynamicSymbol}: [OOV]𝓛[ty]8691{Symbol};
}
let 𝓟624{globalState}: [miss]𝓟[ty]604{GlobalState} = 𝓟600{CONSTRUCTOR}();
if (𝓟599{globalOrWindow}.access(𝓟597{tag}))
{
  𝓟624{globalState} ⟵ 𝓟599{globalOrWindow}.access(𝓟597{tag});
}
else
{
  𝓟599{globalOrWindow}.access(𝓟597{tag}) ⟵ 𝓟624{globalState};
}

LibAcc: 0.6833=41/60, ProjAcc: 0.5000=4/8, Missing: 277

Module: src/debug

Module: demos/atom/computed-async

Module: src/reaction

Module: demos/debug/index

Module: src/index

Module: demos/async/index

Module: src/built-ins/weak-set

Module: src/observer

Module: src/built-ins/map

Module: src/event/index

Module: src/atom

Module: demos/action/index

Module: src/built-ins/set

Module: src/built-ins/weak-map

Module: src/utils

Module: src/built-ins/index

Module: demos/atom/index

Module: src/global-state

Module: demos/reaction/index

Module: demos/observe-async/index