LibAcc: 0.5712=341/597, ProjAcc: 0.1903=118/620, Missing: 690

Module: packages/funfix-exec/src/cancelable

type 𝓟[ty]1{ICancelable} = {cancel: ()->𝓛[ty]10033{Void}}
type 𝓟[ty]2{IBoolCancelable} extends 𝓟[ty]1{ICancelable} = {isCanceled: ()->𝓛[ty]8666{Boolean}}
type 𝓟[ty]3{IAssignCancelable} extends 𝓟[ty]2{IBoolCancelable} = {update: (𝓟[ty]1{ICancelable})->any}
function 𝓟4{CONSTRUCTOR} (): (𝓟[ty]21{Cancelable})
{
 const 𝓟[ty]21{Cancelable};
 const 𝓟[ty]21{Cancelable};
}
function 𝓟8{of} (𝓟9{cb}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function})): (𝓟10: (𝓟[ty]30{WrapFn} ≠ 𝓟[ty]21{Cancelable}))
{
 return 𝓟10 = 𝓟25{CONSTRUCTOR}(𝓟9{cb})
}
function 𝓟11{empty} (): (𝓟12: (𝓟[ty]40{DummyCancelable} ≠ 𝓟[ty]21{Cancelable}))
{
 return 𝓟12 = 𝓟45{Empty}
}
function 𝓟13{collection} (𝓟14{refs}: (𝓟[ty]928{TimeUnit} ≠ 𝓛[ty]8670{Array})): (𝓟15: (𝓟[ty]71{CollectionCancelable} ≠ 𝓟[ty]21{Cancelable}))
{
 return 𝓟15 = 𝓟66{CONSTRUCTOR}(𝓟14{refs})
}
function 𝓟16{cancelAll} (𝓟17{refs}: 𝓛[ty]8670{Array}): (𝓟18: 𝓛[ty]10033{Void})
{
 let 𝓟19{errors}: [OOV]any = 𝓛12643{undefined};
 {
 const 𝓟20{c}: [miss]𝓟[ty]21{Cancelable} = 𝓛12589{$ArrayAccess}(𝓟17{refs});
 while (𝓛8744{Boolean})
 {
 {
 𝓟20{c}.cancel()
 }
 }
 }
 if (𝓛12569{ExclamationToken}(𝓟19{errors}))
 {
 }
 else
 {
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟19{errors}.length,𝓛8745{Number}))
 {
 𝓟19{errors}.access(𝓛8745{Number})
 }
 else
 {
 𝓟3171{CONSTRUCTOR}(𝓟19{errors})
 }
 }
}
class 𝓟[ty]21{Cancelable} extends 𝓟[ty]1{ICancelable}{
 function 𝓟23{cancel} (): (𝓟24: 𝓛[ty]10033{Void})
 {
 }
}
function 𝓟25{CONSTRUCTOR} (𝓟26{cb}: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]30{WrapFn})
{
 const 𝓟[ty]30{WrapFn};
 const 𝓟[ty]30{WrapFn};
 𝓟[ty]30{WrapFn}()
 𝓟[ty]30{WrapFn}.thunk ⟵ 𝓟26{cb};
}
class 𝓟[ty]30{WrapFn} extends 𝓟[ty]21{Cancelable}{
 𝓟32{thunk}: [OOV]any;
 function 𝓟33{cancel} (): (𝓟34: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟[ty]30{WrapFn}.thunk,𝓛12643{undefined}))
 {
 const 𝓟35{ref}: [miss]𝓛[ty]8696{Function} = 𝓟[ty]30{WrapFn}.thunk;
 𝓟[ty]30{WrapFn}.thunk ⟵ 𝓛12643{undefined};
 𝓟35{ref}()
 }
 }
}
function 𝓟36{CONSTRUCTOR} (): (𝓟[ty]40{DummyCancelable})
{
 const 𝓟[ty]40{DummyCancelable};
 const 𝓟[ty]40{DummyCancelable};
 𝓟[ty]40{DummyCancelable}._funIsDummy ⟵ 𝓛8744{Boolean};
}
class 𝓟[ty]40{DummyCancelable} extends 𝓟[ty]1{ICancelable}{
 𝓟42{_funIsDummy}: [miss]𝓛[ty]8666{Boolean};
 function 𝓟43{cancel} (): (𝓟44: 𝓛[ty]10033{Void})
 {
 }
}
const 𝓟45{Empty}: [OOV]𝓟[ty]1{ICancelable} = 𝓟36{CONSTRUCTOR}();
function 𝓟46{CONSTRUCTOR} (): (𝓟[ty]60{BoolCancelable})
{
 const 𝓟[ty]60{BoolCancelable};
 const 𝓟[ty]60{BoolCancelable};
}
function 𝓟50{of} (𝓟51{cb}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function})): (𝓟52: (𝓟[ty]82{BoolWrapFn} ≠ 𝓟[ty]60{BoolCancelable}))
{
 return 𝓟52 = 𝓟78{CONSTRUCTOR}(𝓟51{cb})
}
function 𝓟53{empty} (): (𝓟54: (𝓟[ty]90{BoolEmpty} ≠ 𝓟[ty]60{BoolCancelable}))
{
 return 𝓟54 = 𝓟86{CONSTRUCTOR}()
}
function 𝓟55{alreadyCanceled} (): (𝓟56: (𝓛[ty]8666{Boolean} ≠ 𝓟[ty]60{BoolCancelable}))
{
 return 𝓟56 = 𝓟105{AlreadyCanceledRef}
}
function 𝓟57{collection} (𝓟58{refs}: (𝓟[ty]928{TimeUnit} ≠ 𝓛[ty]8670{Array})): (𝓟59: (𝓟[ty]71{CollectionCancelable} ≠ 𝓟[ty]60{BoolCancelable}))
{
 return 𝓟59 = 𝓟66{CONSTRUCTOR}(𝓟58{refs})
}
class 𝓟[ty]60{BoolCancelable} extends 𝓟[ty]2{IBoolCancelable}{
 function 𝓟62{isCanceled} (): (𝓟63: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8666{Boolean}))
 {
 }
 function 𝓟64{cancel} (): (𝓟65: 𝓛[ty]10033{Void})
 {
 }
}
function 𝓟66{CONSTRUCTOR} (𝓟67{refs}: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8670{Array})): (𝓟[ty]71{CollectionCancelable})
{
 const 𝓟[ty]71{CollectionCancelable};
 const 𝓟[ty]71{CollectionCancelable};
 𝓟[ty]71{CollectionCancelable}()
 𝓟[ty]71{CollectionCancelable}._refs ⟵ 𝓟67{refs};
}
class 𝓟[ty]71{CollectionCancelable} extends 𝓟[ty]60{BoolCancelable}{
 𝓟73{_refs}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8670{Array});
 function 𝓟74{isCanceled} (): (𝓟75: 𝓛[ty]8666{Boolean})
 {
 return 𝓟75 = 𝓛12569{ExclamationToken}(𝓟[ty]71{CollectionCancelable}._refs)
 }
 function 𝓟76{cancel} (): (𝓟77: 𝓛[ty]10033{Void})
 {
 if (𝓟[ty]71{CollectionCancelable}._refs)
 {
 {
 𝓟16{cancelAll}(𝓟[ty]71{CollectionCancelable}._refs)
 }
 {
 𝓛12622{$Delete}(𝓟[ty]71{CollectionCancelable}._refs)
 }
 }
 }
}
function 𝓟78{CONSTRUCTOR} (): (𝓟[ty]82{BoolWrapFn})
{
 const 𝓟[ty]82{BoolWrapFn};
 const 𝓟[ty]82{BoolWrapFn};
}
class 𝓟[ty]82{BoolWrapFn} extends 𝓟[ty]30{WrapFn} with 𝓟[ty]60{BoolCancelable}{
 function 𝓟84{isCanceled} (): (𝓟85: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟85 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]82{BoolWrapFn}.thunk,𝓛12643{undefined})
 }
}
function 𝓟86{CONSTRUCTOR} (): (𝓟[ty]90{BoolEmpty})
{
 const 𝓟[ty]90{BoolEmpty};
 const 𝓟[ty]90{BoolEmpty};
 𝓟[ty]90{BoolEmpty}.canceled ⟵ 𝓛8744{Boolean};
}
class 𝓟[ty]90{BoolEmpty} extends 𝓟[ty]60{BoolCancelable}{
 𝓟92{canceled}: 𝓛[ty]8666{Boolean};
 function 𝓟93{isCanceled} (): (𝓟94: 𝓛[ty]8666{Boolean})
 {
 return 𝓟94 = 𝓟[ty]90{BoolEmpty}.canceled
 }
 function 𝓟95{cancel} (): (𝓟96: 𝓛[ty]10033{Void})
 {
 𝓟[ty]90{BoolEmpty}.canceled ⟵ 𝓛8744{Boolean};
 }
}
function 𝓟97{CONSTRUCTOR} (): (𝓟[ty]101{AlreadyCanceledBoolCancelable})
{
 const 𝓟[ty]101{AlreadyCanceledBoolCancelable};
 const 𝓟[ty]101{AlreadyCanceledBoolCancelable};
}
class 𝓟[ty]101{AlreadyCanceledBoolCancelable} extends 𝓟[ty]40{DummyCancelable} with 𝓟[ty]2{IBoolCancelable}{
 function 𝓟103{isCanceled} (): (𝓟104: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟104 = 𝓛8744{Boolean}
 }
}
const 𝓟105{AlreadyCanceledRef}: (𝓟[ty]101{AlreadyCanceledBoolCancelable} ≠ 𝓟[ty]60{BoolCancelable}) = 𝓟97{CONSTRUCTOR}();
function 𝓟106{CONSTRUCTOR} (): (𝓟[ty]117{AssignCancelable})
{
 const 𝓟[ty]117{AssignCancelable};
 const 𝓟[ty]117{AssignCancelable};
}
function 𝓟110{alreadyCanceled} (): (𝓟111: (𝓟[ty]800{TSuccess} ≠ 𝓟[ty]117{AssignCancelable}))
{
 return 𝓟111 = 𝓟139{AlreadyCanceledAssignCancelableRef}
}
function 𝓟112{empty} (): (𝓟113: (𝓟[ty]1779{IO} ≠ 𝓟[ty]117{AssignCancelable}))
{
 return 𝓟113 = 𝓟145{empty}()
}
function 𝓟114{of} (𝓟115{cb}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function})): (𝓟116: (𝓟[ty]1779{IO} ≠ 𝓟[ty]117{AssignCancelable}))
{
 return 𝓟116 = 𝓟147{of}(𝓟115{cb})
}
class 𝓟[ty]117{AssignCancelable} extends 𝓟[ty]3{IAssignCancelable}{
 function 𝓟119{update} (𝓟120{value}: [OOV]𝓟[ty]1{ICancelable}): (𝓟121: [OOV]any)
 {
 }
 function 𝓟122{isCanceled} (): (𝓟123: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8666{Boolean}))
 {
 }
 function 𝓟124{cancel} (): (𝓟125: 𝓛[ty]10033{Void})
 {
 }
}
function 𝓟126{CONSTRUCTOR} (): (𝓟[ty]130{AlreadyCanceledAssignCancelable})
{
 const 𝓟[ty]130{AlreadyCanceledAssignCancelable};
 const 𝓟[ty]130{AlreadyCanceledAssignCancelable};
}
class 𝓟[ty]130{AlreadyCanceledAssignCancelable} extends 𝓟[ty]40{DummyCancelable} with 𝓟[ty]3{IAssignCancelable}{
 function 𝓟132{isCanceled} (): (𝓟133: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟133 = 𝓛8744{Boolean}
 }
 function 𝓟134{cancel} (): (𝓟135: [miss]𝓛[ty]10033{Void})
 {
 }
 function 𝓟136{update} (𝓟137{value}: [OOV]𝓟[ty]1{ICancelable}): (𝓟138: [OOV]any)
 {
 𝓟137{value}.cancel()
 return 𝓟138 = 𝓟[ty]130{AlreadyCanceledAssignCancelable}
 }
}
const 𝓟139{AlreadyCanceledAssignCancelableRef}: (𝓟[ty]130{AlreadyCanceledAssignCancelable} ≠ 𝓟[ty]117{AssignCancelable}) = 𝓟126{CONSTRUCTOR}();
function 𝓟140{CONSTRUCTOR} (𝓟141{initial}: [OOV]𝓟[ty]1{ICancelable}): (𝓟[ty]150{MultiAssignCancelable})
{
 const 𝓟[ty]150{MultiAssignCancelable};
 const 𝓟[ty]150{MultiAssignCancelable};
 𝓟[ty]150{MultiAssignCancelable}._underlying ⟵ 𝓟141{initial};
 𝓟[ty]150{MultiAssignCancelable}._canceled ⟵ 𝓛8744{Boolean};
}
function 𝓟145{empty} (): (𝓟146: (𝓟[ty]30{WrapFn} ≠ 𝓟[ty]150{MultiAssignCancelable}))
{
 return 𝓟146 = 𝓟140{CONSTRUCTOR}()
}
function 𝓟147{of} (𝓟148{cb}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟149: (𝓟[ty]30{WrapFn} ≠ 𝓟[ty]150{MultiAssignCancelable}))
{
 return 𝓟149 = 𝓟140{CONSTRUCTOR}(𝓟8{of}(𝓟148{cb}))
}
class 𝓟[ty]150{MultiAssignCancelable} extends 𝓟[ty]3{IAssignCancelable}{
 𝓟152{_underlying}: [OOV]𝓟[ty]1{ICancelable};
 𝓟153{_canceled}: 𝓛[ty]8666{Boolean};
 function 𝓟159{cancel} (): (𝓟160: 𝓛[ty]10033{Void})
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]150{MultiAssignCancelable}._canceled))
 {
 𝓟[ty]150{MultiAssignCancelable}._canceled ⟵ 𝓛8744{Boolean};
 if (𝓟[ty]150{MultiAssignCancelable}._underlying)
 {
 𝓟[ty]150{MultiAssignCancelable}._underlying.cancel()
 𝓛12622{$Delete}(𝓟[ty]150{MultiAssignCancelable}._underlying)
 }
 }
 }
 function 𝓟157{isCanceled} (): (𝓟158: 𝓛[ty]8666{Boolean})
 {
 return 𝓟158 = 𝓟[ty]150{MultiAssignCancelable}._canceled
 }
 function 𝓟164{clear} (): (𝓟165: [OOV]any)
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]150{MultiAssignCancelable}._canceled))
 {
 𝓟[ty]150{MultiAssignCancelable}._underlying ⟵ 𝓛12643{undefined};
 }
 return 𝓟165 = 𝓟[ty]150{MultiAssignCancelable}
 }
 function 𝓟154{update} (𝓟155{value}: [OOV]𝓟[ty]1{ICancelable}): (𝓟156: [OOV]any)
 {
 if (𝓟[ty]150{MultiAssignCancelable}._canceled)
 {
 𝓟155{value}.cancel()
 }
 else
 {
 𝓟[ty]150{MultiAssignCancelable}._underlying ⟵ 𝓟155{value};
 }
 return 𝓟156 = 𝓟[ty]150{MultiAssignCancelable}
 }
 function 𝓟161{collapse} (): (𝓟162: [OOV]any)
 {
 if (𝓛12592{AmpersandAmpersandToken}(𝓟[ty]150{MultiAssignCancelable}._underlying,𝓛1{<UNKNOWN>}(𝓟[ty]150{MultiAssignCancelable}._underlying,𝓛12643{undefined})))
 {
 const 𝓟163{ref}: [miss]𝓟[ty]150{MultiAssignCancelable} = 𝓟[ty]150{MultiAssignCancelable}._underlying;
 𝓟[ty]150{MultiAssignCancelable}._underlying ⟵ 𝓟163{ref}._underlying;
 𝓟[ty]150{MultiAssignCancelable}._canceled ⟵ 𝓟163{ref}._canceled;
 }
 return 𝓟162 = 𝓟[ty]150{MultiAssignCancelable}
 }
}
function 𝓟166{CONSTRUCTOR} (𝓟167{initial}: [OOV]𝓟[ty]1{ICancelable}): (𝓟[ty]176{SerialCancelable})
{
 const 𝓟[ty]176{SerialCancelable};
 const 𝓟[ty]176{SerialCancelable};
 𝓟[ty]176{SerialCancelable}._underlying ⟵ 𝓟167{initial};
 𝓟[ty]176{SerialCancelable}._canceled ⟵ 𝓛8744{Boolean};
}
function 𝓟171{empty} (): (𝓟172: (𝓟[ty]2084{RestartCallback} ≠ 𝓟[ty]176{SerialCancelable}))
{
 return 𝓟172 = 𝓟166{CONSTRUCTOR}()
}
function 𝓟173{of} (𝓟174{cb}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟175: (𝓟[ty]2084{RestartCallback} ≠ 𝓟[ty]176{SerialCancelable}))
{
 return 𝓟175 = 𝓟166{CONSTRUCTOR}(𝓟8{of}(𝓟174{cb}))
}
class 𝓟[ty]176{SerialCancelable} extends 𝓟[ty]3{IAssignCancelable}{
 𝓟178{_underlying}: [OOV]𝓟[ty]1{ICancelable};
 𝓟179{_canceled}: 𝓛[ty]8666{Boolean};
 function 𝓟180{update} (𝓟181{value}: [OOV]𝓟[ty]1{ICancelable}): (𝓟182: [OOV]any)
 {
 if (𝓟[ty]176{SerialCancelable}._canceled)
 {
 𝓟181{value}.cancel()
 }
 else
 {
 if (𝓟[ty]176{SerialCancelable}._underlying)
 {
 𝓟[ty]176{SerialCancelable}._underlying.cancel()
 }
 𝓟[ty]176{SerialCancelable}._underlying ⟵ 𝓟181{value};
 }
 return 𝓟182 = 𝓟[ty]176{SerialCancelable}
 }
 function 𝓟183{isCanceled} (): (𝓟184: 𝓛[ty]8666{Boolean})
 {
 return 𝓟184 = 𝓟[ty]176{SerialCancelable}._canceled
 }
 function 𝓟185{cancel} (): (𝓟186: 𝓛[ty]10033{Void})
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]176{SerialCancelable}._canceled))
 {
 𝓟[ty]176{SerialCancelable}._canceled ⟵ 𝓛8744{Boolean};
 if (𝓟[ty]176{SerialCancelable}._underlying)
 {
 𝓟[ty]176{SerialCancelable}._underlying.cancel()
 𝓛12622{$Delete}(𝓟[ty]176{SerialCancelable}._underlying)
 }
 }
 }
}
function 𝓟187{CONSTRUCTOR} (): (𝓟[ty]197{SingleAssignCancelable})
{
 const 𝓟[ty]197{SingleAssignCancelable};
 const 𝓟[ty]197{SingleAssignCancelable};
 𝓟[ty]197{SingleAssignCancelable}._canceled ⟵ 𝓛8744{Boolean};
 𝓟[ty]197{SingleAssignCancelable}._wasAssigned ⟵ 𝓛8744{Boolean};
}
function 𝓟191{empty} (): (𝓟192: (𝓟[ty]2004{IOAsync} ≠ 𝓟[ty]197{SingleAssignCancelable}))
{
 return 𝓟192 = 𝓟187{CONSTRUCTOR}()
}
function 𝓟193{of} (𝓟194{cb}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟195: (𝓟[ty]2004{IOAsync} ≠ 𝓟[ty]197{SingleAssignCancelable}))
{
 const 𝓟196{ref}: [miss]𝓟[ty]197{SingleAssignCancelable} = 𝓟187{CONSTRUCTOR}();
 𝓟196{ref}.update(𝓟8{of}(𝓟194{cb}))
 return 𝓟195 = 𝓟196{ref}
}
class 𝓟[ty]197{SingleAssignCancelable} extends 𝓟[ty]3{IAssignCancelable}{
 𝓟199{_wasAssigned}: 𝓛[ty]8666{Boolean};
 𝓟200{_canceled}: 𝓛[ty]8666{Boolean};
 𝓟201{_underlying}: [OOV]𝓟[ty]1{ICancelable};
 function 𝓟202{update} (𝓟203{value}: [OOV]𝓟[ty]1{ICancelable}): (𝓟204: [OOV]any)
 {
 if (𝓟[ty]197{SingleAssignCancelable}._wasAssigned)
 {
 𝓟3209{CONSTRUCTOR}(𝓛8743{String})
 }
 𝓟[ty]197{SingleAssignCancelable}._wasAssigned ⟵ 𝓛8744{Boolean};
 if (𝓟[ty]197{SingleAssignCancelable}._canceled)
 {
 𝓟203{value}.cancel()
 }
 else
 {
 𝓟[ty]197{SingleAssignCancelable}._underlying ⟵ 𝓟203{value};
 }
 return 𝓟204 = 𝓟[ty]197{SingleAssignCancelable}
 }
 function 𝓟205{isCanceled} (): (𝓟206: 𝓛[ty]8666{Boolean})
 {
 return 𝓟206 = 𝓟[ty]197{SingleAssignCancelable}._canceled
 }
 function 𝓟207{cancel} (): (𝓟208: 𝓛[ty]10033{Void})
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]197{SingleAssignCancelable}._canceled))
 {
 𝓟[ty]197{SingleAssignCancelable}._canceled ⟵ 𝓛8744{Boolean};
 if (𝓟[ty]197{SingleAssignCancelable}._underlying)
 {
 𝓟[ty]197{SingleAssignCancelable}._underlying.cancel()
 𝓛12622{$Delete}(𝓟[ty]197{SingleAssignCancelable}._underlying)
 }
 }
 }
}
function 𝓟209{CONSTRUCTOR} (𝓟210{initial}: 𝓛[ty]8670{Array}): (𝓟[ty]219{StackedCancelable})
{
 const 𝓟[ty]219{StackedCancelable};
 const 𝓟[ty]219{StackedCancelable};
 𝓟[ty]219{StackedCancelable}._refs ⟵ (𝓟210{initial} ? 𝓟210{initial}.slice(𝓛8745{Number}) : 𝓛8757{Array}();
}
function 𝓟214{empty} (): (𝓟215: 𝓟[ty]219{StackedCancelable})
{
 return 𝓟215 = 𝓟209{CONSTRUCTOR}()
}
function 𝓟216{collection} (𝓟217{refs}: (𝓟[ty]928{TimeUnit} ≠ 𝓛[ty]8670{Array})): (𝓟218: 𝓟[ty]219{StackedCancelable})
{
 return 𝓟218 = 𝓟209{CONSTRUCTOR}(𝓟217{refs})
}
class 𝓟[ty]219{StackedCancelable} extends 𝓟[ty]2{IBoolCancelable}{
 𝓟221{_refs}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8670{Array});
 function 𝓟222{cancel} (): (𝓟223: 𝓛[ty]10033{Void})
 {
 if (𝓟[ty]219{StackedCancelable}._refs)
 {
 {
 𝓟16{cancelAll}(𝓟[ty]219{StackedCancelable}._refs)
 }
 {
 𝓛12622{$Delete}(𝓟[ty]219{StackedCancelable}._refs)
 }
 }
 }
 function 𝓟224{isCanceled} (): (𝓟225: 𝓛[ty]8666{Boolean})
 {
 return 𝓟225 = 𝓛12569{ExclamationToken}(𝓟[ty]219{StackedCancelable}._refs)
 }
 function 𝓟226{push} (𝓟227{value}: [OOV]𝓟[ty]1{ICancelable}): (𝓟228: [OOV]any)
 {
 if (𝓟[ty]219{StackedCancelable}._refs)
 {
 𝓟[ty]219{StackedCancelable}._refs.push(𝓟227{value})
 }
 else
 {
 𝓟227{value}.cancel()
 }
 return 𝓟228 = 𝓟[ty]219{StackedCancelable}
 }
 function 𝓟229{pop} (): (𝓟230: [OOV]𝓟[ty]1{ICancelable})
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]219{StackedCancelable}._refs))
 {
 return 𝓟230 = 𝓟11{empty}()
 }
 return 𝓟230 = 𝓛12546{BarBarToken}(𝓟[ty]219{StackedCancelable}._refs.pop(),𝓟11{empty}())
 }
}
function 𝓟231{CONSTRUCTOR} (𝓟232{initial}: [OOV]𝓟[ty]1{ICancelable}): (𝓟[ty]238{ChainedCancelable})
{
 const 𝓟[ty]238{ChainedCancelable};
 const 𝓟[ty]238{ChainedCancelable};
 𝓟[ty]238{ChainedCancelable}._underlying ⟵ 𝓛12546{BarBarToken}(𝓟232{initial},𝓟45{Empty});
 𝓟[ty]238{ChainedCancelable}._chained ⟵ 𝓛8744{Boolean};
}
function 𝓟236{empty} (): (𝓟237: (𝓟[ty]2477{Now} ≠ 𝓟[ty]238{ChainedCancelable}))
{
 return 𝓟237 = 𝓟231{CONSTRUCTOR}()
}
class 𝓟[ty]238{ChainedCancelable} extends 𝓟[ty]3{IAssignCancelable}{
 𝓟240{_underlying}: [OOV]𝓟[ty]1{ICancelable};
 𝓟241{_chained}: 𝓛[ty]8666{Boolean};
 function 𝓟245{cancel} (): (𝓟246: 𝓛[ty]10033{Void})
 {
 if (𝓟[ty]238{ChainedCancelable}._underlying)
 {
 𝓟[ty]238{ChainedCancelable}._underlying.cancel()
 𝓟[ty]238{ChainedCancelable}._chained ⟵ 𝓛8744{Boolean};
 𝓛12622{$Delete}(𝓟[ty]238{ChainedCancelable}._underlying)
 }
 }
 function 𝓟249{isCanceled} (): (𝓟250: 𝓛[ty]8666{Boolean})
 {
 return 𝓟250 = 𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟[ty]238{ChainedCancelable}._underlying),𝓛12592{AmpersandAmpersandToken}(𝓟[ty]238{ChainedCancelable}._chained,𝓟[ty]238{ChainedCancelable}._underlying as 𝓟[ty]238{ChainedCancelable}.isCanceled()))
 }
 function 𝓟247{clear} (): (𝓟248: 𝓛[ty]10033{Void})
 {
 if (𝓟[ty]238{ChainedCancelable}._underlying)
 {
 𝓟[ty]238{ChainedCancelable}._underlying ⟵ 𝓟45{Empty};
 𝓟[ty]238{ChainedCancelable}._chained ⟵ 𝓛8744{Boolean};
 }
 }
 function 𝓟251{chainTo} (𝓟252{other}: (𝓟[ty]1779{IO} ≠ 𝓟[ty]238{ChainedCancelable})): (𝓟253: [OOV]any)
 {
 if (𝓛12569{ExclamationToken}(𝓟252{other}))
 {
 𝓟3217{CONSTRUCTOR}(𝓛8743{String})
 }
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟252{other},𝓟[ty]238{ChainedCancelable}))
 {
 return 𝓟253 = 𝓟[ty]238{ChainedCancelable}
 }
 if (𝓛12569{ExclamationToken}(𝓟[ty]238{ChainedCancelable}._underlying))
 {
 𝓟252{other}.cancel()
 return 𝓟253 = 𝓟[ty]238{ChainedCancelable}
 }
 let 𝓟254{ref}: [OOV]any = 𝓟252{other};
 let 𝓟255{keepSearching}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
 while (𝓛12592{AmpersandAmpersandToken}(𝓟254{ref},𝓟255{keepSearching}))
 {
 if (𝓟254{ref}._chained)
 {
 const 𝓟256{ref2}: [OOV]any = 𝓟254{ref}._underlying;
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟256{ref2},𝓟[ty]238{ChainedCancelable}))
 {
 return 𝓟253 = 𝓟[ty]238{ChainedCancelable}
 }
 𝓟254{ref} ⟵ 𝓟256{ref2} as 𝓟[ty]238{ChainedCancelable};
 𝓟255{keepSearching} ⟵ 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓟256{ref2}));
 }
 else
 {
 if (𝓛12569{ExclamationToken}(𝓟254{ref}._underlying))
 {
 𝓟254{ref} ⟵ 𝓛12643{undefined};
 }
 𝓟255{keepSearching} ⟵ 𝓛8744{Boolean};
 }
 }
 if (𝓛12569{ExclamationToken}(𝓟254{ref}))
 {
 𝓟[ty]238{ChainedCancelable}.cancel()
 }
 else
 {
 const 𝓟257{prev}: [OOV]𝓟[ty]1{ICancelable} = 𝓟[ty]238{ChainedCancelable}._underlying;
 𝓟[ty]238{ChainedCancelable}._underlying ⟵ 𝓟254{ref};
 𝓟[ty]238{ChainedCancelable}._chained ⟵ 𝓛8744{Boolean};
 if (𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟257{prev},𝓛12643{undefined})))
 {
 𝓟254{ref}.update(𝓟257{prev})
 }
 }
 return 𝓟253 = 𝓟[ty]238{ChainedCancelable}
 }
 function 𝓟242{update} (𝓟243{value}: [OOV]𝓟[ty]1{ICancelable}): (𝓟244: [OOV]any)
 {
 if (𝓛12569{ExclamationToken}(𝓟243{value}))
 {
 𝓟3217{CONSTRUCTOR}(𝓛8743{String})
 }
 if (𝓛12569{ExclamationToken}(𝓟[ty]238{ChainedCancelable}._underlying))
 {
 𝓟243{value}.cancel()
 return 𝓟244 = 𝓟[ty]238{ChainedCancelable}
 }
 else
 {
 if (𝓟[ty]238{ChainedCancelable}._chained)
 {
 𝓟[ty]238{ChainedCancelable}._underlying as 𝓟[ty]238{ChainedCancelable}.update(𝓟243{value})
 return 𝓟244 = 𝓟[ty]238{ChainedCancelable}
 }
 else
 {
 𝓟[ty]238{ChainedCancelable}._underlying ⟵ 𝓟243{value};
 return 𝓟244 = 𝓟[ty]238{ChainedCancelable}
 }
 }
 }
}

Module: packages/funfix-effect/src/index

Module: test-common/apply-tests

function 𝓟258{applyCheck} (𝓟259{genFA}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟260{genAtoB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟261{genBtoC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟262{genFAtoB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟263{genFBtoC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟264{check}: 𝓛[ty]8696{Function},𝓟265{F}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟266{lawsRef}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟267{includeSuperTypes}: 𝓛[ty]8666{Boolean}): (𝓟268: [miss]𝓛[ty]10033{Void})
{
 const 𝓟269{laws} = 𝓛12546{BarBarToken}(𝓟266{lawsRef},𝓟3244{ApplyLaws}.CONSTRUCTOR(𝓟265{F}));
 if (𝓟267{includeSuperTypes})
 {
 𝓟893{functorCheck}(𝓟259{genFA},𝓟260{genAtoB},𝓟261{genBtoC},𝓟264{check},𝓟265{F},𝓟269{laws})
 }
 function 𝓟270{$Lambda4} (𝓟271{fa},𝓟272{fab},𝓟273{fbc}): (𝓟274: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟274 = 𝓟264{check}(𝓟269{laws}.applyComposition(𝓟271{fa},𝓟272{fab},𝓟273{fbc}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟259{genFA},𝓟262{genFAtoB},𝓟263{genFBtoC},𝓟270{$Lambda4})
}

Module: packages/funfix-core/src/internals

function 𝓟275{convertToMethod} (𝓟276{f}: 𝓛[ty]8696{Function}): (𝓟277: 𝓛[ty]8696{Function})
{
 function 𝓟278{$Lambda41} (𝓟279{this}: [OOV]any): (𝓟280: [OOV]any)
 {
 const 𝓟281{args} = 𝓛8757{Array}.prototype.slice.call(𝓛10035{arguments});
 𝓟281{args}.push(𝓟279{this})
 return 𝓟280 = 𝓟276{f}.apply(𝓛12643{undefined},𝓟281{args})
 }
 return 𝓟277 = 𝓟278{$Lambda41}
}
function 𝓟282{fantasyLandRegister} (𝓟283{cls}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟284{monad}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟285{setoid}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟286: 𝓛[ty]10033{Void})
{
 const 𝓟287{c} = 𝓟283{cls} as any;
 const 𝓟288{p} = 𝓟287{c}.prototype;
 const 𝓟289{fl}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
 const 𝓟290{equals}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
 const 𝓟291{flEquals}: [miss]𝓛[ty]10051{String} = 𝓛12641{PlusToken}(𝓟289{fl},𝓟290{equals});
 const 𝓟292{map}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
 const 𝓟293{flMap}: [miss]𝓛[ty]10051{String} = 𝓛12641{PlusToken}(𝓟289{fl},𝓟292{map});
 const 𝓟294{ap}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
 const 𝓟295{flAp}: [miss]𝓛[ty]10051{String} = 𝓛12641{PlusToken}(𝓟289{fl},𝓟294{ap});
 const 𝓟296{flOf}: [miss]𝓛[ty]10051{String} = 𝓛12641{PlusToken}(𝓟289{fl},𝓛8743{String});
 const 𝓟297{chain}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
 const 𝓟298{flChain}: [miss]𝓛[ty]10051{String} = 𝓛12641{PlusToken}(𝓟289{fl},𝓟297{chain});
 const 𝓟299{chainRec}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
 const 𝓟300{flChainRec}: [miss]𝓛[ty]10051{String} = 𝓛12641{PlusToken}(𝓟289{fl},𝓟299{chainRec});
 if (𝓟288{p}.access(𝓟290{equals}))
 {
 𝓟288{p}.access(𝓟291{flEquals}) ⟵ 𝓟288{p}.access(𝓟290{equals});
 }
 else
 {
 if (𝓟285{setoid})
 {
 𝓟288{p}.access(𝓟291{flEquals}) ⟵ 𝓟275{convertToMethod}(𝓟285{setoid}.equals);
 }
 }
 if (𝓟288{p}.access(𝓟292{map}))
 {
 𝓟288{p}.access(𝓟293{flMap}) ⟵ 𝓟288{p}.access(𝓟292{map});
 }
 else
 {
 if (𝓟284{monad})
 {
 𝓟288{p}.access(𝓟293{flMap}) ⟵ 𝓟275{convertToMethod}(𝓟284{monad}.map);
 }
 }
 if (𝓟288{p}.access(𝓟294{ap}))
 {
 𝓟288{p}.access(𝓟295{flAp}) ⟵ 𝓟288{p}.access(𝓟294{ap});
 }
 else
 {
 if (𝓟284{monad})
 {
 𝓟288{p}.access(𝓟295{flAp}) ⟵ 𝓟275{convertToMethod}(𝓟284{monad}.ap);
 }
 }
 if (𝓟287{c}.access(𝓛8743{String}))
 {
 𝓟287{c}.access(𝓟296{flOf}) ⟵ 𝓟287{c}.access(𝓛8743{String});
 }
 else
 {
 if (𝓟284{monad})
 {
 𝓟287{c}.access(𝓟296{flOf}) ⟵ 𝓟284{monad}.of;
 }
 }
 if (𝓟288{p}.access(𝓟297{chain}))
 {
 𝓟288{p}.access(𝓟298{flChain}) ⟵ 𝓟288{p}.access(𝓟297{chain});
 }
 else
 {
 if (𝓟284{monad})
 {
 𝓟288{p}.access(𝓟298{flChain}) ⟵ 𝓟275{convertToMethod}(𝓟284{monad}.chain);
 }
 }
 if (𝓟287{c}.access(𝓟299{chainRec}))
 {
 𝓟287{c}.access(𝓟300{flChainRec}) ⟵ 𝓟287{c}.access(𝓟299{chainRec});
 }
 else
 {
 if (𝓟284{monad})
 {
 𝓟287{c}.access(𝓟300{flChainRec}) ⟵ 𝓟284{monad}.chainRec;
 }
 }
}

Module: packages/funfix-core/src/disjunctions

type 𝓟[ty]301{TryTypes} = any
type 𝓟[ty]302{OptionTypes} = any
type 𝓟[ty]303{EitherTypes} = any
const 𝓟304{_Class}: (𝓛[ty]10051{String} ≠ 𝓟[ty]362{Either});
function 𝓟305{CONSTRUCTOR} (𝓟306{value}: [OOV]any,𝓟307{tag}: [OOV]any): (𝓟[ty]362{Either})
{
 const 𝓟[ty]362{Either};
 const 𝓟[ty]362{Either};
 𝓟[ty]362{Either}._isRight ⟵ 𝓛12559{EqualsEqualsEqualsToken}(𝓟307{tag},𝓛8743{String});
 𝓟[ty]362{Either}.value ⟵ 𝓟306{value};
}
function 𝓟311{pure} (𝓟312{value}: [OOV]any): (𝓟313: (𝓟[ty]441{TRight} ≠ 𝓟[ty]362{Either}))
{
 return 𝓟313 = 𝓟436{CONSTRUCTOR}(𝓟312{value})
}
function 𝓟314{left} (𝓟315{value}: [OOV]any): (𝓟316: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
{
 return 𝓟316 = 𝓟433{Left}(𝓟315{value})
}
function 𝓟317{right} (𝓟318{value}: [OOV]any): (𝓟319: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
{
 return 𝓟319 = 𝓟444{Right}(𝓟318{value})
}
function 𝓟320{map2} (𝓟321{fa1}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟322{fa2}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟323{f}: 𝓛[ty]8696{Function}): (𝓟324: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
{
 if (𝓟321{fa1}.isLeft())
 {
 return 𝓟324 = 𝓟321{fa1}
 }
 if (𝓟322{fa2}.isLeft())
 {
 return 𝓟324 = 𝓟322{fa2}
 }
 return 𝓟324 = 𝓟444{Right}(𝓟323{f}(𝓟321{fa1}.value as 𝓛[ty]2{<UNKNOWN>},𝓟322{fa2}.value as 𝓛[ty]2{<UNKNOWN>}))
}
function 𝓟325{map3} (𝓟326{fa1}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟327{fa2}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟328{fa3}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟329{f}: 𝓛[ty]8696{Function}): (𝓟330: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
{
 if (𝓟326{fa1}.isLeft())
 {
 return 𝓟330 = 𝓟326{fa1}
 }
 if (𝓟327{fa2}.isLeft())
 {
 return 𝓟330 = 𝓟327{fa2}
 }
 if (𝓟328{fa3}.isLeft())
 {
 return 𝓟330 = 𝓟328{fa3}
 }
 return 𝓟330 = 𝓟444{Right}(𝓟329{f}(𝓟326{fa1}.value as 𝓛[ty]2{<UNKNOWN>},𝓟327{fa2}.value as 𝓛[ty]2{<UNKNOWN>},𝓟328{fa3}.value as 𝓛[ty]2{<UNKNOWN>}))
}
function 𝓟331{map4} (𝓟332{fa1}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟333{fa2}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟334{fa3}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟335{fa4}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟336{f}: 𝓛[ty]8696{Function}): (𝓟337: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
{
 if (𝓟332{fa1}.isLeft())
 {
 return 𝓟337 = 𝓟332{fa1}
 }
 if (𝓟333{fa2}.isLeft())
 {
 return 𝓟337 = 𝓟333{fa2}
 }
 if (𝓟334{fa3}.isLeft())
 {
 return 𝓟337 = 𝓟334{fa3}
 }
 if (𝓟335{fa4}.isLeft())
 {
 return 𝓟337 = 𝓟335{fa4}
 }
 return 𝓟337 = 𝓟444{Right}(𝓟336{f}(𝓟332{fa1}.value as 𝓛[ty]2{<UNKNOWN>},𝓟333{fa2}.value as 𝓛[ty]2{<UNKNOWN>},𝓟334{fa3}.value as 𝓛[ty]2{<UNKNOWN>},𝓟335{fa4}.value as 𝓛[ty]2{<UNKNOWN>}))
}
function 𝓟338{map5} (𝓟339{fa1}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟340{fa2}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟341{fa3}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟342{fa4}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟343{fa5}: (𝓟[ty]2477{Now} ≠ 𝓟[ty]362{Either}),𝓟344{f}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8696{Function})): (𝓟345: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
{
 if (𝓟339{fa1}.isLeft())
 {
 return 𝓟345 = 𝓟339{fa1}
 }
 if (𝓟340{fa2}.isLeft())
 {
 return 𝓟345 = 𝓟340{fa2}
 }
 if (𝓟341{fa3}.isLeft())
 {
 return 𝓟345 = 𝓟341{fa3}
 }
 if (𝓟342{fa4}.isLeft())
 {
 return 𝓟345 = 𝓟342{fa4}
 }
 if (𝓟343{fa5}.isLeft())
 {
 return 𝓟345 = 𝓟343{fa5}
 }
 return 𝓟345 = 𝓟444{Right}(𝓟344{f}(𝓟339{fa1}.value as 𝓛[ty]2{<UNKNOWN>},𝓟340{fa2}.value as 𝓛[ty]2{<UNKNOWN>},𝓟341{fa3}.value as 𝓛[ty]2{<UNKNOWN>},𝓟342{fa4}.value as 𝓛[ty]2{<UNKNOWN>},𝓟343{fa5}.value as 𝓛[ty]2{<UNKNOWN>}))
}
function 𝓟346{map6} (𝓟347{fa1}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟348{fa2}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟349{fa3}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟350{fa4}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}),𝓟351{fa5}: (𝓟[ty]2477{Now} ≠ 𝓟[ty]362{Either}),𝓟352{fa6}: (𝓟[ty]2477{Now} ≠ 𝓟[ty]362{Either}),𝓟353{f}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8696{Function})): (𝓟354: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
{
 if (𝓟347{fa1}.isLeft())
 {
 return 𝓟354 = 𝓟347{fa1}
 }
 if (𝓟348{fa2}.isLeft())
 {
 return 𝓟354 = 𝓟348{fa2}
 }
 if (𝓟349{fa3}.isLeft())
 {
 return 𝓟354 = 𝓟349{fa3}
 }
 if (𝓟350{fa4}.isLeft())
 {
 return 𝓟354 = 𝓟350{fa4}
 }
 if (𝓟351{fa5}.isLeft())
 {
 return 𝓟354 = 𝓟351{fa5}
 }
 if (𝓟352{fa6}.isLeft())
 {
 return 𝓟354 = 𝓟352{fa6}
 }
 return 𝓟354 = 𝓟444{Right}(𝓟353{f}(𝓟347{fa1}.value as 𝓛[ty]2{<UNKNOWN>},𝓟348{fa2}.value as 𝓛[ty]2{<UNKNOWN>},𝓟349{fa3}.value as 𝓛[ty]2{<UNKNOWN>},𝓟350{fa4}.value as 𝓛[ty]2{<UNKNOWN>},𝓟351{fa5}.value as 𝓛[ty]2{<UNKNOWN>},𝓟352{fa6}.value as 𝓛[ty]2{<UNKNOWN>}))
}
function 𝓟355{tailRecM} (𝓟356{a}: [OOV]any,𝓟357{f}: 𝓛[ty]8696{Function}): (𝓟358: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
{
 let 𝓟359{cursor}: [OOV]any = 𝓟356{a};
 while (𝓛8744{Boolean})
 {
 const 𝓟360{result}: [miss]𝓟[ty]362{Either} = 𝓟357{f}(𝓟359{cursor});
 if (𝓛12569{ExclamationToken}(𝓟360{result}.isRight()))
 {
 return 𝓟358 = 𝓟360{result} as any
 }
 const 𝓟361{some}: [miss]𝓟[ty]362{Either} = 𝓟360{result}.value;
 if (𝓟361{some}.isRight())
 {
 return 𝓟358 = 𝓟444{Right}(𝓟361{some}.value)
 }
 𝓟359{cursor} ⟵ 𝓟361{some}.value as 𝓛[ty]2{<UNKNOWN>};
 }
}
class 𝓟[ty]362{Either} extends 𝓟[ty]3110{IEquals}{
 𝓟364{_L}: [OOV]any;
 𝓟365{_URI}: 𝓛[ty]10051{String};
 𝓟366{_isRight}: 𝓛[ty]8666{Boolean};
 𝓟367{_A}: [OOV]any;
 𝓟368{value}: [OOV]any;
 function 𝓟418{toOption} (): (𝓟419: (𝓟[ty]1779{IO} ≠ 𝓟[ty]533{Option}))
 {
 return 𝓟419 = (𝓟[ty]362{Either}._isRight ? 𝓟614{Some}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>}) : 𝓟624{None}
 }
 function 𝓟410{map} (𝓟411{f}: 𝓛[ty]8696{Function}): (𝓟412: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
 {
 return 𝓟412 = (𝓟[ty]362{Either}._isRight ? 𝓟444{Right}(𝓟411{f}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>})) : 𝓟[ty]362{Either} as any
 }
 function 𝓟420{equals} (𝓟421{that}: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either})): (𝓟422: 𝓛[ty]8666{Boolean})
 {
 if (𝓛12599{EqualsEqualsToken}(𝓟421{that},𝓛12643{undefined}))
 {
 return 𝓟422 = 𝓛8744{Boolean}
 }
 return 𝓟422 = 𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]362{Either}._isRight,𝓟421{that}._isRight),𝓟3114{is}(𝓟[ty]362{Either}.value,𝓟421{that}.value))
 }
 function 𝓟407{getOrElseL} (𝓟408{thunk}: 𝓛[ty]8696{Function}): (𝓟409: [OOV]any)
 {
 return 𝓟409 = (𝓟[ty]362{Either}._isRight ? 𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>} : 𝓟408{thunk}()
 }
 function 𝓟369{isLeft} (): (𝓟370: 𝓛[ty]8666{Boolean})
 {
 return 𝓟370 = 𝓛12569{ExclamationToken}(𝓟[ty]362{Either}._isRight)
 }
 function 𝓟389{ap} (𝓟390{ff}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either})): (𝓟391: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
 {
 function 𝓟392{$Lambda18} (𝓟393{f}): (𝓟394: [miss]𝓟[ty]362{Either})
 {
 return 𝓟394 = 𝓟[ty]362{Either}.map(𝓟393{f})
 }
 return 𝓟391 = 𝓟390{ff}.flatMap(𝓟392{$Lambda18})
 }
 function 𝓟395{fold} (𝓟396{left}: 𝓛[ty]8696{Function},𝓟397{right}: 𝓛[ty]8696{Function}): (𝓟398: [OOV]any)
 {
 return 𝓟398 = (𝓟[ty]362{Either}._isRight ? 𝓟397{right}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>}) : 𝓟396{left}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>})
 }
 function 𝓟413{forEach} (𝓟414{cb}: 𝓛[ty]8696{Function}): (𝓟415: 𝓛[ty]10033{Void})
 {
 if (𝓟[ty]362{Either}._isRight)
 {
 𝓟414{cb}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>})
 }
 }
 function 𝓟383{flatMap} (𝓟384{f}: 𝓛[ty]8696{Function}): (𝓟385: (𝓟[ty]1779{IO} ≠ 𝓟[ty]362{Either}))
 {
 return 𝓟385 = (𝓟[ty]362{Either}._isRight ? 𝓟384{f}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>}) : 𝓟[ty]362{Either} as any
 }
 function 𝓟404{getOrElse} (𝓟405{fallback}: [OOV]any): (𝓟406: [OOV]any)
 {
 return 𝓟406 = (𝓟[ty]362{Either}._isRight ? 𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>} : 𝓟405{fallback}
 }
 function 𝓟371{isRight} (): (𝓟372: 𝓛[ty]8666{Boolean})
 {
 return 𝓟372 = 𝓟[ty]362{Either}._isRight
 }
 function 𝓟376{exists} (𝓟377{p}: 𝓛[ty]8696{Function}): (𝓟378: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8666{Boolean}))
 {
 return 𝓟378 = 𝓛12592{AmpersandAmpersandToken}(𝓟[ty]362{Either}._isRight,𝓟377{p}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>}))
 }
 function 𝓟416{swap} (): (𝓟417: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}))
 {
 return 𝓟417 = (𝓟[ty]362{Either}._isRight ? 𝓟433{Left}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>}) : 𝓟444{Right}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>})
 }
 function 𝓟379{filterOrElse} (𝓟380{p}: 𝓛[ty]8696{Function},𝓟381{zero}: 𝓛[ty]8696{Function}): (𝓟382: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
 {
 return 𝓟382 = (𝓟[ty]362{Either}._isRight ? (𝓟380{p}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>}) ? 𝓟[ty]362{Either} as any : 𝓟433{Left}(𝓟381{zero}()) : 𝓟[ty]362{Either} as any
 }
 function 𝓟402{get} (): (𝓟403: [OOV]any)
 {
 if (𝓟[ty]362{Either}._isRight)
 {
 return 𝓟403 = 𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>}
 }
 𝓟3193{CONSTRUCTOR}(𝓛8743{String})
 }
 function 𝓟373{contains} (𝓟374{elem}: [OOV]any): (𝓟375: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8666{Boolean}))
 {
 return 𝓟375 = 𝓛12592{AmpersandAmpersandToken}(𝓟[ty]362{Either}._isRight,𝓟3114{is}(𝓟[ty]362{Either}.value,𝓟374{elem}))
 }
 function 𝓟399{forAll} (𝓟400{p}: 𝓛[ty]8696{Function}): (𝓟401: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8666{Boolean}))
 {
 return 𝓟401 = 𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟[ty]362{Either}._isRight),𝓟400{p}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>}))
 }
 function 𝓟386{chain} (𝓟387{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟388: (𝓟[ty]533{Option} ≠ 𝓟[ty]362{Either}))
 {
 return 𝓟388 = 𝓟[ty]362{Either}.flatMap(𝓟387{f})
 }
 function 𝓟423{hashCode} (): (𝓟424: 𝓛[ty]8655{Number})
 {
 return 𝓟424 = (𝓟[ty]362{Either}._isRight ? 𝓛12560{LessThanLessThanToken}(𝓟3125{hashCode}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>}),𝓛8745{Number}) : 𝓛12560{LessThanLessThanToken}(𝓟3125{hashCode}(𝓟[ty]362{Either}.value as 𝓛[ty]2{<UNKNOWN>}),𝓛8745{Number})
 }
}
function 𝓟425{CONSTRUCTOR} (𝓟426{value}: [OOV]any): (𝓟[ty]430{TLeft})
{
 const 𝓟[ty]430{TLeft};
 const 𝓟[ty]430{TLeft};
 𝓟[ty]430{TLeft}(𝓟426{value},𝓛8743{String})
}
class 𝓟[ty]430{TLeft} extends 𝓟[ty]362{Either}{
 𝓟432{value}: [OOV]any;
}
function 𝓟433{Left} (𝓟434{value}: [OOV]any): (𝓟435: (𝓟[ty]219{StackedCancelable} ≠ 𝓟[ty]430{TLeft}))
{
 return 𝓟435 = 𝓟425{CONSTRUCTOR}(𝓟434{value})
}
function 𝓟436{CONSTRUCTOR} (𝓟437{value}: [OOV]any): (𝓟[ty]441{TRight})
{
 const 𝓟[ty]441{TRight};
 const 𝓟[ty]441{TRight};
 𝓟[ty]441{TRight}(𝓟437{value},𝓛8743{String})
}
class 𝓟[ty]441{TRight} extends 𝓟[ty]362{Either}{
 𝓟443{value}: [OOV]any;
}
function 𝓟444{Right} (𝓟445{value}: [OOV]any): (𝓟446: 𝓟[ty]441{TRight})
{
 return 𝓟446 = 𝓟436{CONSTRUCTOR}(𝓟445{value})
}
function 𝓟447{$Lambda19} (𝓟448{x},𝓟449{y}): (𝓟450: [OOV]any)
{
 return 𝓟450 = (𝓟448{x} ? 𝓟448{x}.equals(𝓟449{y}) : 𝓛12569{ExclamationToken}(𝓟449{y})
}
function 𝓟451{$Lambda20} (𝓟452{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟453{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either})): (𝓟454: [miss]𝓟[ty]362{Either})
{
 return 𝓟454 = 𝓟453{fa}.map(𝓟452{f})
}
function 𝓟455{$Lambda21} (𝓟456{ff}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]362{Either}),𝓟457{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either})): (𝓟458: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
{
 return 𝓟458 = 𝓟457{fa}.ap(𝓟456{ff})
}
function 𝓟459{$Lambda22} (𝓟460{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟461{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either})): (𝓟462: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]362{Either}))
{
 return 𝓟462 = 𝓟461{fa}.flatMap(𝓟460{f})
}
function 𝓟463{$Lambda23} (𝓟464{f}: 𝓛[ty]8696{Function},𝓟465{a}: [OOV]any): (𝓟466: (𝓟[ty]1779{IO} ≠ 𝓟[ty]362{Either}))
{
 function 𝓟467{$Lambda24} (𝓟468{a}): (𝓟469: [miss]𝓟[ty]362{Either})
 {
 return 𝓟469 = 𝓟464{f}(𝓟314{left} as any,𝓟317{right} as any,𝓟468{a})
 }
 return 𝓟466 = 𝓟355{tailRecM}(𝓟465{a},𝓟467{$Lambda24})
}
const 𝓟470{EitherModule}: [OOV]𝓟[ty]303{EitherTypes} = {map: 𝓟451{$Lambda20},equals: 𝓟447{$Lambda19},ap: 𝓟455{$Lambda21},chainRec: 𝓟463{$Lambda23},chain: 𝓟459{$Lambda22},of: 𝓟311{pure}};
𝓟282{fantasyLandRegister}(𝓛12643{undefined},𝓟470{EitherModule},𝓟470{EitherModule})
const 𝓟471{_Class}: (𝓛[ty]10051{String} ≠ 𝓟[ty]533{Option});
function 𝓟472{CONSTRUCTOR} (𝓟473{ref}: [OOV]any,𝓟474{isEmpty}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8666{Boolean})): (𝓟[ty]533{Option})
{
 const 𝓟[ty]533{Option};
 const 𝓟[ty]533{Option};
 𝓟[ty]533{Option}._isEmpty ⟵ (𝓛12637{ExclamationEqualsToken}(𝓟474{isEmpty},𝓛12643{undefined}) ? 𝓟474{isEmpty} : 𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟473{ref},𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓟473{ref},𝓛12643{undefined}));
 𝓟[ty]533{Option}.value ⟵ 𝓟473{ref};
}
function 𝓟478{of} (𝓟479{value}: [OOV]any): (𝓟480: (𝓟[ty]1779{IO} ≠ 𝓟[ty]533{Option}))
{
 return 𝓟480 = (𝓛12637{ExclamationEqualsToken}(𝓟479{value},𝓛12643{undefined}) ? 𝓟614{Some}(𝓟479{value}) : 𝓟624{None}
}
function 𝓟481{some} (𝓟482{value}: [OOV]any): (𝓟483: 𝓟[ty]533{Option})
{
 return 𝓟483 = 𝓟472{CONSTRUCTOR}(𝓟482{value},𝓛8744{Boolean})
}
function 𝓟484{none} (): (𝓟485: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}))
{
 return 𝓟485 = 𝓟624{None}
}
function 𝓟486{empty} (): (𝓟487: (𝓟[ty]1779{IO} ≠ 𝓟[ty]533{Option}))
{
 return 𝓟487 = 𝓟624{None}
}
function 𝓟488{pure} (𝓟489{value}: [OOV]any): (𝓟490: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}))
{
 return 𝓟490 = 𝓟614{Some}(𝓟489{value})
}
function 𝓟491{map2} (𝓟492{fa1}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}),𝓟493{fa2}: 𝓟[ty]533{Option},𝓟494{f}: 𝓛[ty]8696{Function}): (𝓟495: (𝓟[ty]1779{IO} ≠ 𝓟[ty]533{Option}))
{
 return 𝓟495 = (𝓛12592{AmpersandAmpersandToken}(𝓟492{fa1}.nonEmpty(),𝓟493{fa2}.nonEmpty()) ? 𝓟614{Some}(𝓟494{f}(𝓟492{fa1}.value,𝓟493{fa2}.value)) : 𝓟624{None}
}
function 𝓟496{map3} (𝓟497{fa1}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}),𝓟498{fa2}: 𝓟[ty]533{Option},𝓟499{fa3}: 𝓟[ty]533{Option},𝓟500{f}: 𝓛[ty]8696{Function}): (𝓟501: (𝓟[ty]1779{IO} ≠ 𝓟[ty]533{Option}))
{
 return 𝓟501 = (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓟497{fa1}.nonEmpty(),𝓟498{fa2}.nonEmpty()),𝓟499{fa3}.nonEmpty()) ? 𝓟614{Some}(𝓟500{f}(𝓟497{fa1}.value,𝓟498{fa2}.value,𝓟499{fa3}.value)) : 𝓟624{None}
}
function 𝓟502{map4} (𝓟503{fa1}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}),𝓟504{fa2}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}),𝓟505{fa3}: 𝓟[ty]533{Option},𝓟506{fa4}: 𝓟[ty]533{Option},𝓟507{f}: 𝓛[ty]8696{Function}): (𝓟508: (𝓟[ty]1779{IO} ≠ 𝓟[ty]533{Option}))
{
 return 𝓟508 = (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓟503{fa1}.nonEmpty(),𝓟504{fa2}.nonEmpty()),𝓟505{fa3}.nonEmpty()),𝓟506{fa4}.nonEmpty()) ? 𝓟614{Some}(𝓟507{f}(𝓟503{fa1}.value,𝓟504{fa2}.value,𝓟505{fa3}.value,𝓟506{fa4}.value)) : 𝓟624{None}
}
function 𝓟509{map5} (𝓟510{fa1}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}),𝓟511{fa2}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}),𝓟512{fa3}: 𝓟[ty]533{Option},𝓟513{fa4}: 𝓟[ty]533{Option},𝓟514{fa5}: 𝓟[ty]533{Option},𝓟515{f}: 𝓛[ty]8696{Function}): (𝓟516: (𝓟[ty]1779{IO} ≠ 𝓟[ty]533{Option}))
{
 return 𝓟516 = (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓟510{fa1}.nonEmpty(),𝓟511{fa2}.nonEmpty()),𝓟512{fa3}.nonEmpty()),𝓟513{fa4}.nonEmpty()),𝓟514{fa5}.nonEmpty()) ? 𝓟614{Some}(𝓟515{f}(𝓟510{fa1}.value,𝓟511{fa2}.value,𝓟512{fa3}.value,𝓟513{fa4}.value,𝓟514{fa5}.value)) : 𝓟624{None}
}
function 𝓟517{map6} (𝓟518{fa1}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}),𝓟519{fa2}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}),𝓟520{fa3}: 𝓟[ty]533{Option},𝓟521{fa4}: 𝓟[ty]533{Option},𝓟522{fa5}: 𝓟[ty]533{Option},𝓟523{fa6}: 𝓟[ty]533{Option},𝓟524{f}: 𝓛[ty]8696{Function}): (𝓟525: (𝓟[ty]1779{IO} ≠ 𝓟[ty]533{Option}))
{
 return 𝓟525 = (𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓟518{fa1}.nonEmpty(),𝓟519{fa2}.nonEmpty()),𝓟520{fa3}.nonEmpty()),𝓟521{fa4}.nonEmpty()),𝓟522{fa5}.nonEmpty()),𝓟523{fa6}.nonEmpty()) ? 𝓟614{Some}(𝓟524{f}(𝓟518{fa1}.value,𝓟519{fa2}.value,𝓟520{fa3}.value,𝓟521{fa4}.value,𝓟522{fa5}.value,𝓟523{fa6}.value)) : 𝓟624{None}
}
function 𝓟526{tailRecM} (𝓟527{a}: [OOV]any,𝓟528{f}: 𝓛[ty]8696{Function}): (𝓟529: (𝓛[ty]8642{Object} ≠ 𝓟[ty]533{Option}))
{
 let 𝓟530{cursor}: [OOV]any = 𝓟527{a};
 while (𝓛8744{Boolean})
 {
 const 𝓟531{result}: [miss]𝓟[ty]533{Option} = 𝓟528{f}(𝓟530{cursor});
 if (𝓟531{result}.nonEmpty())
 {
 const 𝓟532{some}: [miss]𝓟[ty]362{Either} = 𝓟531{result}.value;
 if (𝓟532{some}.isRight())
 {
 return 𝓟529 = 𝓟614{Some}(𝓟532{some}.value)
 }
 𝓟530{cursor} ⟵ 𝓟532{some}.value as 𝓛[ty]2{<UNKNOWN>};
 }
 else
 {
 return 𝓟529 = 𝓟624{None}
 }
 }
}
class 𝓟[ty]533{Option} extends 𝓟[ty]3110{IEquals}{
 𝓟535{_isEmpty}: 𝓛[ty]8666{Boolean};
 𝓟536{value}: [OOV]any;
 𝓟537{_URI}: 𝓛[ty]10051{String};
 𝓟538{_A}: [OOV]any;
 function 𝓟544{orNull} (): (𝓟545: [OOV]any)
 {
 return 𝓟545 = (𝓛12569{ExclamationToken}(𝓟[ty]533{Option}._isEmpty) ? 𝓟[ty]533{Option}.value as 𝓛[ty]2{<UNKNOWN>} : 𝓛12643{undefined}
 }
 function 𝓟561{map} (𝓟562{f}: 𝓛[ty]8696{Function}): (𝓟563: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}))
 {
 return 𝓟563 = (𝓟[ty]533{Option}._isEmpty ? 𝓟624{None} : 𝓟614{Some}(𝓟562{f}(𝓟[ty]533{Option}.value as 𝓛[ty]2{<UNKNOWN>}))
 }
 function 𝓟554{orElseL} (𝓟555{thunk}: 𝓛[ty]8696{Function}): (𝓟556: (𝓟[ty]2437{Eval} ≠ 𝓟[ty]533{Option}))
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]533{Option}._isEmpty))
 {
 return 𝓟556 = 𝓟[ty]533{Option}
 }
 else
 {
 return 𝓟556 = 𝓟555{thunk}()
 }
 }
 function 𝓟601{equals} (𝓟602{that}: 𝓟[ty]533{Option}): (𝓟603: 𝓛[ty]8666{Boolean})
 {
 if (𝓛12599{EqualsEqualsToken}(𝓟602{that},𝓛12643{undefined}))
 {
 return 𝓟603 = 𝓛8744{Boolean}
 }
 if (𝓛12592{AmpersandAmpersandToken}(𝓟[ty]533{Option}.nonEmpty(),𝓟602{that}.nonEmpty()))
 {
 return 𝓟603 = 𝓟3114{is}(𝓟[ty]533{Option}.value,𝓟602{that}.value)
 }
 return 𝓟603 = 𝓛12592{AmpersandAmpersandToken}(𝓟[ty]533{Option}.isEmpty(),𝓟602{that}.isEmpty())
 }
 function 𝓟548{getOrElseL} (𝓟549{thunk}: 𝓛[ty]8696{Function}): (𝓟550: [OOV]any)
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]533{Option}._isEmpty))
 {
 return 𝓟550 = 𝓟[ty]533{Option}.value as 𝓛[ty]2{<UNKNOWN>}
 }
 else
 {
 return 𝓟550 = 𝓟549{thunk}()
 }
 }
 function 𝓟570{ap} (𝓟571{ff}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option})): (𝓟572: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}))
 {
 function 𝓟573{$Lambda25} (𝓟574{f}): (𝓟575: [miss]𝓟[ty]533{Option})
 {
 return 𝓟575 = 𝓟[ty]533{Option}.map(𝓟574{f})
 }
 return 𝓟572 = 𝓟571{ff}.flatMap(𝓟573{$Lambda25})
 }
 function 𝓟585{fold} (𝓟586{fallback}: 𝓛[ty]8696{Function},𝓟587{f}: 𝓛[ty]8696{Function}): (𝓟588: [OOV]any)
 {
 if (𝓟[ty]533{Option}._isEmpty)
 {
 return 𝓟588 = 𝓟586{fallback}()
 }
 return 𝓟588 = 𝓟587{f}(𝓟[ty]533{Option}.value as 𝓛[ty]2{<UNKNOWN>})
 }
 function 𝓟598{forEach} (𝓟599{cb}: 𝓛[ty]8696{Function}): (𝓟600: 𝓛[ty]10033{Void})
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]533{Option}._isEmpty))
 {
 𝓟599{cb}(𝓟[ty]533{Option}.value as 𝓛[ty]2{<UNKNOWN>})
 }
 }
 function 𝓟559{nonEmpty} (): (𝓟560: 𝓛[ty]8666{Boolean})
 {
 return 𝓟560 = 𝓛12569{ExclamationToken}(𝓟[ty]533{Option}._isEmpty)
 }
 function 𝓟551{orElse} (𝓟552{fallback}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]533{Option})): (𝓟553: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}))
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]533{Option}._isEmpty))
 {
 return 𝓟553 = 𝓟[ty]533{Option}
 }
 else
 {
 return 𝓟553 = 𝓟552{fallback}
 }
 }
 function 𝓟582{filter} (𝓟583{p}: 𝓛[ty]8696{Function}): (𝓟584: 𝓟[ty]533{Option})
 {
 if (𝓛12546{BarBarToken}(𝓟[ty]533{Option}._isEmpty,𝓛12569{ExclamationToken}(𝓟583{p}(𝓟[ty]533{Option}.value as 𝓛[ty]2{<UNKNOWN>}))))
 {
 return 𝓟584 = 𝓟624{None}
 }
 else
 {
 return 𝓟584 = 𝓟[ty]533{Option}
 }
 }
 function 𝓟564{flatMap} (𝓟565{f}: 𝓛[ty]8696{Function}): (𝓟566: (𝓛[ty]8642{Object} ≠ 𝓟[ty]533{Option}))
 {
 if (𝓟[ty]533{Option}._isEmpty)
 {
 return 𝓟566 = 𝓟624{None}
 }
 else
 {
 return 𝓟566 = 𝓟565{f}(𝓟[ty]533{Option}.value as 𝓛[ty]2{<UNKNOWN>})
 }
 }
 function 𝓟541{getOrElse} (𝓟542{fallback}: [OOV]any): (𝓟543: [OOV]any)
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]533{Option}._isEmpty))
 {
 return 𝓟543 = 𝓟[ty]533{Option}.value as 𝓛[ty]2{<UNKNOWN>}
 }
 else
 {
 return 𝓟543 = 𝓟542{fallback}
 }
 }
 function 𝓟592{exists} (𝓟593{p}: 𝓛[ty]8696{Function}): (𝓟594: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8666{Boolean}))
 {
 return 𝓟594 = 𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟[ty]533{Option}._isEmpty),𝓟593{p}(𝓟[ty]533{Option}.value as 𝓛[ty]2{<UNKNOWN>}))
 }
 function 𝓟539{get} (): (𝓟540: [OOV]any)
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]533{Option}._isEmpty))
 {
 return 𝓟540 = 𝓟[ty]533{Option}.value as 𝓛[ty]2{<UNKNOWN>}
 }
 𝓟3193{CONSTRUCTOR}(𝓛8743{String})
 }
 function 𝓟589{contains} (𝓟590{elem}: [OOV]any): (𝓟591: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8666{Boolean}))
 {
 return 𝓟591 = 𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟[ty]533{Option}._isEmpty),𝓟3114{is}(𝓟[ty]533{Option}.value,𝓟590{elem}))
 }
 function 𝓟557{isEmpty} (): (𝓟558: 𝓛[ty]8666{Boolean})
 {
 return 𝓟558 = 𝓟[ty]533{Option}._isEmpty
 }
 function 𝓟595{forAll} (𝓟596{p}: 𝓛[ty]8696{Function}): (𝓟597: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8666{Boolean}))
 {
 return 𝓟597 = 𝓛12546{BarBarToken}(𝓟[ty]533{Option}._isEmpty,𝓟596{p}(𝓟[ty]533{Option}.value as 𝓛[ty]2{<UNKNOWN>}))
 }
 function 𝓟567{chain} (𝓟568{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟569: 𝓟[ty]533{Option})
 {
 return 𝓟569 = 𝓟[ty]533{Option}.flatMap(𝓟568{f})
 }
 function 𝓟546{orUndefined} (): (𝓟547: [OOV]any)
 {
 return 𝓟547 = (𝓛12569{ExclamationToken}(𝓟[ty]533{Option}._isEmpty) ? 𝓟[ty]533{Option}.value : 𝓛12643{undefined}
 }
 function 𝓟604{hashCode} (): (𝓟605: 𝓛[ty]8655{Number})
 {
 if (𝓟[ty]533{Option}._isEmpty)
 {
 return 𝓟605 = 𝓛8745{Number}
 }
 else
 {
 if (𝓛12599{EqualsEqualsToken}(𝓟[ty]533{Option}.value,𝓛12643{undefined}))
 {
 return 𝓟605 = 𝓛12560{LessThanLessThanToken}(𝓛8745{Number},𝓛8745{Number})
 }
 else
 {
 return 𝓟605 = 𝓛12560{LessThanLessThanToken}(𝓟3125{hashCode}(𝓟[ty]533{Option}.value),𝓛8745{Number})
 }
 }
 }
}
function 𝓟606{CONSTRUCTOR} (𝓟607{value}: [OOV]any): (𝓟[ty]611{TSome})
{
 const 𝓟[ty]611{TSome};
 const 𝓟[ty]611{TSome};
 𝓟[ty]611{TSome}(𝓟607{value},𝓛8744{Boolean})
}
class 𝓟[ty]611{TSome} extends 𝓟[ty]533{Option}{
 𝓟613{value}: [OOV]any;
}
function 𝓟614{Some} (𝓟615{value}: [OOV]any): (𝓟616: (𝓟[ty]30{WrapFn} ≠ 𝓟[ty]611{TSome}))
{
 return 𝓟616 = 𝓟606{CONSTRUCTOR}(𝓟615{value})
}
function 𝓟617{CONSTRUCTOR} (): (𝓟[ty]621{TNone})
{
 const 𝓟[ty]621{TNone};
 const 𝓟[ty]621{TNone};
 𝓟[ty]621{TNone}(𝓛12643{undefined},𝓛8744{Boolean})
}
class 𝓟[ty]621{TNone} extends 𝓟[ty]533{Option}{
 𝓟623{value}: [OOV]any;
}
const 𝓟624{None}: (𝓟[ty]1779{IO} ≠ 𝓟[ty]621{TNone}) = 𝓛12643{undefined} as any.CONSTRUCTOR();
function 𝓟625{$Lambda26} (𝓟626{x},𝓟627{y}): (𝓟628: [OOV]any)
{
 return 𝓟628 = (𝓟626{x} ? 𝓟626{x}.equals(𝓟627{y}) : 𝓛12569{ExclamationToken}(𝓟627{y})
}
function 𝓟629{$Lambda27} (𝓟630{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟631{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option})): (𝓟632: [miss]𝓟[ty]533{Option})
{
 return 𝓟632 = 𝓟631{fa}.map(𝓟630{f})
}
function 𝓟633{$Lambda28} (𝓟634{ff}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]533{Option}),𝓟635{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option})): (𝓟636: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}))
{
 return 𝓟636 = 𝓟635{fa}.ap(𝓟634{ff})
}
function 𝓟637{$Lambda29} (𝓟638{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟639{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option})): (𝓟640: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}))
{
 return 𝓟640 = 𝓟639{fa}.flatMap(𝓟638{f})
}
function 𝓟641{$Lambda30} (𝓟642{f}: 𝓛[ty]8696{Function},𝓟643{a}: [OOV]any): (𝓟644: (𝓟[ty]1779{IO} ≠ 𝓟[ty]533{Option}))
{
 function 𝓟645{$Lambda31} (𝓟646{a}): (𝓟647: [miss]𝓟[ty]533{Option})
 {
 return 𝓟647 = 𝓟642{f}(𝓟314{left} as any,𝓟317{right} as any,𝓟646{a})
 }
 return 𝓟644 = 𝓟526{tailRecM}(𝓟643{a},𝓟645{$Lambda31})
}
const 𝓟648{OptionModule}: [OOV]𝓟[ty]302{OptionTypes} = {map: 𝓟629{$Lambda27},equals: 𝓟625{$Lambda26},ap: 𝓟633{$Lambda28},chainRec: 𝓟641{$Lambda30},chain: 𝓟637{$Lambda29},of: 𝓟488{pure}};
𝓟282{fantasyLandRegister}(𝓛12145{Option},𝓟648{OptionModule},𝓟648{OptionModule})
const 𝓟649{_Class}: (𝓛[ty]10051{String} ≠ 𝓟[ty]715{Try});
function 𝓟650{CONSTRUCTOR} (𝓟651{value}: [OOV]any,𝓟652{tag}: [OOV]any): (𝓟[ty]715{Try})
{
 const 𝓟[ty]715{Try};
 const 𝓟[ty]715{Try};
 𝓟[ty]715{Try}._isSuccess ⟵ 𝓛12559{EqualsEqualsEqualsToken}(𝓟652{tag},𝓛8743{String});
 𝓟[ty]715{Try}.value ⟵ 𝓟651{value};
}
function 𝓟656{of} (𝓟657{thunk}: 𝓛[ty]8696{Function}): (𝓟658: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
{
 {
 return 𝓟658 = 𝓟803{Success}(𝓟657{thunk}())
 }
}
function 𝓟659{pure} (𝓟660{value}: [OOV]any): (𝓟661: (𝓟[ty]1779{IO} ≠ 𝓟[ty]715{Try}))
{
 return 𝓟661 = 𝓟664{success}(𝓟660{value})
}
function 𝓟662{unit} (): (𝓟663: (𝓟[ty]2029{IOContext} ≠ 𝓟[ty]715{Try}))
{
 return 𝓟663 = 𝓟841{tryUnitRef}
}
function 𝓟664{success} (𝓟665{value}: [OOV]any): (𝓟666: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
{
 return 𝓟666 = 𝓟803{Success}(𝓟665{value})
}
function 𝓟667{failure} (𝓟668{e}: [OOV]𝓟[ty]3170{Throwable}): (𝓟669: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
{
 return 𝓟669 = 𝓟814{Failure}(𝓟668{e})
}
function 𝓟670{raise} (𝓟671{e}: [OOV]𝓟[ty]3170{Throwable}): (𝓟672: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
{
 return 𝓟672 = 𝓟814{Failure}(𝓟671{e})
}
function 𝓟673{map2} (𝓟674{fa1}: 𝓟[ty]715{Try},𝓟675{fa2}: 𝓟[ty]715{Try},𝓟676{f}: 𝓛[ty]8696{Function}): (𝓟677: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
{
 if (𝓟674{fa1}.isFailure())
 {
 return 𝓟677 = 𝓟674{fa1}
 }
 if (𝓟675{fa2}.isFailure())
 {
 return 𝓟677 = 𝓟675{fa2}
 }
 {
 return 𝓟677 = 𝓟803{Success}(𝓟676{f}(𝓟674{fa1}.value as 𝓛[ty]2{<UNKNOWN>},𝓟675{fa2}.value as 𝓛[ty]2{<UNKNOWN>}))
 }
}
function 𝓟678{map3} (𝓟679{fa1}: 𝓟[ty]715{Try},𝓟680{fa2}: 𝓟[ty]715{Try},𝓟681{fa3}: 𝓟[ty]715{Try},𝓟682{f}: 𝓛[ty]8696{Function}): (𝓟683: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
{
 if (𝓟679{fa1}.isFailure())
 {
 return 𝓟683 = 𝓟679{fa1}
 }
 if (𝓟680{fa2}.isFailure())
 {
 return 𝓟683 = 𝓟680{fa2}
 }
 if (𝓟681{fa3}.isFailure())
 {
 return 𝓟683 = 𝓟681{fa3}
 }
 {
 return 𝓟683 = 𝓟803{Success}(𝓟682{f}(𝓟679{fa1}.value as 𝓛[ty]2{<UNKNOWN>},𝓟680{fa2}.value as 𝓛[ty]2{<UNKNOWN>},𝓟681{fa3}.value as 𝓛[ty]2{<UNKNOWN>}))
 }
}
function 𝓟684{map4} (𝓟685{fa1}: 𝓟[ty]715{Try},𝓟686{fa2}: 𝓟[ty]715{Try},𝓟687{fa3}: 𝓟[ty]715{Try},𝓟688{fa4}: 𝓟[ty]715{Try},𝓟689{f}: 𝓛[ty]8696{Function}): (𝓟690: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
{
 if (𝓟685{fa1}.isFailure())
 {
 return 𝓟690 = 𝓟685{fa1}
 }
 if (𝓟686{fa2}.isFailure())
 {
 return 𝓟690 = 𝓟686{fa2}
 }
 if (𝓟687{fa3}.isFailure())
 {
 return 𝓟690 = 𝓟687{fa3}
 }
 if (𝓟688{fa4}.isFailure())
 {
 return 𝓟690 = 𝓟688{fa4}
 }
 {
 return 𝓟690 = 𝓟803{Success}(𝓟689{f}(𝓟685{fa1}.value as 𝓛[ty]2{<UNKNOWN>},𝓟686{fa2}.value as 𝓛[ty]2{<UNKNOWN>},𝓟687{fa3}.value as 𝓛[ty]2{<UNKNOWN>},𝓟688{fa4}.value as 𝓛[ty]2{<UNKNOWN>}))
 }
}
function 𝓟691{map5} (𝓟692{fa1}: 𝓟[ty]715{Try},𝓟693{fa2}: 𝓟[ty]715{Try},𝓟694{fa3}: 𝓟[ty]715{Try},𝓟695{fa4}: 𝓟[ty]715{Try},𝓟696{fa5}: 𝓟[ty]715{Try},𝓟697{f}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8696{Function})): (𝓟698: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
{
 if (𝓟692{fa1}.isFailure())
 {
 return 𝓟698 = 𝓟692{fa1}
 }
 if (𝓟693{fa2}.isFailure())
 {
 return 𝓟698 = 𝓟693{fa2}
 }
 if (𝓟694{fa3}.isFailure())
 {
 return 𝓟698 = 𝓟694{fa3}
 }
 if (𝓟695{fa4}.isFailure())
 {
 return 𝓟698 = 𝓟695{fa4}
 }
 if (𝓟696{fa5}.isFailure())
 {
 return 𝓟698 = 𝓟696{fa5}
 }
 {
 return 𝓟698 = 𝓟803{Success}(𝓟697{f}(𝓟692{fa1}.value as 𝓛[ty]2{<UNKNOWN>},𝓟693{fa2}.value as 𝓛[ty]2{<UNKNOWN>},𝓟694{fa3}.value as 𝓛[ty]2{<UNKNOWN>},𝓟695{fa4}.value as 𝓛[ty]2{<UNKNOWN>},𝓟696{fa5}.value as 𝓛[ty]2{<UNKNOWN>}))
 }
}
function 𝓟699{map6} (𝓟700{fa1}: 𝓟[ty]715{Try},𝓟701{fa2}: 𝓟[ty]715{Try},𝓟702{fa3}: 𝓟[ty]715{Try},𝓟703{fa4}: 𝓟[ty]715{Try},𝓟704{fa5}: 𝓟[ty]715{Try},𝓟705{fa6}: 𝓟[ty]715{Try},𝓟706{f}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8696{Function})): (𝓟707: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
{
 if (𝓟700{fa1}.isFailure())
 {
 return 𝓟707 = 𝓟700{fa1}
 }
 if (𝓟701{fa2}.isFailure())
 {
 return 𝓟707 = 𝓟701{fa2}
 }
 if (𝓟702{fa3}.isFailure())
 {
 return 𝓟707 = 𝓟702{fa3}
 }
 if (𝓟703{fa4}.isFailure())
 {
 return 𝓟707 = 𝓟703{fa4}
 }
 if (𝓟704{fa5}.isFailure())
 {
 return 𝓟707 = 𝓟704{fa5}
 }
 if (𝓟705{fa6}.isFailure())
 {
 return 𝓟707 = 𝓟705{fa6}
 }
 {
 return 𝓟707 = 𝓟803{Success}(𝓟706{f}(𝓟700{fa1}.value as 𝓛[ty]2{<UNKNOWN>},𝓟701{fa2}.value as 𝓛[ty]2{<UNKNOWN>},𝓟702{fa3}.value as 𝓛[ty]2{<UNKNOWN>},𝓟703{fa4}.value as 𝓛[ty]2{<UNKNOWN>},𝓟704{fa5}.value as 𝓛[ty]2{<UNKNOWN>},𝓟705{fa6}.value as 𝓛[ty]2{<UNKNOWN>}))
 }
}
function 𝓟708{tailRecM} (𝓟709{a}: [OOV]any,𝓟710{f}: 𝓛[ty]8696{Function}): (𝓟711: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
{
 let 𝓟712{cursor}: [OOV]any = 𝓟709{a};
 while (𝓛8744{Boolean})
 {
 {
 const 𝓟713{result}: [miss]𝓟[ty]715{Try} = 𝓟710{f}(𝓟712{cursor});
 if (𝓟713{result}.isFailure())
 {
 return 𝓟711 = 𝓟713{result} as any
 }
 const 𝓟714{some}: [miss]𝓟[ty]362{Either} = 𝓟713{result}.get();
 if (𝓟714{some}.isRight())
 {
 return 𝓟711 = 𝓟803{Success}(𝓟714{some}.value)
 }
 𝓟712{cursor} ⟵ 𝓟714{some}.value as 𝓛[ty]2{<UNKNOWN>};
 }
 }
}
class 𝓟[ty]715{Try} extends 𝓟[ty]3110{IEquals}{
 𝓟717{_isSuccess}: 𝓛[ty]8666{Boolean};
 𝓟718{value}: [OOV]any;
 𝓟719{_URI}: 𝓛[ty]10051{String};
 𝓟720{_A}: [OOV]any;
 function 𝓟783{recoverWith} (𝓟784{f}: 𝓛[ty]8696{Function}): (𝓟785: (𝓟[ty]533{Option} ≠ 𝓟[ty]715{Try}))
 {
 {
 return 𝓟785 = (𝓟[ty]715{Try}._isSuccess ? 𝓟[ty]715{Try} : 𝓟784{f}(𝓟[ty]715{Try}.value as 𝓟[ty]3170{Throwable})
 }
 }
 function 𝓟786{toOption} (): (𝓟787: (𝓟[ty]1779{IO} ≠ 𝓟[ty]533{Option}))
 {
 return 𝓟787 = (𝓟[ty]715{Try}._isSuccess ? 𝓟614{Some}(𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>}) : 𝓟624{None}
 }
 function 𝓟733{orNull} (): (𝓟734: [OOV]any)
 {
 return 𝓟734 = (𝓟[ty]715{Try}._isSuccess ? 𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>} : 𝓛12643{undefined}
 }
 function 𝓟770{map} (𝓟771{f}: 𝓛[ty]8696{Function}): (𝓟772: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
 {
 function 𝓟773{$Lambda33} (): (𝓟774: [OOV]any)
 {
 return 𝓟774 = 𝓟771{f}(𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>})
 }
 return 𝓟772 = (𝓟[ty]715{Try}._isSuccess ? 𝓟656{of}(𝓟773{$Lambda33}) : 𝓟[ty]715{Try} as any as 𝓟[ty]715{Try}
 }
 function 𝓟740{orElseL} (𝓟741{thunk}: 𝓛[ty]8696{Function}): (𝓟742: 𝓟[ty]715{Try})
 {
 if (𝓟[ty]715{Try}._isSuccess)
 {
 return 𝓟742 = 𝓟[ty]715{Try}
 }
 return 𝓟742 = 𝓟741{thunk}()
 }
 function 𝓟723{isFailure} (): (𝓟724: 𝓛[ty]8666{Boolean})
 {
 return 𝓟724 = 𝓛12569{ExclamationToken}(𝓟[ty]715{Try}._isSuccess)
 }
 function 𝓟790{equals} (𝓟791{that}: 𝓟[ty]715{Try}): (𝓟792: 𝓛[ty]8666{Boolean})
 {
 if (𝓛12599{EqualsEqualsToken}(𝓟791{that},𝓛12643{undefined}))
 {
 return 𝓟792 = 𝓛8744{Boolean}
 }
 return 𝓟792 = (𝓟[ty]715{Try}._isSuccess ? 𝓛12592{AmpersandAmpersandToken}(𝓟791{that}._isSuccess,𝓟3114{is}(𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>},𝓟791{that}.value as 𝓛[ty]2{<UNKNOWN>})) : 𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟791{that}._isSuccess),𝓟3114{is}(𝓟[ty]715{Try}.value,𝓟791{that}.value))
 }
 function 𝓟730{getOrElseL} (𝓟731{thunk}: 𝓛[ty]8696{Function}): (𝓟732: [OOV]any)
 {
 return 𝓟732 = (𝓟[ty]715{Try}._isSuccess ? 𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>} : 𝓟731{thunk}()
 }
 function 𝓟743{failed} (): (𝓟744: (𝓟[ty]533{Option} ≠ 𝓟[ty]715{Try}))
 {
 return 𝓟744 = (𝓟[ty]715{Try}._isSuccess ? 𝓟814{Failure}(𝓟3193{CONSTRUCTOR}(𝓛8743{String})) : 𝓟803{Success}(𝓟[ty]715{Try}.value as 𝓟[ty]3170{Throwable})
 }
 function 𝓟764{ap} (𝓟765{ff}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try})): (𝓟766: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
 {
 function 𝓟767{$Lambda32} (𝓟768{f}): (𝓟769: [miss]𝓟[ty]715{Try})
 {
 return 𝓟769 = 𝓟[ty]715{Try}.map(𝓟768{f})
 }
 return 𝓟766 = 𝓟765{ff}.flatMap(𝓟767{$Lambda32})
 }
 function 𝓟788{toEither} (): (𝓟789: (𝓟[ty]1779{IO} ≠ 𝓟[ty]362{Either}))
 {
 return 𝓟789 = (𝓟[ty]715{Try}._isSuccess ? 𝓟444{Right}(𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>}) : 𝓟433{Left}(𝓟[ty]715{Try}.value as 𝓟[ty]3170{Throwable})
 }
 function 𝓟745{fold} (𝓟746{failure}: 𝓛[ty]8696{Function},𝓟747{success}: 𝓛[ty]8696{Function}): (𝓟748: [OOV]any)
 {
 return 𝓟748 = (𝓟[ty]715{Try}._isSuccess ? 𝓟747{success}(𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>}) : 𝓟746{failure}(𝓟[ty]715{Try}.value as 𝓟[ty]3170{Throwable})
 }
 function 𝓟775{forEach} (𝓟776{cb}: 𝓛[ty]8696{Function}): (𝓟777: 𝓛[ty]10033{Void})
 {
 if (𝓟[ty]715{Try}._isSuccess)
 {
 𝓟776{cb}(𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>})
 }
 }
 function 𝓟737{orElse} (𝓟738{fallback}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]715{Try})): (𝓟739: 𝓟[ty]715{Try})
 {
 if (𝓟[ty]715{Try}._isSuccess)
 {
 return 𝓟739 = 𝓟[ty]715{Try}
 }
 return 𝓟739 = 𝓟738{fallback}
 }
 function 𝓟721{isSuccess} (): (𝓟722: 𝓛[ty]8666{Boolean})
 {
 return 𝓟722 = 𝓟[ty]715{Try}._isSuccess
 }
 function 𝓟755{filter} (𝓟756{p}: 𝓛[ty]8696{Function}): (𝓟757: 𝓟[ty]715{Try})
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]715{Try}._isSuccess))
 {
 return 𝓟757 = 𝓟[ty]715{Try}
 }
 {
 if (𝓟756{p}(𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>}))
 {
 return 𝓟757 = 𝓟[ty]715{Try}
 }
 return 𝓟757 = 𝓟814{Failure}(𝓟3193{CONSTRUCTOR}(𝓛12607{$Template}(𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>})))
 }
 }
 function 𝓟778{recover} (𝓟779{f}: 𝓛[ty]8696{Function}): (𝓟780: (𝓟[ty]533{Option} ≠ 𝓟[ty]715{Try}))
 {
 function 𝓟781{$Lambda34} (): (𝓟782: [OOV]any)
 {
 return 𝓟782 = 𝓟779{f}(𝓟[ty]715{Try}.value as 𝓟[ty]3170{Throwable})
 }
 return 𝓟780 = (𝓟[ty]715{Try}._isSuccess ? 𝓟[ty]715{Try} : 𝓟656{of}(𝓟781{$Lambda34})
 }
 function 𝓟758{flatMap} (𝓟759{f}: 𝓛[ty]8696{Function}): (𝓟760: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]715{Try}._isSuccess))
 {
 return 𝓟760 = 𝓟[ty]715{Try} as any
 }
 {
 return 𝓟760 = 𝓟759{f}(𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>})
 }
 }
 function 𝓟727{getOrElse} (𝓟728{fallback}: [OOV]any): (𝓟729: [OOV]any)
 {
 return 𝓟729 = (𝓟[ty]715{Try}._isSuccess ? 𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>} : 𝓟728{fallback}
 }
 function 𝓟725{get} (): (𝓟726: [OOV]any)
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]715{Try}._isSuccess))
 {
 𝓟[ty]715{Try}.value
 }
 return 𝓟726 = 𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>}
 }
 function 𝓟761{chain} (𝓟762{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟763: (𝓟[ty]533{Option} ≠ 𝓟[ty]715{Try}))
 {
 return 𝓟763 = 𝓟[ty]715{Try}.flatMap(𝓟762{f})
 }
 function 𝓟735{orUndefined} (): (𝓟736: [OOV]any)
 {
 return 𝓟736 = (𝓟[ty]715{Try}._isSuccess ? 𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>} : 𝓛12643{undefined}
 }
 function 𝓟793{hashCode} (): (𝓟794: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟794 = (𝓟[ty]715{Try}._isSuccess ? 𝓟3125{hashCode}(𝓟[ty]715{Try}.value as 𝓛[ty]2{<UNKNOWN>}) : 𝓟3125{hashCode}(𝓟[ty]715{Try}.value as 𝓟[ty]3170{Throwable})
 }
}
function 𝓟795{CONSTRUCTOR} (𝓟796{value}: [OOV]any): (𝓟[ty]800{TSuccess})
{
 const 𝓟[ty]800{TSuccess};
 const 𝓟[ty]800{TSuccess};
 𝓟[ty]800{TSuccess}(𝓟796{value},𝓛8743{String})
}
class 𝓟[ty]800{TSuccess} extends 𝓟[ty]715{Try}{
 𝓟802{value}: [OOV]any;
}
function 𝓟803{Success} (𝓟804{value}: [OOV]any): (𝓟805: (𝓟[ty]800{TSuccess} ≠ 𝓟[ty]715{Try}))
{
 return 𝓟805 = 𝓟795{CONSTRUCTOR}(𝓟804{value})
}
function 𝓟806{CONSTRUCTOR} (𝓟807{value}: [OOV]𝓟[ty]3170{Throwable}): (𝓟[ty]811{TFailure})
{
 const 𝓟[ty]811{TFailure};
 const 𝓟[ty]811{TFailure};
 𝓟[ty]811{TFailure}(𝓟807{value},𝓛8743{String})
}
class 𝓟[ty]811{TFailure} extends 𝓟[ty]715{Try}{
 𝓟813{value}: [OOV]𝓟[ty]3170{Throwable};
}
function 𝓟814{Failure} (𝓟815{e}: [OOV]𝓟[ty]3170{Throwable}): (𝓟816: (𝓟[ty]811{TFailure} ≠ 𝓟[ty]715{Try}))
{
 return 𝓟816 = 𝓟806{CONSTRUCTOR}(𝓟815{e})
}
function 𝓟817{$Lambda35} (𝓟818{x},𝓟819{y}): (𝓟820: [OOV]any)
{
 return 𝓟820 = (𝓟818{x} ? 𝓟818{x}.equals(𝓟819{y}) : 𝓛12569{ExclamationToken}(𝓟819{y})
}
function 𝓟821{$Lambda36} (𝓟822{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟823{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try})): (𝓟824: [miss]𝓟[ty]715{Try})
{
 return 𝓟824 = 𝓟823{fa}.map(𝓟822{f})
}
function 𝓟825{$Lambda37} (𝓟826{ff}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]715{Try}),𝓟827{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try})): (𝓟828: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
{
 return 𝓟828 = 𝓟827{fa}.ap(𝓟826{ff})
}
function 𝓟829{$Lambda38} (𝓟830{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟831{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try})): (𝓟832: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
{
 return 𝓟832 = 𝓟831{fa}.flatMap(𝓟830{f})
}
function 𝓟833{$Lambda39} (𝓟834{f}: 𝓛[ty]8696{Function},𝓟835{a}: [OOV]any): (𝓟836: (𝓟[ty]1779{IO} ≠ 𝓟[ty]715{Try}))
{
 function 𝓟837{$Lambda40} (𝓟838{a}): (𝓟839: [miss]𝓟[ty]715{Try})
 {
 return 𝓟839 = 𝓟834{f}(𝓟314{left} as any,𝓟317{right} as any,𝓟838{a})
 }
 return 𝓟836 = 𝓟708{tailRecM}(𝓟835{a},𝓟837{$Lambda40})
}
const 𝓟840{TryModule}: [OOV]𝓟[ty]301{TryTypes} = {map: 𝓟821{$Lambda36},equals: 𝓟817{$Lambda35},ap: 𝓟825{$Lambda37},chainRec: 𝓟833{$Lambda39},chain: 𝓟829{$Lambda38},of: 𝓟659{pure}};
𝓟282{fantasyLandRegister}(𝓛12643{undefined},𝓟840{TryModule},𝓟840{TryModule})
const 𝓟841{tryUnitRef}: 𝓟[ty]715{Try} = 𝓟803{Success}(𝓛12643{undefined});

Module: test-common/applicative-tests

function 𝓟842{applicativeCheck} (𝓟843{genFA}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟844{genAtoB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟845{genBtoC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟846{genFAtoB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟847{genFBtoC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟848{genA}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟849{check}: 𝓛[ty]8696{Function},𝓟850{F}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟851{lawsRef}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟852{includeSuperTypes}: 𝓛[ty]8666{Boolean}): (𝓟853: [miss]𝓛[ty]10033{Void})
{
 const 𝓟854{laws} = 𝓛12546{BarBarToken}(𝓟851{lawsRef},𝓟3249{ApplicativeLaws}.CONSTRUCTOR(𝓟850{F}));
 if (𝓟852{includeSuperTypes})
 {
 𝓟258{applyCheck}(𝓟843{genFA},𝓟844{genAtoB},𝓟845{genBtoC},𝓟846{genFAtoB},𝓟847{genFBtoC},𝓟849{check},𝓟850{F},𝓟854{laws})
 }
 function 𝓟855{$Lambda0} (𝓟856{fa}): (𝓟857: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟857 = 𝓟849{check}(𝓟854{laws}.applicativeIdentity(𝓟856{fa}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟843{genFA},𝓟855{$Lambda0})
 function 𝓟858{$Lambda1} (𝓟859{a},𝓟860{f}): (𝓟861: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟861 = 𝓟849{check}(𝓟854{laws}.applicativeHomomorphism(𝓟859{a},𝓟860{f}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟848{genA},𝓟844{genAtoB},𝓟858{$Lambda1})
 function 𝓟862{$Lambda2} (𝓟863{a},𝓟864{ff}): (𝓟865: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟865 = 𝓟849{check}(𝓟854{laws}.applicativeInterchange(𝓟863{a},𝓟864{ff}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟848{genA},𝓟846{genFAtoB},𝓟862{$Lambda2})
 function 𝓟866{$Lambda3} (𝓟867{fa},𝓟868{f}): (𝓟869: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟869 = 𝓟849{check}(𝓟854{laws}.applicativeMap(𝓟867{fa},𝓟868{f}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟843{genFA},𝓟844{genAtoB},𝓟866{$Lambda3})
}

Module: test-common/chain-tests

function 𝓟870{chainCheck} (𝓟871{genFA}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟872{genFB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟873{genFC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟874{genAtoB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟875{genBtoC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟876{genFAtoB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟877{genFBtoC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟878{check}: 𝓛[ty]8696{Function},𝓟879{F}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟880{lawsRef}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟881{includeSuperTypes}: 𝓛[ty]8666{Boolean}): (𝓟882: [miss]𝓛[ty]10033{Void})
{
 const 𝓟883{laws} = 𝓛12546{BarBarToken}(𝓟880{lawsRef},𝓟3251{ChainLaws}.CONSTRUCTOR(𝓟879{F}));
 if (𝓟881{includeSuperTypes})
 {
 𝓟258{applyCheck}(𝓟871{genFA},𝓟874{genAtoB},𝓟875{genBtoC},𝓟876{genFAtoB},𝓟877{genFBtoC},𝓟878{check},𝓟879{F},𝓟883{laws})
 }
 function 𝓟884{$Lambda6} (𝓟885{fa},𝓟886{fab},𝓟887{fbc}): (𝓟888: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟888 = 𝓟878{check}(𝓟883{laws}.chainAssociativity(𝓟885{fa},𝓟886{fab},𝓟887{fbc}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟871{genFA},𝓛1{<UNKNOWN>}(𝓟872{genFB}),𝓛1{<UNKNOWN>}(𝓟873{genFC}),𝓟884{$Lambda6})
 function 𝓟889{$Lambda7} (𝓟890{fa},𝓟891{fab}): (𝓟892: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟892 = 𝓟878{check}(𝓟883{laws}.chainConsistentApply(𝓟891{fab},𝓟890{fa}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟871{genFA},𝓟876{genFAtoB},𝓟889{$Lambda7})
}

Module: test-common/functor-tests

function 𝓟893{functorCheck} (𝓟894{genFA}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟895{genAtoB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟896{genBtoC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟897{check}: 𝓛[ty]8696{Function},𝓟898{F}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟899{lawsRef}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟900: [miss]𝓛[ty]10033{Void})
{
 const 𝓟901{laws} = 𝓛12546{BarBarToken}(𝓟899{lawsRef},𝓟3253{FunctorLaws}.CONSTRUCTOR(𝓟898{F}));
 function 𝓟902{$Lambda8} (𝓟903{fa}): (𝓟904: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟904 = 𝓟897{check}(𝓟901{laws}.identity(𝓟903{fa}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟894{genFA},𝓟902{$Lambda8})
 function 𝓟905{$Lambda9} (𝓟906{fa},𝓟907{g},𝓟908{f}): (𝓟909: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟909 = 𝓟897{check}(𝓟901{laws}.composition(𝓟906{fa},𝓟908{f},𝓟907{g}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟894{genFA},𝓟895{genAtoB},𝓟896{genBtoC},𝓟905{$Lambda9})
}

Module: packages/funfix-effect/src/internals

type 𝓟[ty]910{IteratorLike} = {next: ()->{done: 𝓛[ty]8666{Boolean}, value: any}}
function 𝓟911{$Lambda61} (): (𝓟912: [miss]𝓛[ty]8642{Object})
{
 return 𝓟912 = {done: 𝓛8744{Boolean}}
}
const 𝓟913{emptyIteratorRef}: [OOV]𝓟[ty]910{IteratorLike} = {next: 𝓟911{$Lambda61}};
function 𝓟914{iteratorOf} (𝓟915{list}: [OOV]any): (𝓟916: [OOV]𝓟[ty]910{IteratorLike})
{
 if (𝓛12569{ExclamationToken}(𝓟915{list}))
 {
 return 𝓟916 = 𝓟913{emptyIteratorRef}
 }
 if (𝓛12612{ExclamationEqualsEqualsToken}(𝓛8741{Object}.prototype.toString.call(𝓟915{list}),𝓛8743{String}))
 {
 return 𝓟916 = 𝓟915{list}.access(𝓛10031{Symbol}.iterator)()
 }
 const 𝓟917{array}: [miss]𝓛[ty]8670{Array} = 𝓟915{list} as 𝓛[ty]8670{Array};
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟917{array}.length,𝓛8745{Number}))
 {
 return 𝓟916 = 𝓟913{emptyIteratorRef}
 }
 let 𝓟918{cursor}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 function 𝓟919{$Lambda62} (): (𝓟920: [miss]𝓛[ty]8642{Object})
 {
 const 𝓟921{value}: [OOV]any = 𝓟917{array}.access(𝓛12556{POST_PlusPlusToken}(𝓟918{cursor}));
 const 𝓟922{done}: [miss]𝓛[ty]8666{Boolean} = 𝓛12596{GreaterThanEqualsToken}(𝓟918{cursor},𝓟917{array}.length);
 return 𝓟920 = {done: 𝓟922{done},value: 𝓟921{value}}
 }
 const 𝓟923{next}: [miss]𝓛[ty]8696{Function} = 𝓟919{$Lambda62};
 return 𝓟916 = {next: 𝓟923{next}}
}

Module: packages/funfix-exec/src/time

function 𝓟924{CONSTRUCTOR} (): (𝓟[ty]928{TimeUnit})
{
 const 𝓟[ty]928{TimeUnit};
 const 𝓟[ty]928{TimeUnit};
}
class 𝓟[ty]928{TimeUnit}{
 𝓟930{ord}: 𝓛[ty]8655{Number};
 𝓟931{label}: 𝓛[ty]10051{String};
 function 𝓟945{toSeconds} (𝓟946{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟947: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8655{Number}))
 {
 }
 function 𝓟939{toMicros} (𝓟940{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟941: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8655{Number}))
 {
 }
 function 𝓟942{toMillis} (𝓟943{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟944: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8655{Number}))
 {
 }
 function 𝓟951{toHours} (𝓟952{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟953: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8655{Number}))
 {
 }
 function 𝓟957{toString} (): (𝓟958: 𝓛[ty]10051{String})
 {
 return 𝓟958 = 𝓟[ty]928{TimeUnit}.label.toUpperCase()
 }
 function 𝓟954{toDays} (𝓟955{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟956: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8655{Number}))
 {
 }
 function 𝓟936{toNanos} (𝓟937{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟938: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8655{Number}))
 {
 }
 function 𝓟948{toMinutes} (𝓟949{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟950: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8655{Number}))
 {
 }
 function 𝓟932{convert} (𝓟933{duration}: (𝓟[ty]1251{Duration} ≠ 𝓛[ty]8655{Number}),𝓟934{unit}: 𝓟[ty]928{TimeUnit}): (𝓟935: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8655{Number}))
 {
 }
}
const 𝓟959{C0}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
const 𝓟960{C1}: [miss]𝓛[ty]8655{Number} = 𝓛12548{AsteriskToken}(𝓟959{C0},𝓛8745{Number});
const 𝓟961{C2}: [miss]𝓛[ty]8655{Number} = 𝓛12548{AsteriskToken}(𝓟960{C1},𝓛8745{Number});
const 𝓟962{C3}: [miss]𝓛[ty]8655{Number} = 𝓛12548{AsteriskToken}(𝓟961{C2},𝓛8745{Number});
const 𝓟963{C4}: [miss]𝓛[ty]8655{Number} = 𝓛12548{AsteriskToken}(𝓟962{C3},𝓛8745{Number});
const 𝓟964{C5}: [miss]𝓛[ty]8655{Number} = 𝓛12548{AsteriskToken}(𝓟963{C4},𝓛8745{Number});
const 𝓟965{C6}: [miss]𝓛[ty]8655{Number} = 𝓛12548{AsteriskToken}(𝓟964{C5},𝓛8745{Number});
const 𝓟966{MIN}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓛8745{Number});
const 𝓟967{MAX}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
function 𝓟968{$Lambda206} (𝓟969{x}): (𝓟970: [miss]𝓛[ty]8655{Number})
{
 if (𝓛8717{isNaN}(𝓟969{x}))
 {
 return 𝓟970 = 𝓛8705{NaN}
 }
 if (𝓛12595{GreaterThanToken}(𝓟969{x},𝓛8745{Number}))
 {
 return 𝓟970 = 𝓛8746{Math}.floor(𝓟969{x})
 }
 return 𝓟970 = 𝓛8746{Math}.ceil(𝓟969{x})
}
const 𝓟971{trunc}: 𝓛[ty]8696{Function} = 𝓛12546{BarBarToken}(𝓛8746{Math}.trunc,𝓟968{$Lambda206});
function 𝓟972{x} (𝓟973{d}: 𝓛[ty]8655{Number},𝓟974{m}: 𝓛[ty]8655{Number},𝓟975{over}: 𝓛[ty]8655{Number}): (𝓟976: 𝓛[ty]8655{Number})
{
 if (𝓛12595{GreaterThanToken}(𝓟973{d},𝓟975{over}))
 {
 return 𝓟976 = 𝓟967{MAX}
 }
 if (𝓛1{<UNKNOWN>}(𝓟973{d},𝓛12616{MinusToken}(𝓟975{over})))
 {
 return 𝓟976 = 𝓟966{MIN}
 }
 return 𝓟976 = 𝓛12548{AsteriskToken}(𝓟973{d},𝓟974{m})
}
function 𝓟977{CONSTRUCTOR} (): (𝓟[ty]981{Nanoseconds})
{
 const 𝓟[ty]981{Nanoseconds};
 const 𝓟[ty]981{Nanoseconds};
 𝓟[ty]981{Nanoseconds}.ord ⟵ 𝓛8745{Number};
 𝓟[ty]981{Nanoseconds}.label ⟵ 𝓛8743{String};
}
class 𝓟[ty]981{Nanoseconds} extends 𝓟[ty]928{TimeUnit}{
 𝓟983{ord}: 𝓛[ty]8655{Number};
 𝓟984{label}: [miss]𝓛[ty]10051{String};
 function 𝓟998{toSeconds} (𝓟999{d}: 𝓛[ty]8655{Number}): (𝓟1000: 𝓛[ty]8655{Number})
 {
 return 𝓟1000 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟999{d},𝓛12573{SlashToken}(𝓟962{C3},𝓟959{C0})))
 }
 function 𝓟992{toMicros} (𝓟993{d}: 𝓛[ty]8655{Number}): (𝓟994: 𝓛[ty]8655{Number})
 {
 return 𝓟994 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟993{d},𝓛12573{SlashToken}(𝓟960{C1},𝓟959{C0})))
 }
 function 𝓟995{toMillis} (𝓟996{d}: 𝓛[ty]8655{Number}): (𝓟997: 𝓛[ty]8655{Number})
 {
 return 𝓟997 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟996{d},𝓛12573{SlashToken}(𝓟961{C2},𝓟959{C0})))
 }
 function 𝓟1004{toHours} (𝓟1005{d}: 𝓛[ty]8655{Number}): (𝓟1006: 𝓛[ty]8655{Number})
 {
 return 𝓟1006 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1005{d},𝓛12573{SlashToken}(𝓟964{C5},𝓟959{C0})))
 }
 function 𝓟1007{toDays} (𝓟1008{d}: 𝓛[ty]8655{Number}): (𝓟1009: 𝓛[ty]8655{Number})
 {
 return 𝓟1009 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1008{d},𝓛12573{SlashToken}(𝓟965{C6},𝓟959{C0})))
 }
 function 𝓟989{toNanos} (𝓟990{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟991: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟991 = 𝓟990{d}
 }
 function 𝓟1001{toMinutes} (𝓟1002{d}: 𝓛[ty]8655{Number}): (𝓟1003: 𝓛[ty]8655{Number})
 {
 return 𝓟1003 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1002{d},𝓛12573{SlashToken}(𝓟963{C4},𝓟959{C0})))
 }
 function 𝓟985{convert} (𝓟986{duration}: (𝓟[ty]1251{Duration} ≠ 𝓛[ty]8655{Number}),𝓟987{unit}: 𝓟[ty]928{TimeUnit}): (𝓟988: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟988 = 𝓟987{unit}.toNanos(𝓟986{duration})
 }
}
const 𝓟1010{NANOSECONDS}: (𝓟[ty]981{Nanoseconds} ≠ 𝓟[ty]928{TimeUnit}) = 𝓟977{CONSTRUCTOR}();
function 𝓟1011{CONSTRUCTOR} (): (𝓟[ty]1015{Microseconds})
{
 const 𝓟[ty]1015{Microseconds};
 const 𝓟[ty]1015{Microseconds};
 𝓟[ty]1015{Microseconds}.ord ⟵ 𝓛8745{Number};
 𝓟[ty]1015{Microseconds}.label ⟵ 𝓛8743{String};
}
class 𝓟[ty]1015{Microseconds} extends 𝓟[ty]928{TimeUnit}{
 𝓟1017{ord}: 𝓛[ty]8655{Number};
 𝓟1018{label}: [miss]𝓛[ty]10051{String};
 function 𝓟1032{toSeconds} (𝓟1033{d}: 𝓛[ty]8655{Number}): (𝓟1034: 𝓛[ty]8655{Number})
 {
 return 𝓟1034 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1033{d},𝓛12573{SlashToken}(𝓟962{C3},𝓟960{C1})))
 }
 function 𝓟1026{toMicros} (𝓟1027{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1028: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1028 = 𝓟1027{d}
 }
 function 𝓟1029{toMillis} (𝓟1030{d}: 𝓛[ty]8655{Number}): (𝓟1031: 𝓛[ty]8655{Number})
 {
 return 𝓟1031 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1030{d},𝓛12573{SlashToken}(𝓟961{C2},𝓟960{C1})))
 }
 function 𝓟1038{toHours} (𝓟1039{d}: 𝓛[ty]8655{Number}): (𝓟1040: 𝓛[ty]8655{Number})
 {
 return 𝓟1040 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1039{d},𝓛12573{SlashToken}(𝓟964{C5},𝓟960{C1})))
 }
 function 𝓟1041{toDays} (𝓟1042{d}: 𝓛[ty]8655{Number}): (𝓟1043: 𝓛[ty]8655{Number})
 {
 return 𝓟1043 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1042{d},𝓛12573{SlashToken}(𝓟965{C6},𝓟960{C1})))
 }
 function 𝓟1023{toNanos} (𝓟1024{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1025: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1025 = 𝓟972{x}(𝓟1024{d},𝓛12573{SlashToken}(𝓟960{C1},𝓟959{C0}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟960{C1},𝓟959{C0}))))
 }
 function 𝓟1035{toMinutes} (𝓟1036{d}: 𝓛[ty]8655{Number}): (𝓟1037: 𝓛[ty]8655{Number})
 {
 return 𝓟1037 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1036{d},𝓛12573{SlashToken}(𝓟963{C4},𝓟960{C1})))
 }
 function 𝓟1019{convert} (𝓟1020{duration}: (𝓟[ty]1251{Duration} ≠ 𝓛[ty]8655{Number}),𝓟1021{unit}: 𝓟[ty]928{TimeUnit}): (𝓟1022: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1022 = 𝓟1021{unit}.toMicros(𝓟1020{duration})
 }
}
const 𝓟1044{MICROSECONDS}: (𝓟[ty]981{Nanoseconds} ≠ 𝓟[ty]928{TimeUnit}) = 𝓟1011{CONSTRUCTOR}();
function 𝓟1045{CONSTRUCTOR} (): (𝓟[ty]1049{Milliseconds})
{
 const 𝓟[ty]1049{Milliseconds};
 const 𝓟[ty]1049{Milliseconds};
 𝓟[ty]1049{Milliseconds}.ord ⟵ 𝓛8745{Number};
 𝓟[ty]1049{Milliseconds}.label ⟵ 𝓛8743{String};
}
class 𝓟[ty]1049{Milliseconds} extends 𝓟[ty]928{TimeUnit}{
 𝓟1051{ord}: 𝓛[ty]8655{Number};
 𝓟1052{label}: [miss]𝓛[ty]10051{String};
 function 𝓟1066{toSeconds} (𝓟1067{d}: 𝓛[ty]8655{Number}): (𝓟1068: 𝓛[ty]8655{Number})
 {
 return 𝓟1068 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1067{d},𝓛12573{SlashToken}(𝓟962{C3},𝓟961{C2})))
 }
 function 𝓟1060{toMicros} (𝓟1061{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1062: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1062 = 𝓟972{x}(𝓟1061{d},𝓛12573{SlashToken}(𝓟961{C2},𝓟960{C1}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟961{C2},𝓟960{C1}))))
 }
 function 𝓟1063{toMillis} (𝓟1064{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1065: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1065 = 𝓟1064{d}
 }
 function 𝓟1072{toHours} (𝓟1073{d}: 𝓛[ty]8655{Number}): (𝓟1074: 𝓛[ty]8655{Number})
 {
 return 𝓟1074 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1073{d},𝓛12573{SlashToken}(𝓟964{C5},𝓟961{C2})))
 }
 function 𝓟1075{toDays} (𝓟1076{d}: 𝓛[ty]8655{Number}): (𝓟1077: 𝓛[ty]8655{Number})
 {
 return 𝓟1077 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1076{d},𝓛12573{SlashToken}(𝓟965{C6},𝓟961{C2})))
 }
 function 𝓟1057{toNanos} (𝓟1058{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1059: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1059 = 𝓟972{x}(𝓟1058{d},𝓛12573{SlashToken}(𝓟961{C2},𝓟959{C0}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟961{C2},𝓟959{C0}))))
 }
 function 𝓟1069{toMinutes} (𝓟1070{d}: 𝓛[ty]8655{Number}): (𝓟1071: 𝓛[ty]8655{Number})
 {
 return 𝓟1071 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1070{d},𝓛12573{SlashToken}(𝓟963{C4},𝓟961{C2})))
 }
 function 𝓟1053{convert} (𝓟1054{duration}: (𝓟[ty]1251{Duration} ≠ 𝓛[ty]8655{Number}),𝓟1055{unit}: 𝓟[ty]928{TimeUnit}): (𝓟1056: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1056 = 𝓟1055{unit}.toMillis(𝓟1054{duration})
 }
}
const 𝓟1078{MILLISECONDS}: (𝓟[ty]1049{Milliseconds} ≠ 𝓟[ty]928{TimeUnit}) = 𝓟1045{CONSTRUCTOR}();
function 𝓟1079{CONSTRUCTOR} (): (𝓟[ty]1083{Seconds})
{
 const 𝓟[ty]1083{Seconds};
 const 𝓟[ty]1083{Seconds};
 𝓟[ty]1083{Seconds}.ord ⟵ 𝓛8745{Number};
 𝓟[ty]1083{Seconds}.label ⟵ 𝓛8743{String};
}
class 𝓟[ty]1083{Seconds} extends 𝓟[ty]928{TimeUnit}{
 𝓟1085{ord}: 𝓛[ty]8655{Number};
 𝓟1086{label}: [miss]𝓛[ty]10051{String};
 function 𝓟1100{toSeconds} (𝓟1101{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1102: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1102 = 𝓟1101{d}
 }
 function 𝓟1094{toMicros} (𝓟1095{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1096: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1096 = 𝓟972{x}(𝓟1095{d},𝓛12573{SlashToken}(𝓟962{C3},𝓟960{C1}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟962{C3},𝓟960{C1}))))
 }
 function 𝓟1097{toMillis} (𝓟1098{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1099: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1099 = 𝓟972{x}(𝓟1098{d},𝓛12573{SlashToken}(𝓟962{C3},𝓟961{C2}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟962{C3},𝓟961{C2}))))
 }
 function 𝓟1106{toHours} (𝓟1107{d}: 𝓛[ty]8655{Number}): (𝓟1108: 𝓛[ty]8655{Number})
 {
 return 𝓟1108 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1107{d},𝓛12573{SlashToken}(𝓟964{C5},𝓟962{C3})))
 }
 function 𝓟1109{toDays} (𝓟1110{d}: 𝓛[ty]8655{Number}): (𝓟1111: 𝓛[ty]8655{Number})
 {
 return 𝓟1111 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1110{d},𝓛12573{SlashToken}(𝓟965{C6},𝓟962{C3})))
 }
 function 𝓟1091{toNanos} (𝓟1092{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1093: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1093 = 𝓟972{x}(𝓟1092{d},𝓛12573{SlashToken}(𝓟962{C3},𝓟959{C0}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟962{C3},𝓟959{C0}))))
 }
 function 𝓟1103{toMinutes} (𝓟1104{d}: 𝓛[ty]8655{Number}): (𝓟1105: 𝓛[ty]8655{Number})
 {
 return 𝓟1105 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1104{d},𝓛12573{SlashToken}(𝓟963{C4},𝓟962{C3})))
 }
 function 𝓟1087{convert} (𝓟1088{duration}: (𝓟[ty]1251{Duration} ≠ 𝓛[ty]8655{Number}),𝓟1089{unit}: 𝓟[ty]928{TimeUnit}): (𝓟1090: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1090 = 𝓟1089{unit}.toSeconds(𝓟1088{duration})
 }
}
const 𝓟1112{SECONDS}: (𝓟[ty]1185{Days} ≠ 𝓟[ty]928{TimeUnit}) = 𝓟1079{CONSTRUCTOR}();
function 𝓟1113{CONSTRUCTOR} (): (𝓟[ty]1117{Minutes})
{
 const 𝓟[ty]1117{Minutes};
 const 𝓟[ty]1117{Minutes};
 𝓟[ty]1117{Minutes}.ord ⟵ 𝓛8745{Number};
 𝓟[ty]1117{Minutes}.label ⟵ 𝓛8743{String};
}
class 𝓟[ty]1117{Minutes} extends 𝓟[ty]928{TimeUnit}{
 𝓟1119{ord}: 𝓛[ty]8655{Number};
 𝓟1120{label}: [miss]𝓛[ty]10051{String};
 function 𝓟1134{toSeconds} (𝓟1135{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1136: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1136 = 𝓟972{x}(𝓟1135{d},𝓛12573{SlashToken}(𝓟963{C4},𝓟962{C3}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟963{C4},𝓟962{C3}))))
 }
 function 𝓟1128{toMicros} (𝓟1129{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1130: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1130 = 𝓟972{x}(𝓟1129{d},𝓛12573{SlashToken}(𝓟963{C4},𝓟960{C1}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟963{C4},𝓟960{C1}))))
 }
 function 𝓟1131{toMillis} (𝓟1132{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1133: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1133 = 𝓟972{x}(𝓟1132{d},𝓛12573{SlashToken}(𝓟963{C4},𝓟961{C2}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟963{C4},𝓟961{C2}))))
 }
 function 𝓟1140{toHours} (𝓟1141{d}: 𝓛[ty]8655{Number}): (𝓟1142: 𝓛[ty]8655{Number})
 {
 return 𝓟1142 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1141{d},𝓛12573{SlashToken}(𝓟964{C5},𝓟963{C4})))
 }
 function 𝓟1143{toDays} (𝓟1144{d}: 𝓛[ty]8655{Number}): (𝓟1145: 𝓛[ty]8655{Number})
 {
 return 𝓟1145 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1144{d},𝓛12573{SlashToken}(𝓟965{C6},𝓟963{C4})))
 }
 function 𝓟1125{toNanos} (𝓟1126{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1127: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1127 = 𝓟972{x}(𝓟1126{d},𝓛12573{SlashToken}(𝓟963{C4},𝓟959{C0}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟963{C4},𝓟959{C0}))))
 }
 function 𝓟1137{toMinutes} (𝓟1138{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1139: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1139 = 𝓟1138{d}
 }
 function 𝓟1121{convert} (𝓟1122{duration}: (𝓟[ty]1251{Duration} ≠ 𝓛[ty]8655{Number}),𝓟1123{unit}: 𝓟[ty]928{TimeUnit}): (𝓟1124: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1124 = 𝓟1123{unit}.toMinutes(𝓟1122{duration})
 }
}
const 𝓟1146{MINUTES}: (𝓟[ty]3239{TimeoutError} ≠ 𝓟[ty]928{TimeUnit}) = 𝓟1113{CONSTRUCTOR}();
function 𝓟1147{CONSTRUCTOR} (): (𝓟[ty]1151{Hours})
{
 const 𝓟[ty]1151{Hours};
 const 𝓟[ty]1151{Hours};
 𝓟[ty]1151{Hours}.ord ⟵ 𝓛8745{Number};
 𝓟[ty]1151{Hours}.label ⟵ 𝓛8743{String};
}
class 𝓟[ty]1151{Hours} extends 𝓟[ty]928{TimeUnit}{
 𝓟1153{ord}: 𝓛[ty]8655{Number};
 𝓟1154{label}: [miss]𝓛[ty]10051{String};
 function 𝓟1168{toSeconds} (𝓟1169{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1170: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1170 = 𝓟972{x}(𝓟1169{d},𝓛12573{SlashToken}(𝓟964{C5},𝓟962{C3}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟964{C5},𝓟962{C3}))))
 }
 function 𝓟1162{toMicros} (𝓟1163{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1164: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1164 = 𝓟972{x}(𝓟1163{d},𝓛12573{SlashToken}(𝓟964{C5},𝓟960{C1}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟964{C5},𝓟960{C1}))))
 }
 function 𝓟1165{toMillis} (𝓟1166{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1167: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1167 = 𝓟972{x}(𝓟1166{d},𝓛12573{SlashToken}(𝓟964{C5},𝓟961{C2}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟964{C5},𝓟961{C2}))))
 }
 function 𝓟1174{toHours} (𝓟1175{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1176: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1176 = 𝓟1175{d}
 }
 function 𝓟1177{toDays} (𝓟1178{d}: 𝓛[ty]8655{Number}): (𝓟1179: 𝓛[ty]8655{Number})
 {
 return 𝓟1179 = 𝓟971{trunc}(𝓛12573{SlashToken}(𝓟1178{d},𝓛12573{SlashToken}(𝓟965{C6},𝓟964{C5})))
 }
 function 𝓟1159{toNanos} (𝓟1160{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1161: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1161 = 𝓟972{x}(𝓟1160{d},𝓛12573{SlashToken}(𝓟964{C5},𝓟959{C0}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟964{C5},𝓟959{C0}))))
 }
 function 𝓟1171{toMinutes} (𝓟1172{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1173: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1173 = 𝓟972{x}(𝓟1172{d},𝓛12573{SlashToken}(𝓟964{C5},𝓟963{C4}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟964{C5},𝓟963{C4}))))
 }
 function 𝓟1155{convert} (𝓟1156{duration}: (𝓟[ty]1251{Duration} ≠ 𝓛[ty]8655{Number}),𝓟1157{unit}: 𝓟[ty]928{TimeUnit}): (𝓟1158: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1158 = 𝓟1157{unit}.toHours(𝓟1156{duration})
 }
}
const 𝓟1180{HOURS}: (𝓟[ty]1117{Minutes} ≠ 𝓟[ty]928{TimeUnit}) = 𝓟1147{CONSTRUCTOR}();
function 𝓟1181{CONSTRUCTOR} (): (𝓟[ty]1185{Days})
{
 const 𝓟[ty]1185{Days};
 const 𝓟[ty]1185{Days};
 𝓟[ty]1185{Days}.ord ⟵ 𝓛8745{Number};
 𝓟[ty]1185{Days}.label ⟵ 𝓛8743{String};
}
class 𝓟[ty]1185{Days} extends 𝓟[ty]928{TimeUnit}{
 𝓟1187{ord}: 𝓛[ty]8655{Number};
 𝓟1188{label}: [miss]𝓛[ty]10051{String};
 function 𝓟1202{toSeconds} (𝓟1203{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1204: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1204 = 𝓟972{x}(𝓟1203{d},𝓛12573{SlashToken}(𝓟965{C6},𝓟962{C3}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟965{C6},𝓟962{C3}))))
 }
 function 𝓟1196{toMicros} (𝓟1197{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1198: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1198 = 𝓟972{x}(𝓟1197{d},𝓛12573{SlashToken}(𝓟965{C6},𝓟960{C1}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟965{C6},𝓟960{C1}))))
 }
 function 𝓟1199{toMillis} (𝓟1200{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1201: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1201 = 𝓟972{x}(𝓟1200{d},𝓛12573{SlashToken}(𝓟965{C6},𝓟961{C2}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟965{C6},𝓟961{C2}))))
 }
 function 𝓟1208{toHours} (𝓟1209{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1210: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1210 = 𝓟972{x}(𝓟1209{d},𝓛12573{SlashToken}(𝓟965{C6},𝓟964{C5}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟965{C6},𝓟964{C5}))))
 }
 function 𝓟1211{toDays} (𝓟1212{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1213: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1213 = 𝓟1212{d}
 }
 function 𝓟1193{toNanos} (𝓟1194{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1195: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1195 = 𝓟972{x}(𝓟1194{d},𝓛12573{SlashToken}(𝓟965{C6},𝓟959{C0}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟965{C6},𝓟959{C0}))))
 }
 function 𝓟1205{toMinutes} (𝓟1206{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1207: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1207 = 𝓟972{x}(𝓟1206{d},𝓛12573{SlashToken}(𝓟965{C6},𝓟963{C4}),𝓟971{trunc}(𝓛12573{SlashToken}(𝓟967{MAX},𝓛12573{SlashToken}(𝓟965{C6},𝓟963{C4}))))
 }
 function 𝓟1189{convert} (𝓟1190{duration}: (𝓟[ty]1251{Duration} ≠ 𝓛[ty]8655{Number}),𝓟1191{unit}: 𝓟[ty]928{TimeUnit}): (𝓟1192: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1192 = 𝓟1191{unit}.toDays(𝓟1190{duration})
 }
}
const 𝓟1214{DAYS}: (𝓟[ty]1185{Days} ≠ 𝓟[ty]928{TimeUnit}) = 𝓟1181{CONSTRUCTOR}();
function 𝓟1215{CONSTRUCTOR} (𝓟1216{duration}: (𝓟[ty]715{Try} ≠ 𝓛[ty]8655{Number}),𝓟1217{unit}: 𝓟[ty]928{TimeUnit}): (𝓟[ty]1251{Duration})
{
 const 𝓟[ty]1251{Duration};
 const 𝓟[ty]1251{Duration};
 if (𝓛8717{isNaN}(𝓟1216{duration}))
 {
 𝓟3217{CONSTRUCTOR}(𝓛8743{String})
 }
 𝓟[ty]1251{Duration}.duration ⟵ 𝓟971{trunc}(𝓟1216{duration});
 𝓟[ty]1251{Duration}.unit ⟵ 𝓟1217{unit};
}
function 𝓟1221{of} (𝓟1222{value}: [OOV]any): (𝓟1223: (𝓛[ty]8670{Array} ≠ 𝓟[ty]1251{Duration}))
{
 return 𝓟1223 = (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1222{value}),𝓛8743{String}) ? 𝓟1236{millis}(𝓟1222{value}) : 𝓟1222{value}
}
function 𝓟1224{zero} (): (𝓟1225: (𝓟[ty]238{ChainedCancelable} ≠ 𝓟[ty]1251{Duration}))
{
 return 𝓟1225 = 𝓟1215{CONSTRUCTOR}(𝓛8745{Number},𝓟1214{DAYS})
}
function 𝓟1226{inf} (): (𝓟1227: 𝓟[ty]1251{Duration})
{
 return 𝓟1227 = 𝓟1215{CONSTRUCTOR}(𝓛8706{Infinity},𝓟1214{DAYS})
}
function 𝓟1228{negInf} (): (𝓟1229: (𝓟[ty]238{ChainedCancelable} ≠ 𝓟[ty]1251{Duration}))
{
 return 𝓟1229 = 𝓟1215{CONSTRUCTOR}(𝓛12616{MinusToken}(𝓛8706{Infinity}),𝓟1214{DAYS})
}
function 𝓟1230{nanos} (𝓟1231{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1232: (𝓟[ty]238{ChainedCancelable} ≠ 𝓟[ty]1251{Duration}))
{
 return 𝓟1232 = 𝓟1215{CONSTRUCTOR}(𝓟1231{d},𝓟1010{NANOSECONDS})
}
function 𝓟1233{micros} (𝓟1234{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1235: 𝓟[ty]1251{Duration})
{
 return 𝓟1235 = 𝓟1215{CONSTRUCTOR}(𝓟1234{d},𝓟1044{MICROSECONDS})
}
function 𝓟1236{millis} (𝓟1237{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1238: 𝓟[ty]1251{Duration})
{
 return 𝓟1238 = 𝓟1215{CONSTRUCTOR}(𝓟1237{d},𝓟1078{MILLISECONDS})
}
function 𝓟1239{seconds} (𝓟1240{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1241: 𝓟[ty]1251{Duration})
{
 return 𝓟1241 = 𝓟1215{CONSTRUCTOR}(𝓟1240{d},𝓟1112{SECONDS})
}
function 𝓟1242{minutes} (𝓟1243{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1244: (𝓟[ty]238{ChainedCancelable} ≠ 𝓟[ty]1251{Duration}))
{
 return 𝓟1244 = 𝓟1215{CONSTRUCTOR}(𝓟1243{d},𝓟1146{MINUTES})
}
function 𝓟1245{hours} (𝓟1246{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1247: (𝓟[ty]238{ChainedCancelable} ≠ 𝓟[ty]1251{Duration}))
{
 return 𝓟1247 = 𝓟1215{CONSTRUCTOR}(𝓟1246{d},𝓟1180{HOURS})
}
function 𝓟1248{days} (𝓟1249{d}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1250: (𝓟[ty]238{ChainedCancelable} ≠ 𝓟[ty]1251{Duration}))
{
 return 𝓟1250 = 𝓟1215{CONSTRUCTOR}(𝓟1249{d},𝓟1214{DAYS})
}
class 𝓟[ty]1251{Duration} extends 𝓟[ty]3110{IEquals}{
 𝓟1253{duration}: 𝓛[ty]8655{Number};
 𝓟1254{unit}: 𝓟[ty]928{TimeUnit};
 function 𝓟1281{minus} (𝓟1282{other}: 𝓟[ty]1251{Duration}): (𝓟1283: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1251{Duration}))
 {
 return 𝓟1283 = 𝓟[ty]1251{Duration}.plus(𝓟1282{other}.negate())
 }
 function 𝓟1276{plus} (𝓟1277{other}: 𝓟[ty]1251{Duration}): (𝓟1278: 𝓟[ty]1251{Duration})
 {
 if (𝓛12569{ExclamationToken}(𝓟1255{isFinite}(𝓟[ty]1251{Duration}.duration)))
 {
 if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟1255{isFinite}(𝓟1277{other}.duration)),𝓛12612{ExclamationEqualsEqualsToken}(𝓟[ty]1251{Duration}.duration,𝓟1277{other}.duration)))
 {
 𝓟3217{CONSTRUCTOR}(𝓛12641{PlusToken}(𝓛8743{String},𝓛8743{String}))
 }
 return 𝓟1278 = 𝓟[ty]1251{Duration}
 }
 else
 {
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟1277{other}.duration,𝓛8745{Number}))
 {
 return 𝓟1278 = 𝓟[ty]1251{Duration}
 }
 else
 {
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]1251{Duration}.duration,𝓛8745{Number}))
 {
 return 𝓟1278 = 𝓟1277{other}
 }
 }
 }
 if (𝓛12569{ExclamationToken}(𝓟1255{isFinite}(𝓟1277{other}.duration)))
 {
 return 𝓟1278 = 𝓟1277{other}
 }
 let 𝓟1279{d1}: 𝓟[ty]1251{Duration} = 𝓟[ty]1251{Duration};
 let 𝓟1280{d2}: 𝓟[ty]1251{Duration} = 𝓟1277{other};
 if (𝓛1{<UNKNOWN>}(𝓟1280{d2}.unit.ord,𝓟1279{d1}.unit.ord))
 {
 𝓟1279{d1} ⟵ 𝓟1277{other};
 𝓟1280{d2} ⟵ 𝓟[ty]1251{Duration};
 }
 𝓟1280{d2} ⟵ 𝓟1280{d2}.convertTo(𝓟1279{d1}.unit);
 return 𝓟1278 = 𝓟1215{CONSTRUCTOR}(𝓛12641{PlusToken}(𝓟1279{d1}.duration,𝓟1280{d2}.duration),𝓟1279{d1}.unit)
 }
 function 𝓟1284{equals} (𝓟1285{other}: 𝓟[ty]1251{Duration}): (𝓟1286: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8666{Boolean}))
 {
 function 𝓟1287{cmp} (𝓟1288{s}: 𝓟[ty]1251{Duration},𝓟1289{o}: 𝓟[ty]1251{Duration}): (𝓟1290: [miss]𝓛[ty]8666{Boolean})
 {
 const 𝓟1291{n}: [miss]𝓛[ty]8655{Number} = 𝓟1288{s}.unit.convert(𝓟1289{o}.duration,𝓟1289{o}.unit);
 return 𝓟1290 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟1291{n},𝓟1288{s}.duration)
 }
 if (𝓛12569{ExclamationToken}(𝓟1255{isFinite}(𝓟[ty]1251{Duration}.duration)))
 {
 return 𝓟1286 = 𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟1255{isFinite}(𝓟1285{other}.duration)),𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]1251{Duration}.duration,𝓟1285{other}.duration))
 }
 return 𝓟1286 = (𝓛12582{LessThanEqualsToken}(𝓟[ty]1251{Duration}.unit.ord,𝓟1285{other}.unit.ord) ? 𝓟1287{cmp}(𝓟[ty]1251{Duration},𝓟1285{other}) : 𝓟1287{cmp}(𝓟1285{other},𝓟[ty]1251{Duration})
 }
 function 𝓟1263{toSeconds} (): (𝓟1264: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1264 = 𝓟1112{SECONDS}.convert(𝓟[ty]1251{Duration}.duration,𝓟[ty]1251{Duration}.unit)
 }
 function 𝓟1255{isFinite} (): (𝓟1256: 𝓛[ty]8666{Boolean})
 {
 return 𝓟1256 = 𝓟1255{isFinite}(𝓟[ty]1251{Duration}.duration)
 }
 function 𝓟1274{negate} (): (𝓟1275: 𝓟[ty]1251{Duration})
 {
 𝓛12577{$Switch}(𝓟[ty]1251{Duration}.duration)
 𝓛12634{$Case}(𝓛8706{Infinity})
 return 𝓟1275 = 𝓟1228{negInf}()
 𝓛12634{$Case}(𝓛12616{MinusToken}(𝓛8706{Infinity}))
 return 𝓟1275 = 𝓟1226{inf}()
 return 𝓟1275 = 𝓟1215{CONSTRUCTOR}(𝓛12616{MinusToken}(𝓟[ty]1251{Duration}.duration),𝓟[ty]1251{Duration}.unit)
 }
 function 𝓟1259{toMicros} (): (𝓟1260: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1260 = 𝓟1044{MICROSECONDS}.convert(𝓟[ty]1251{Duration}.duration,𝓟[ty]1251{Duration}.unit)
 }
 function 𝓟1261{toMillis} (): (𝓟1262: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1262 = 𝓟1078{MILLISECONDS}.convert(𝓟[ty]1251{Duration}.duration,𝓟[ty]1251{Duration}.unit)
 }
 function 𝓟1267{toHours} (): (𝓟1268: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1268 = 𝓟1180{HOURS}.convert(𝓟[ty]1251{Duration}.duration,𝓟[ty]1251{Duration}.unit)
 }
 function 𝓟1294{toString} (): (𝓟1295: 𝓛[ty]10051{String})
 {
 if (𝓟[ty]1251{Duration}.isFinite())
 {
 return 𝓟1295 = 𝓛12607{$Template}(𝓟[ty]1251{Duration}.duration,𝓟[ty]1251{Duration}.unit.label)
 }
 else
 {
 if (𝓛12596{GreaterThanEqualsToken}(𝓟[ty]1251{Duration}.duration,𝓛8745{Number}))
 {
 return 𝓟1295 = 𝓛8743{String}
 }
 else
 {
 return 𝓟1295 = 𝓛8743{String}
 }
 }
 }
 function 𝓟1269{toDays} (): (𝓟1270: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1270 = 𝓟1214{DAYS}.convert(𝓟[ty]1251{Duration}.duration,𝓟[ty]1251{Duration}.unit)
 }
 function 𝓟1271{convertTo} (𝓟1272{unit}: 𝓟[ty]928{TimeUnit}): (𝓟1273: 𝓟[ty]1251{Duration})
 {
 return 𝓟1273 = 𝓟1215{CONSTRUCTOR}(𝓟1272{unit}.convert(𝓟[ty]1251{Duration}.duration,𝓟[ty]1251{Duration}.unit),𝓟1272{unit})
 }
 function 𝓟1257{toNanos} (): (𝓟1258: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1258 = 𝓟1010{NANOSECONDS}.convert(𝓟[ty]1251{Duration}.duration,𝓟[ty]1251{Duration}.unit)
 }
 function 𝓟1265{toMinutes} (): (𝓟1266: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1266 = 𝓟1146{MINUTES}.convert(𝓟[ty]1251{Duration}.duration,𝓟[ty]1251{Duration}.unit)
 }
 function 𝓟1292{hashCode} (): (𝓟1293: 𝓛[ty]8655{Number})
 {
 if (𝓟[ty]1251{Duration}.isFinite())
 {
 return 𝓟1293 = 𝓟[ty]1251{Duration}.toNanos()
 }
 else
 {
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]1251{Duration}.duration,𝓛8706{Infinity}))
 {
 return 𝓟1293 = 𝓛8745{Number}
 }
 else
 {
 return 𝓟1293 = 𝓛8745{Number}
 }
 }
 }
}

Module: packages/funfix-exec/src/scheduler

function 𝓟1296{$Lambda196} (): (𝓟1297: [miss]𝓟[ty]1419{GlobalScheduler})
{
 return 𝓟1297 = 𝓟1528{globalSchedulerRef}
}
const 𝓟1298{global}: (𝓟[ty]1419{GlobalScheduler} ≠ 𝓟[ty]2308{DynamicRef}) = 𝓟2305{of}(𝓟1296{$Lambda196});
function 𝓟1299{CONSTRUCTOR} (𝓟1300{em}: 𝓟[ty]1380{ExecutionModel}): (𝓟[ty]1309{Scheduler})
{
 const 𝓟[ty]1309{Scheduler};
 const 𝓟[ty]1309{Scheduler};
 𝓟[ty]1309{Scheduler}.batchIndex ⟵ 𝓛8745{Number};
 𝓟[ty]1309{Scheduler}.executionModel ⟵ 𝓟1300{em};
 𝓛12577{$Switch}(𝓟1300{em}.type)
 𝓛12634{$Case}(𝓛8743{String})
 𝓟[ty]1309{Scheduler}.executeBatched ⟵ 𝓟[ty]1309{Scheduler}.executeAsync;
 𝓛12634{$Case}(𝓛8743{String})
 𝓟[ty]1309{Scheduler}.executeBatched ⟵ 𝓟[ty]1309{Scheduler}.trampoline;
 𝓛12634{$Case}(𝓛8743{String})
 const 𝓟1304{modulus}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓟1300{em}.recommendedBatchSize,𝓛8745{Number});
 function 𝓟1305{$Lambda191} (𝓟1306{r}): (𝓟1307: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟1308{next}: [miss]𝓛[ty]8655{Number} = 𝓛12608{AmpersandToken}(𝓛12641{PlusToken}(𝓟[ty]1309{Scheduler}.batchIndex,𝓛8745{Number}),𝓟1304{modulus});
 if (𝓟1308{next})
 {
 𝓟[ty]1309{Scheduler}.batchIndex ⟵ 𝓟1308{next};
 return 𝓟1307 = 𝓟[ty]1309{Scheduler}.trampoline(𝓟1306{r})
 }
 else
 {
 return 𝓟1307 = 𝓟[ty]1309{Scheduler}.executeAsync(𝓟1306{r})
 }
 }
 𝓟[ty]1309{Scheduler}.executeBatched ⟵ 𝓟1305{$Lambda191};
}
class 𝓟[ty]1309{Scheduler}{
 𝓟1311{executionModel}: 𝓟[ty]1380{ExecutionModel};
 𝓟1312{batchIndex}: 𝓛[ty]8655{Number};
 𝓟1313{executeBatched}: 𝓛[ty]8696{Function};
 function 𝓟1320{reportFailure} (𝓟1321{e}: [OOV]𝓟[ty]3170{Throwable}): (𝓟1322: 𝓛[ty]10033{Void})
 {
 }
 function 𝓟1325{scheduleOnce} (𝓟1326{delay}: [OOV]any,𝓟1327{runnable}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1328: [OOV]𝓟[ty]1{ICancelable})
 {
 }
 function 𝓟1323{currentTimeMillis} (): (𝓟1324: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8655{Number}))
 {
 }
 function 𝓟1317{trampoline} (𝓟1318{runnable}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1319: 𝓛[ty]10033{Void})
 {
 }
 function 𝓟1314{executeAsync} (𝓟1315{runnable}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1316: 𝓛[ty]10033{Void})
 {
 }
 function 𝓟1332{scheduleWithFixedDelay} (𝓟1333{initialDelay}: [OOV]any,𝓟1334{delay}: [OOV]any,𝓟1335{runnable}: 𝓛[ty]8696{Function}): (𝓟1336: [OOV]𝓟[ty]1{ICancelable})
 {
 function 𝓟1337{$Lambda192} (𝓟1338{self}: (𝓟[ty]1457{TestScheduler} ≠ 𝓟[ty]1309{Scheduler}),𝓟1339{ref}: [OOV]𝓟[ty]3{IAssignCancelable},𝓟1340{delayNow}: [OOV]any): (𝓟1341: [OOV]𝓟[ty]3{IAssignCancelable})
 {
 function 𝓟1342{$Lambda193} (): (𝓟1343: [miss]𝓛[ty]10033{Void})
 {
 𝓟1335{runnable}()
 𝓟1344{loop}(𝓟1338{self},𝓟1339{ref},𝓟1334{delay})
 }
 return 𝓟1341 = 𝓟1339{ref}.update(𝓟1338{self}.scheduleOnce(𝓟1340{delayNow},𝓟1342{$Lambda193}))
 }
 const 𝓟1344{loop}: [miss]𝓛[ty]8696{Function} = 𝓟1337{$Lambda192};
 const 𝓟1345{task}: [miss]𝓟[ty]150{MultiAssignCancelable} = 𝓟145{empty}();
 return 𝓟1336 = 𝓟1344{loop}(𝓟[ty]1309{Scheduler},𝓟1345{task},𝓟1333{initialDelay})
 }
 function 𝓟1346{scheduleAtFixedRate} (𝓟1347{initialDelay}: [OOV]any,𝓟1348{period}: [OOV]any,𝓟1349{runnable}: 𝓛[ty]8696{Function}): (𝓟1350: [OOV]𝓟[ty]1{ICancelable})
 {
 function 𝓟1351{$Lambda194} (𝓟1352{self}: (𝓟[ty]2014{IOMemoize} ≠ 𝓟[ty]1309{Scheduler}),𝓟1353{ref}: [OOV]𝓟[ty]3{IAssignCancelable},𝓟1354{delayNowMs}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟1355{periodMs}: 𝓛[ty]8655{Number}): (𝓟1356: [OOV]𝓟[ty]3{IAssignCancelable})
 {
 function 𝓟1357{$Lambda195} (): (𝓟1358: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟1359{startAt}: [miss]𝓛[ty]8655{Number} = 𝓟1352{self}.currentTimeMillis();
 𝓟1349{runnable}()
 const 𝓟1360{elapsedMs}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓟1352{self}.currentTimeMillis(),𝓟1359{startAt});
 const 𝓟1361{nextDelayMs}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.max(𝓛8745{Number},𝓛12616{MinusToken}(𝓟1355{periodMs},𝓟1360{elapsedMs}));
 𝓟1362{loop}(𝓟1352{self},𝓟1353{ref},𝓟1355{periodMs},𝓟1361{nextDelayMs})
 }
 return 𝓟1356 = 𝓟1353{ref}.update(𝓟1352{self}.scheduleOnce(𝓟1354{delayNowMs},𝓟1357{$Lambda195}))
 }
 const 𝓟1362{loop}: [miss]𝓛[ty]8696{Function} = 𝓟1351{$Lambda194};
 const 𝓟1363{task}: [miss]𝓟[ty]150{MultiAssignCancelable} = 𝓟145{empty}();
 return 𝓟1350 = 𝓟1362{loop}(𝓟[ty]1309{Scheduler},𝓟1363{task},(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1347{initialDelay}),𝓛8743{String}) ? 𝓟1347{initialDelay} : 𝓟1347{initialDelay}.toMillis(),(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟1348{period}),𝓛8743{String}) ? 𝓟1348{period} : 𝓟1348{period}.toMillis())
 }
 function 𝓟1329{withExecutionModel} (𝓟1330{em}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]1380{ExecutionModel})): (𝓟1331: (𝓛[ty]10033{Void} ≠ 𝓟[ty]1309{Scheduler}))
 {
 }
}
function 𝓟1364{$Lambda197} (): (𝓟1365: [miss]𝓟[ty]1380{ExecutionModel})
{
 return 𝓟1365 = 𝓟1377{batched}()
}
const 𝓟1366{global}: (𝓟[ty]1419{GlobalScheduler} ≠ 𝓟[ty]2308{DynamicRef}) = 𝓟2305{of}(𝓟1364{$Lambda197});
function 𝓟1367{CONSTRUCTOR} (𝓟1368{type}: [OOV]any,𝓟1369{batchSize}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟[ty]1380{ExecutionModel})
{
 const 𝓟[ty]1380{ExecutionModel};
 const 𝓟[ty]1380{ExecutionModel};
 𝓟[ty]1380{ExecutionModel}.type ⟵ 𝓟1368{type};
 𝓛12577{$Switch}(𝓟1368{type})
 𝓛12634{$Case}(𝓛8743{String})
 𝓟[ty]1380{ExecutionModel}.recommendedBatchSize ⟵ 𝓟2248{maxPowerOf2};
 𝓛12634{$Case}(𝓛8743{String})
 𝓟[ty]1380{ExecutionModel}.recommendedBatchSize ⟵ 𝓛8745{Number};
 𝓛12634{$Case}(𝓛8743{String})
 𝓟[ty]1380{ExecutionModel}.recommendedBatchSize ⟵ 𝓟2249{nextPowerOf2}(𝓛12546{BarBarToken}(𝓟1369{batchSize},𝓛8745{Number}));
}
function 𝓟1373{synchronous} (): (𝓟1374: 𝓟[ty]1380{ExecutionModel})
{
 return 𝓟1374 = 𝓟1367{CONSTRUCTOR}(𝓛8743{String})
}
function 𝓟1375{alwaysAsync} (): (𝓟1376: 𝓟[ty]1380{ExecutionModel})
{
 return 𝓟1376 = 𝓟1367{CONSTRUCTOR}(𝓛8743{String})
}
function 𝓟1377{batched} (𝓟1378{recommendedBatchSize}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟1379: 𝓟[ty]1380{ExecutionModel})
{
 return 𝓟1379 = 𝓟1367{CONSTRUCTOR}(𝓛8743{String},𝓟1378{recommendedBatchSize})
}
class 𝓟[ty]1380{ExecutionModel} extends 𝓟[ty]3110{IEquals}{
 𝓟1382{recommendedBatchSize}: 𝓛[ty]8655{Number};
 𝓟1383{type}: [OOV]any;
 function 𝓟1384{equals} (𝓟1385{other}: 𝓟[ty]1380{ExecutionModel}): (𝓟1386: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8666{Boolean}))
 {
 return 𝓟1386 = 𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]1380{ExecutionModel}.type,𝓟1385{other}.type),𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]1380{ExecutionModel}.recommendedBatchSize,𝓟1385{other}.recommendedBatchSize))
 }
 function 𝓟1387{hashCode} (): (𝓟1388: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}))
 {
 return 𝓟1388 = 𝓛12641{PlusToken}(𝓛12548{AsteriskToken}(𝓟3129{hashCodeOfString}(𝓟[ty]1380{ExecutionModel}.type),𝓛8745{Number}),𝓟[ty]1380{ExecutionModel}.recommendedBatchSize)
 }
}
function 𝓟1389{CONSTRUCTOR} (𝓟1390{reporter}: (𝓟[ty]928{TimeUnit} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]1394{Trampoline})
{
 const 𝓟[ty]1394{Trampoline};
 const 𝓟[ty]1394{Trampoline};
 𝓟[ty]1394{Trampoline}._isActive ⟵ 𝓛8744{Boolean};
 𝓟[ty]1394{Trampoline}._queue ⟵ 𝓛8757{Array}();
 𝓟[ty]1394{Trampoline}._reporter ⟵ 𝓟1390{reporter};
}
class 𝓟[ty]1394{Trampoline}{
 𝓟1396{_reporter}: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8696{Function});
 𝓟1397{_queue}: 𝓛[ty]8670{Array};
 𝓟1398{_isActive}: 𝓛[ty]8666{Boolean};
 function 𝓟1399{execute} (𝓟1400{r}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1401: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]1394{Trampoline}._isActive))
 {
 𝓟[ty]1394{Trampoline}.runLoop(𝓟1400{r})
 }
 else
 {
 𝓟[ty]1394{Trampoline}._queue.push(𝓟1400{r})
 }
 }
 function 𝓟1402{runLoop} (𝓟1403{r}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1404: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]1394{Trampoline}._isActive ⟵ 𝓛8744{Boolean};
 {
 let 𝓟1405{cursor}: [OOV]any = 𝓟1403{r};
 while (𝓟1405{cursor})
 {
 {
 𝓟1405{cursor}()
 }
 𝓟1405{cursor} ⟵ 𝓟[ty]1394{Trampoline}._queue.pop();
 }
 }
 {
 𝓟[ty]1394{Trampoline}._isActive ⟵ 𝓛8744{Boolean};
 }
 }
}
function 𝓟1406{CONSTRUCTOR} (𝓟1407{canUseSetImmediate}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8666{Boolean}),𝓟1408{em}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1380{ExecutionModel}),𝓟1409{reporter}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]1419{GlobalScheduler})
{
 const 𝓟[ty]1419{GlobalScheduler};
 const 𝓟[ty]1419{GlobalScheduler};
 𝓟[ty]1419{GlobalScheduler}(𝓟1408{em})
 if (𝓟1409{reporter})
 {
 𝓟[ty]1419{GlobalScheduler}.reportFailure ⟵ 𝓟1409{reporter};
 }
 𝓟[ty]1419{GlobalScheduler}._trampoline ⟵ 𝓟1389{CONSTRUCTOR}(𝓟[ty]1419{GlobalScheduler}.reportFailure);
 𝓟[ty]1419{GlobalScheduler}._useSetImmediate ⟵ 𝓛12592{AmpersandAmpersandToken}(𝓛12546{BarBarToken}(𝓟1407{canUseSetImmediate},𝓛8744{Boolean}),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓛10082{setImmediate}),𝓛8743{String}));
 function 𝓟1413{$Lambda198} (𝓟1414{r}): (𝓟1415: [OOV]any)
 {
 return 𝓟1415 = 𝓛10082{setImmediate}(𝓟1529{safeRunnable}(𝓟1414{r},𝓟[ty]1419{GlobalScheduler}.reportFailure))
 }
 function 𝓟1416{$Lambda199} (𝓟1417{r}): (𝓟1418: [miss]𝓛[ty]8655{Number})
 {
 return 𝓟1418 = 𝓛12490{setTimeout}(𝓟1529{safeRunnable}(𝓟1417{r},𝓟[ty]1419{GlobalScheduler}.reportFailure))
 }
 𝓟[ty]1419{GlobalScheduler}.executeAsync ⟵ (𝓟[ty]1419{GlobalScheduler}._useSetImmediate ? 𝓟1413{$Lambda198} : 𝓟1416{$Lambda199};
}
class 𝓟[ty]1419{GlobalScheduler} extends 𝓟[ty]1309{Scheduler}{
 𝓟1421{_useSetImmediate}: 𝓛[ty]8666{Boolean};
 𝓟1422{_trampoline}: 𝓟[ty]1394{Trampoline};
 function 𝓟1429{reportFailure} (𝓟1430{e}: [OOV]𝓟[ty]3170{Throwable}): (𝓟1431: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓟1430{e})
 }
 function 𝓟1434{scheduleOnce} (𝓟1435{delay}: [OOV]any,𝓟1436{runnable}: 𝓛[ty]8696{Function}): (𝓟1437: [OOV]𝓟[ty]1{ICancelable})
 {
 function 𝓟1438{$Lambda200} (): (𝓟1439: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]1419{GlobalScheduler}.batchIndex ⟵ 𝓛8745{Number};
 {
 𝓟1436{runnable}()
 }
 }
 const 𝓟1440{r}: [miss]𝓛[ty]8696{Function} = 𝓟1438{$Lambda200};
 const 𝓟1441{ms}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.max(𝓛8745{Number},𝓟1221{of}(𝓟1435{delay}).toMillis());
 const 𝓟1442{task}: [miss]𝓛[ty]8655{Number} = 𝓛12490{setTimeout}(𝓟1440{r},𝓟1441{ms});
 function 𝓟1443{$Lambda201} (): (𝓟1444: [miss]𝓛[ty]10033{Void})
 {
 return 𝓟1444 = 𝓛12465{clearTimeout}(𝓟1442{task})
 }
 return 𝓟1437 = 𝓟8{of}(𝓟1443{$Lambda201})
 }
 function 𝓟1432{currentTimeMillis} (): (𝓟1433: 𝓛[ty]8655{Number})
 {
 return 𝓟1433 = 𝓛8747{Date}.now()
 }
 function 𝓟1426{trampoline} (𝓟1427{runnable}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1428: (𝓛[ty]8654{Promise} ≠ 𝓛[ty]10033{Void}))
 {
 return 𝓟1428 = 𝓟[ty]1419{GlobalScheduler}._trampoline.execute(𝓟1427{runnable})
 }
 function 𝓟1423{executeAsync} (𝓟1424{runnable}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1425: 𝓛[ty]10033{Void})
 {
 𝓟3225{CONSTRUCTOR}(𝓛8743{String})
 }
 function 𝓟1445{withExecutionModel} (𝓟1446{em}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1380{ExecutionModel})): (𝓟1447: [miss]𝓟[ty]1419{GlobalScheduler})
 {
 return 𝓟1447 = 𝓟1406{CONSTRUCTOR}(𝓟[ty]1419{GlobalScheduler}._useSetImmediate,𝓟1446{em})
 }
}
function 𝓟1448{CONSTRUCTOR} (𝓟1449{reporter}: (𝓟[ty]2528{FlatMap} ≠ 𝓛[ty]8696{Function}),𝓟1450{em}: (𝓟[ty]1779{IO} ≠ 𝓟[ty]1380{ExecutionModel})): (𝓟[ty]1457{TestScheduler})
{
 const 𝓟[ty]1457{TestScheduler};
 const 𝓟[ty]1457{TestScheduler};
 𝓟[ty]1457{TestScheduler}(𝓟1450{em})
 function 𝓟1454{$Lambda202} (𝓟1455{_}): (𝓟1456: [miss]𝓛[ty]10033{Void})
 {
 }
 𝓟[ty]1457{TestScheduler}._reporter ⟵ 𝓛12546{BarBarToken}(𝓟1449{reporter},𝓟1454{$Lambda202});
 𝓟[ty]1457{TestScheduler}._trampoline ⟵ 𝓟1389{CONSTRUCTOR}(𝓟[ty]1457{TestScheduler}.reportFailure.bind(𝓟[ty]1457{TestScheduler}));
}
class 𝓟[ty]1457{TestScheduler} extends 𝓟[ty]1309{Scheduler}{
 𝓟1459{_reporter}: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8696{Function});
 𝓟1460{_trampoline}: 𝓟[ty]1394{Trampoline};
 𝓟1461{_stateRef}: (𝓟[ty]2029{IOContext} ≠ 𝓟[ty]1516{TestSchedulerState});
 function 𝓟1508{tickOne} (): (𝓟1509: 𝓛[ty]8666{Boolean})
 {
 const 𝓟1510{state}: [miss]𝓟[ty]1516{TestSchedulerState} = 𝓟[ty]1457{TestScheduler}._state();
 const 𝓟1511{peek}: [miss]𝓛[ty]8670{Array} = (𝓛12595{GreaterThanToken}(𝓟1510{state}.tasks.length,𝓛8745{Number}) ? 𝓟1510{state}.tasks.access(𝓛12616{MinusToken}(𝓟1510{state}.tasks.length,𝓛8745{Number})) : 𝓛12643{undefined};
 if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟1511{peek}),𝓛12595{GreaterThanToken}(𝓟1511{peek}.access(𝓛8745{Number}),𝓟1510{state}.clock)))
 {
 return 𝓟1509 = 𝓛8744{Boolean}
 }
 𝓟[ty]1457{TestScheduler}._state().tasks.pop()
 𝓟[ty]1457{TestScheduler}.batchIndex ⟵ 𝓛8745{Number};
 {
 𝓟1511{peek}.access(𝓛8745{Number})()
 }
 return 𝓟1509 = 𝓛8744{Boolean}
 }
 function 𝓟1474{reportFailure} (𝓟1475{e}: [OOV]𝓟[ty]3170{Throwable}): (𝓟1476: 𝓛[ty]10033{Void})
 {
 𝓟[ty]1457{TestScheduler}._state().triggeredFailures.push(𝓟1475{e})
 𝓟[ty]1457{TestScheduler}._reporter(𝓟1475{e})
 }
 function 𝓟1462{_state} (): (𝓟1463: [miss]𝓟[ty]1516{TestSchedulerState})
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]1457{TestScheduler}._stateRef))
 {
 𝓟[ty]1457{TestScheduler}._stateRef ⟵ 𝓟1512{CONSTRUCTOR}();
 𝓟[ty]1457{TestScheduler}._stateRef.updateTasks(𝓛8757{Array}())
 }
 return 𝓟1463 = 𝓟[ty]1457{TestScheduler}._stateRef
 }
 function 𝓟1479{scheduleOnce} (𝓟1480{delay}: [OOV]any,𝓟1481{runnable}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1482: [OOV]𝓟[ty]1{ICancelable})
 {
 const 𝓟1483{d}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.max(𝓛8745{Number},𝓟1221{of}(𝓟1480{delay}).toMillis());
 const 𝓟1484{state}: [miss]𝓟[ty]1516{TestSchedulerState} = 𝓟[ty]1457{TestScheduler}._state();
 const 𝓟1485{scheduleAt}: [miss]𝓛[ty]8655{Number} = 𝓛12641{PlusToken}(𝓟1484{state}.clock,𝓟1483{d});
 const 𝓟1486{insertAt}: [miss]𝓛[ty]8655{Number} = 𝓟1484{state}.tasksSearch(𝓛12616{MinusToken}(𝓟1485{scheduleAt}));
 const 𝓟1487{ref}: 𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓟1485{scheduleAt},𝓟1481{runnable});
 𝓟1484{state}.tasks.splice(𝓟1486{insertAt},𝓛8745{Number},𝓟1487{ref})
 function 𝓟1488{$Lambda203} (): (𝓟1489: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟1490{filtered}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
 {
 const 𝓟1491{e}: [miss]𝓛[ty]8670{Array} = 𝓛12589{$ArrayAccess}(𝓟1484{state}.tasks);
 while (𝓛8744{Boolean})
 {
 if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟1491{e},𝓟1487{ref}))
 {
 𝓟1490{filtered}.push(𝓟1491{e})
 }
 }
 }
 𝓟1484{state}.updateTasks(𝓟1490{filtered})
 }
 return 𝓟1482 = 𝓟8{of}(𝓟1488{$Lambda203})
 }
 function 𝓟1464{triggeredFailures} (): (𝓟1465: (𝓛[ty]8654{Promise} ≠ 𝓛[ty]8670{Array}))
 {
 return 𝓟1465 = 𝓟[ty]1457{TestScheduler}._state().triggeredFailures
 }
 function 𝓟1477{currentTimeMillis} (): (𝓟1478: 𝓛[ty]8655{Number})
 {
 return 𝓟1478 = 𝓟[ty]1457{TestScheduler}._state().clock
 }
 function 𝓟1471{trampoline} (𝓟1472{runnable}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1473: 𝓛[ty]10033{Void})
 {
 𝓟[ty]1457{TestScheduler}._trampoline.execute(𝓟1472{runnable})
 }
 function 𝓟1496{tick} (𝓟1497{duration}: [OOV]any): (𝓟1498: 𝓛[ty]8655{Number})
 {
 const 𝓟1499{state}: [miss]𝓟[ty]1516{TestSchedulerState} = 𝓟[ty]1457{TestScheduler}._state();
 let 𝓟1500{toExecute}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
 let 𝓟1501{jumpMs}: [miss]𝓛[ty]8655{Number} = 𝓟1221{of}(𝓛12546{BarBarToken}(𝓟1497{duration},𝓛8745{Number})).toMillis();
 let 𝓟1502{executed}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓛8744{Boolean})
 {
 const 𝓟1503{peek}: [miss]𝓛[ty]8670{Array} = (𝓛12595{GreaterThanToken}(𝓟1499{state}.tasks.length,𝓛8745{Number}) ? 𝓟1499{state}.tasks.access(𝓛12616{MinusToken}(𝓟1499{state}.tasks.length,𝓛8745{Number})) : 𝓛12643{undefined};
 if (𝓛12592{AmpersandAmpersandToken}(𝓟1503{peek},𝓛12582{LessThanEqualsToken}(𝓟1503{peek}.access(𝓛8745{Number}),𝓟1499{state}.clock)))
 {
 𝓟1500{toExecute}.push(𝓟1499{state}.tasks.pop())
 }
 else
 {
 if (𝓛12595{GreaterThanToken}(𝓟1500{toExecute}.length,𝓛8745{Number}))
 {
 while (𝓛12595{GreaterThanToken}(𝓟1500{toExecute}.length,𝓛8745{Number}))
 {
 const 𝓟1504{index}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.floor(𝓛12548{AsteriskToken}(𝓛8746{Math}.random(),𝓟1500{toExecute}.length));
 const 𝓟1505{elem} = 𝓟1500{toExecute}.access(𝓟1504{index}) as any;
 {
 𝓟1500{toExecute}.splice(𝓟1504{index},𝓛8745{Number})
 𝓟[ty]1457{TestScheduler}.batchIndex ⟵ 𝓛8745{Number};
 𝓟1505{elem}.access(𝓛8745{Number})()
 }
 {
 𝓛12564{FirstCompoundAssignment}(𝓟1502{executed},𝓛8745{Number})
 }
 }
 }
 else
 {
 if (𝓛12595{GreaterThanToken}(𝓟1501{jumpMs},𝓛8745{Number}))
 {
 const 𝓟1506{nextTaskJump}: [miss]𝓛[ty]8655{Number} = 𝓛12546{BarBarToken}(𝓛12592{AmpersandAmpersandToken}(𝓟1503{peek},𝓛12616{MinusToken}(𝓟1503{peek}.access(𝓛8745{Number}),𝓟1499{state}.clock)),𝓟1501{jumpMs});
 const 𝓟1507{add}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.min(𝓟1506{nextTaskJump},𝓟1501{jumpMs});
 𝓛12564{FirstCompoundAssignment}(𝓟1499{state}.clock,𝓟1507{add})
 𝓛12606{MinusEqualsToken}(𝓟1501{jumpMs},𝓟1507{add})
 }
 }
 }
 }
 return 𝓟1498 = 𝓟1502{executed}
 }
 function 𝓟1468{executeAsync} (𝓟1469{runnable}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1470: 𝓛[ty]10033{Void})
 {
 𝓟[ty]1457{TestScheduler}._state().tasks.push(𝓛8757{Array}(𝓟[ty]1457{TestScheduler}._state().clock,𝓟1469{runnable}))
 }
 function 𝓟1466{hasTasksLeft} (): (𝓟1467: 𝓛[ty]8666{Boolean})
 {
 return 𝓟1467 = 𝓛12595{GreaterThanToken}(𝓟[ty]1457{TestScheduler}._state().tasks.length,𝓛8745{Number})
 }
 function 𝓟1492{withExecutionModel} (𝓟1493{em}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1380{ExecutionModel})): (𝓟1494: (𝓟[ty]30{WrapFn} ≠ 𝓟[ty]1457{TestScheduler}))
 {
 const 𝓟1495{ec2}: [miss]𝓟[ty]1457{TestScheduler} = 𝓟1448{CONSTRUCTOR}(𝓟[ty]1457{TestScheduler}._reporter,𝓟1493{em});
 𝓟1495{ec2}._stateRef ⟵ 𝓟[ty]1457{TestScheduler}._state();
 return 𝓟1494 = 𝓟1495{ec2}
 }
}
function 𝓟1512{CONSTRUCTOR} (): (𝓟[ty]1516{TestSchedulerState})
{
 const 𝓟[ty]1516{TestSchedulerState};
 const 𝓟[ty]1516{TestSchedulerState};
 𝓟[ty]1516{TestSchedulerState}.clock ⟵ 𝓛8745{Number};
 𝓟[ty]1516{TestSchedulerState}.triggeredFailures ⟵ 𝓛8757{Array}();
 𝓟[ty]1516{TestSchedulerState}.updateTasks(𝓛8757{Array}())
}
class 𝓟[ty]1516{TestSchedulerState}{
 𝓟1518{clock}: 𝓛[ty]8655{Number};
 𝓟1519{triggeredFailures}: 𝓛[ty]8670{Array};
 𝓟1520{tasks}: 𝓛[ty]8670{Array};
 𝓟1521{tasksSearch}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8696{Function});
 function 𝓟1522{updateTasks} (𝓟1523{tasks}: 𝓛[ty]8670{Array}): (𝓟1524: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]1516{TestSchedulerState}.tasks ⟵ 𝓟1523{tasks};
 function 𝓟1525{$Lambda204} (𝓟1526{e}): (𝓟1527: [miss]𝓛[ty]8655{Number})
 {
 return 𝓟1527 = 𝓛12616{MinusToken}(𝓟1526{e}.access(𝓛8745{Number}))
 }
 𝓟[ty]1516{TestSchedulerState}.tasksSearch ⟵ 𝓟2226{arrayBSearchInsertPos}(𝓟[ty]1516{TestSchedulerState}.tasks,𝓟1525{$Lambda204});
 }
}
const 𝓟1528{globalSchedulerRef}: [miss]𝓟[ty]1419{GlobalScheduler} = 𝓟1406{CONSTRUCTOR}(𝓛8744{Boolean});
function 𝓟1529{safeRunnable} (𝓟1530{r}: 𝓛[ty]8696{Function},𝓟1531{reporter}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1532: 𝓛[ty]8696{Function})
{
 function 𝓟1533{$Lambda205} (): (𝓟1534: [miss]𝓛[ty]10033{Void})
 {
 {
 𝓟1530{r}()
 }
 }
 return 𝓟1532 = 𝓟1533{$Lambda205}
}

Module: packages/funfix-exec/src/index

Module: packages/funfix-effect/src/io

type 𝓟[ty]1535{BindT} = any
type 𝓟[ty]1536{Bind} = (any)->𝓟[ty]1779{IO}
type 𝓛[ty]2{<UNKNOWN>} = 𝓛[ty]2{<UNKNOWN>}
type 𝓟[ty]1779{IO} = 𝓟[ty]1779{IO}
type 𝓟[ty]1539{IORegister} = (𝓟[ty]2029{IOContext},((𝓟[ty]715{Try})->𝓛[ty]10033{Void}))->𝓛[ty]10033{Void}
type 𝓛[ty]8670{Array} = 𝓛[ty]8670{Array}
type 𝓟[ty]1541{IOOptions} = {autoCancelableRunLoops: 𝓛[ty]8666{Boolean}}
const 𝓟1542{_Class}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO});
function 𝓟1543{CONSTRUCTOR} (): (𝓟[ty]1779{IO})
{
 const 𝓟[ty]1779{IO};
 const 𝓟[ty]1779{IO};
}
function 𝓟1547{always} (𝓟1548{thunk}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function})): (𝓟1549: (𝓟[ty]2014{IOMemoize} ≠ 𝓟[ty]1779{IO}))
{
 return 𝓟1549 = 𝓟1977{CONSTRUCTOR}(𝓟1548{thunk})
}
function 𝓟1550{async} (𝓟1551{register}: 𝓛[ty]8696{Function}): (𝓟1552: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
{
 function 𝓟1553{$Lambda91} (𝓟1554{ctx},𝓟1555{cb}): (𝓟1556: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟1557{ec} = 𝓟1554{ctx}.scheduler;
 const 𝓟1558{conn} = 𝓟1554{ctx}.connection;
 function 𝓟1559{$Lambda92} (): (𝓟1560: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟1561{safe}: [miss]𝓛[ty]8696{Function} = 𝓟2165{ioSafeCallback}(𝓟1557{ec},𝓟1558{conn},𝓟1555{cb});
 {
 const 𝓟1562{ref} = 𝓟1551{register}(𝓟1557{ec},𝓟1561{safe});
 𝓟1558{conn}.push(𝓛12546{BarBarToken}(𝓟1562{ref},𝓟11{empty}()))
 }
 }
 𝓟1557{ec}.trampoline(𝓟1559{$Lambda92})
 }
 return 𝓟1552 = 𝓟1563{asyncUnsafe}(𝓟1553{$Lambda91})
}
function 𝓟1563{asyncUnsafe} (𝓟1564{register}: [OOV]𝓟[ty]1539{IORegister}): (𝓟1565: (𝓟[ty]811{TFailure} ≠ 𝓟[ty]1779{IO}))
{
 return 𝓟1565 = 𝓟1999{CONSTRUCTOR}(𝓟1564{register})
}
function 𝓟1566{defer} (𝓟1567{thunk}: 𝓛[ty]8696{Function}): (𝓟1568: 𝓟[ty]1779{IO})
{
 function 𝓟1569{$Lambda93} (): (𝓟1570: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1570 = 𝓟1567{thunk}()
 }
 return 𝓟1568 = 𝓟1772{unit}().flatMap(𝓟1569{$Lambda93})
}
function 𝓟1571{deferAction} (𝓟1572{f}: 𝓛[ty]8696{Function}): (𝓟1573: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
{
 function 𝓟1574{$Lambda94} (𝓟1575{ctx},𝓟1576{cb}): (𝓟1577: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟1578{ec} = 𝓟1575{ctx}.scheduler;
 let 𝓟1579{ioa}: 𝓟[ty]1779{IO};
 {
 𝓟1579{ioa} ⟵ 𝓟1572{f}(𝓟1578{ec});
 }
 function 𝓟1580{$Lambda95} (): (𝓟1581: [OOV]any)
 {
 return 𝓟1581 = 𝓟1774{unsafeStart}(𝓟1579{ioa},𝓟1575{ctx},𝓟1576{cb})
 }
 𝓟1578{ec}.trampoline(𝓟1580{$Lambda95})
 }
 return 𝓟1573 = 𝓟1563{asyncUnsafe}(𝓟1574{$Lambda94})
}
function 𝓟1582{deferFuture} (𝓟1583{thunk}: 𝓛[ty]8696{Function}): (𝓟1584: 𝓟[ty]1779{IO})
{
 function 𝓟1585{$Lambda96} (): (𝓟1586: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1586 = 𝓟1607{fromFuture}(𝓟1583{thunk}())
 }
 return 𝓟1584 = 𝓟1760{suspend}(𝓟1585{$Lambda96})
}
function 𝓟1587{deferFutureAction} (𝓟1588{f}: 𝓛[ty]8696{Function}): (𝓟1589: 𝓟[ty]1779{IO})
{
 function 𝓟1590{$Lambda97} (𝓟1591{ec}): (𝓟1592: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1592 = 𝓟1607{fromFuture}(𝓟1588{f}(𝓟1591{ec}))
 }
 return 𝓟1589 = 𝓟1571{deferAction}(𝓟1590{$Lambda97})
}
function 𝓟1593{delayedTick} (𝓟1594{delay}: [OOV]any): (𝓟1595: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
{
 function 𝓟1596{$Lambda98} (𝓟1597{ctx},𝓟1598{cb}): (𝓟1599: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟1600{conn} = 𝓟1597{ctx}.connection;
 function 𝓟1601{$Lambda99} (): (𝓟1602: [miss]𝓛[ty]10033{Void})
 {
 𝓟1600{conn}.pop()
 𝓟1598{cb}(𝓟662{unit}())
 }
 const 𝓟1603{task} = 𝓟1597{ctx}.scheduler.scheduleOnce(𝓟1594{delay},𝓟1601{$Lambda99});
 𝓟1600{conn}.push(𝓟1603{task})
 }
 return 𝓟1595 = 𝓟1563{asyncUnsafe}(𝓟1596{$Lambda98})
}
function 𝓟1604{firstCompletedOf} (𝓟1605{list}: [OOV]any): (𝓟1606: (𝓛[ty]8654{Promise} ≠ 𝓟[ty]1779{IO}))
{
 return 𝓟1606 = 𝓟2209{ioListToFutureProcess}(𝓟1605{list},𝓟2653{firstCompletedOf})
}
function 𝓟1607{fromFuture} (𝓟1608{fa}: (𝓟[ty]1982{IOAlways} ≠ 𝓟[ty]2729{Future})): (𝓟1609: 𝓟[ty]1779{IO})
{
 if (𝓛12569{ExclamationToken}(𝓟1608{fa}.value().isEmpty()))
 {
 return 𝓟1609 = 𝓟1617{fromTry}(𝓟1608{fa}.value().get() as any)
 }
 function 𝓟1610{$Lambda100} (𝓟1611{ctx},𝓟1612{cb}): (𝓟1613: [miss]𝓛[ty]10033{Void})
 {
 𝓟1611{ctx}.connection.push(𝓟1608{fa})
 function 𝓟1614{$Lambda101} (𝓟1615{result}): (𝓟1616: [miss]𝓛[ty]10033{Void})
 {
 𝓟1611{ctx}.connection.pop()
 𝓟1612{cb}(𝓟1615{result} as any)
 }
 𝓟1608{fa}.onComplete(𝓟1614{$Lambda101})
 }
 return 𝓟1609 = 𝓟1563{asyncUnsafe}(𝓟1610{$Lambda100})
}
function 𝓟1617{fromTry} (𝓟1618{a}: (𝓟[ty]1779{IO} ≠ 𝓟[ty]715{Try})): (𝓟1619: (𝓟[ty]2850{PureFuture} ≠ 𝓟[ty]1779{IO}))
{
 return 𝓟1619 = 𝓟1950{CONSTRUCTOR}(𝓟1618{a})
}
function 𝓟1620{fork} (𝓟1621{fa}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1779{IO}),𝓟1622{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟1623: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}))
{
 function 𝓟1624{$Lambda102} (): (𝓟1625: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1625 = 𝓟1621{fa}
 }
 return 𝓟1623 = 𝓟1757{shift}(𝓟1622{ec}).flatMap(𝓟1624{$Lambda102})
}
function 𝓟1626{map2} (𝓟1627{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1628{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1629{f}: 𝓛[ty]8696{Function}): (𝓟1630: 𝓟[ty]1779{IO})
{
 const 𝓟1631{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}) = 𝓟1751{sequence}(𝓛8757{Array}(𝓟1627{fa1},𝓟1628{fa2}) as 𝓛[ty]8670{Array});
 function 𝓟1632{$Lambda103} (𝓟1633{lst}): (𝓟1634: [OOV]any)
 {
 return 𝓟1634 = 𝓟1629{f}(𝓟1633{lst}.access(𝓛8745{Number}),𝓟1633{lst}.access(𝓛8745{Number}))
 }
 return 𝓟1630 = 𝓟1631{fl}.map(𝓟1632{$Lambda103})
}
function 𝓟1635{map3} (𝓟1636{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1637{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1638{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1639{f}: 𝓛[ty]8696{Function}): (𝓟1640: 𝓟[ty]1779{IO})
{
 const 𝓟1641{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}) = 𝓟1751{sequence}(𝓛8757{Array}(𝓟1636{fa1},𝓟1637{fa2},𝓟1638{fa3}) as 𝓛[ty]8670{Array});
 function 𝓟1642{$Lambda104} (𝓟1643{lst}): (𝓟1644: [OOV]any)
 {
 return 𝓟1644 = 𝓟1639{f}(𝓟1643{lst}.access(𝓛8745{Number}),𝓟1643{lst}.access(𝓛8745{Number}),𝓟1643{lst}.access(𝓛8745{Number}))
 }
 return 𝓟1640 = 𝓟1641{fl}.map(𝓟1642{$Lambda104})
}
function 𝓟1645{map4} (𝓟1646{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1647{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1648{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1649{fa4}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1650{f}: 𝓛[ty]8696{Function}): (𝓟1651: 𝓟[ty]1779{IO})
{
 const 𝓟1652{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}) = 𝓟1751{sequence}(𝓛8757{Array}(𝓟1646{fa1},𝓟1647{fa2},𝓟1648{fa3},𝓟1649{fa4}) as 𝓛[ty]8670{Array});
 function 𝓟1653{$Lambda105} (𝓟1654{lst}): (𝓟1655: [OOV]any)
 {
 return 𝓟1655 = 𝓟1650{f}(𝓟1654{lst}.access(𝓛8745{Number}),𝓟1654{lst}.access(𝓛8745{Number}),𝓟1654{lst}.access(𝓛8745{Number}),𝓟1654{lst}.access(𝓛8745{Number}))
 }
 return 𝓟1651 = 𝓟1652{fl}.map(𝓟1653{$Lambda105})
}
function 𝓟1656{map5} (𝓟1657{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1658{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1659{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1660{fa4}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1661{fa5}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]1779{IO}),𝓟1662{f}: 𝓛[ty]8696{Function}): (𝓟1663: 𝓟[ty]1779{IO})
{
 const 𝓟1664{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}) = 𝓟1751{sequence}(𝓛8757{Array}(𝓟1657{fa1},𝓟1658{fa2},𝓟1659{fa3},𝓟1660{fa4},𝓟1661{fa5}) as 𝓛[ty]8670{Array});
 function 𝓟1665{$Lambda106} (𝓟1666{lst}): (𝓟1667: [OOV]any)
 {
 return 𝓟1667 = 𝓟1662{f}(𝓟1666{lst}.access(𝓛8745{Number}),𝓟1666{lst}.access(𝓛8745{Number}),𝓟1666{lst}.access(𝓛8745{Number}),𝓟1666{lst}.access(𝓛8745{Number}),𝓟1666{lst}.access(𝓛8745{Number}))
 }
 return 𝓟1663 = 𝓟1664{fl}.map(𝓟1665{$Lambda106})
}
function 𝓟1668{map6} (𝓟1669{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1670{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1671{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1672{fa4}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1673{fa5}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]1779{IO}),𝓟1674{fa6}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]1779{IO}),𝓟1675{f}: 𝓛[ty]8696{Function}): (𝓟1676: (𝓟[ty]2938{AsyncFuture} ≠ 𝓟[ty]1779{IO}))
{
 const 𝓟1677{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}) = 𝓟1751{sequence}(𝓛8757{Array}(𝓟1669{fa1},𝓟1670{fa2},𝓟1671{fa3},𝓟1672{fa4},𝓟1673{fa5},𝓟1674{fa6}) as 𝓛[ty]8670{Array});
 function 𝓟1678{$Lambda107} (𝓟1679{lst}): (𝓟1680: [OOV]any)
 {
 return 𝓟1680 = 𝓟1675{f}(𝓟1679{lst}.access(𝓛8745{Number}),𝓟1679{lst}.access(𝓛8745{Number}),𝓟1679{lst}.access(𝓛8745{Number}),𝓟1679{lst}.access(𝓛8745{Number}),𝓟1679{lst}.access(𝓛8745{Number}),𝓟1679{lst}.access(𝓛8745{Number}))
 }
 return 𝓟1676 = 𝓟1677{fl}.map(𝓟1678{$Lambda107})
}
function 𝓟1681{now} (𝓟1682{value}: [OOV]any): (𝓟1683: (𝓟[ty]2850{PureFuture} ≠ 𝓟[ty]1779{IO}))
{
 return 𝓟1683 = 𝓟1950{CONSTRUCTOR}(𝓟803{Success}(𝓟1682{value}))
}
function 𝓟1684{of} (𝓟1685{thunk}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1686: 𝓟[ty]1779{IO})
{
 return 𝓟1686 = 𝓟1547{always}(𝓟1685{thunk})
}
function 𝓟1687{once} (𝓟1688{thunk}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function})): (𝓟1689: (𝓟[ty]2477{Now} ≠ 𝓟[ty]1779{IO}))
{
 return 𝓟1689 = 𝓟1960{CONSTRUCTOR}(𝓟1688{thunk},𝓛8744{Boolean})
}
function 𝓟1690{parMap2} (𝓟1691{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1692{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1693{f}: 𝓛[ty]8696{Function}): (𝓟1694: 𝓟[ty]1779{IO})
{
 const 𝓟1695{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}) = 𝓟1754{gather}(𝓛8757{Array}(𝓟1691{fa1},𝓟1692{fa2}) as 𝓛[ty]8670{Array});
 function 𝓟1696{$Lambda108} (𝓟1697{lst}): (𝓟1698: [OOV]any)
 {
 return 𝓟1698 = 𝓟1693{f}(𝓟1697{lst}.access(𝓛8745{Number}),𝓟1697{lst}.access(𝓛8745{Number}))
 }
 return 𝓟1694 = 𝓟1695{fl}.map(𝓟1696{$Lambda108})
}
function 𝓟1699{parMap3} (𝓟1700{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1701{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1702{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1703{f}: 𝓛[ty]8696{Function}): (𝓟1704: 𝓟[ty]1779{IO})
{
 const 𝓟1705{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}) = 𝓟1754{gather}(𝓛8757{Array}(𝓟1700{fa1},𝓟1701{fa2},𝓟1702{fa3}) as 𝓛[ty]8670{Array});
 function 𝓟1706{$Lambda109} (𝓟1707{lst}): (𝓟1708: [OOV]any)
 {
 return 𝓟1708 = 𝓟1703{f}(𝓟1707{lst}.access(𝓛8745{Number}),𝓟1707{lst}.access(𝓛8745{Number}),𝓟1707{lst}.access(𝓛8745{Number}))
 }
 return 𝓟1704 = 𝓟1705{fl}.map(𝓟1706{$Lambda109})
}
function 𝓟1709{parMap4} (𝓟1710{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1711{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1712{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1713{fa4}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1714{f}: 𝓛[ty]8696{Function}): (𝓟1715: 𝓟[ty]1779{IO})
{
 const 𝓟1716{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}) = 𝓟1754{gather}(𝓛8757{Array}(𝓟1710{fa1},𝓟1711{fa2},𝓟1712{fa3},𝓟1713{fa4}) as 𝓛[ty]8670{Array});
 function 𝓟1717{$Lambda110} (𝓟1718{lst}): (𝓟1719: [OOV]any)
 {
 return 𝓟1719 = 𝓟1714{f}(𝓟1718{lst}.access(𝓛8745{Number}),𝓟1718{lst}.access(𝓛8745{Number}),𝓟1718{lst}.access(𝓛8745{Number}),𝓟1718{lst}.access(𝓛8745{Number}))
 }
 return 𝓟1715 = 𝓟1716{fl}.map(𝓟1717{$Lambda110})
}
function 𝓟1720{parMap5} (𝓟1721{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1722{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1723{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1724{fa4}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1725{fa5}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]1779{IO}),𝓟1726{f}: 𝓛[ty]8696{Function}): (𝓟1727: 𝓟[ty]1779{IO})
{
 const 𝓟1728{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}) = 𝓟1754{gather}(𝓛8757{Array}(𝓟1721{fa1},𝓟1722{fa2},𝓟1723{fa3},𝓟1724{fa4},𝓟1725{fa5}) as 𝓛[ty]8670{Array});
 function 𝓟1729{$Lambda111} (𝓟1730{lst}): (𝓟1731: [OOV]any)
 {
 return 𝓟1731 = 𝓟1726{f}(𝓟1730{lst}.access(𝓛8745{Number}),𝓟1730{lst}.access(𝓛8745{Number}),𝓟1730{lst}.access(𝓛8745{Number}),𝓟1730{lst}.access(𝓛8745{Number}),𝓟1730{lst}.access(𝓛8745{Number}))
 }
 return 𝓟1727 = 𝓟1728{fl}.map(𝓟1729{$Lambda111})
}
function 𝓟1732{parMap6} (𝓟1733{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1734{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1735{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1736{fa4}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1737{fa5}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]1779{IO}),𝓟1738{fa6}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]1779{IO}),𝓟1739{f}: 𝓛[ty]8696{Function}): (𝓟1740: 𝓟[ty]1779{IO})
{
 const 𝓟1741{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}) = 𝓟1754{gather}(𝓛8757{Array}(𝓟1733{fa1},𝓟1734{fa2},𝓟1735{fa3},𝓟1736{fa4},𝓟1737{fa5},𝓟1738{fa6}) as 𝓛[ty]8670{Array});
 function 𝓟1742{$Lambda112} (𝓟1743{lst}): (𝓟1744: [OOV]any)
 {
 return 𝓟1744 = 𝓟1739{f}(𝓟1743{lst}.access(𝓛8745{Number}),𝓟1743{lst}.access(𝓛8745{Number}),𝓟1743{lst}.access(𝓛8745{Number}),𝓟1743{lst}.access(𝓛8745{Number}),𝓟1743{lst}.access(𝓛8745{Number}),𝓟1743{lst}.access(𝓛8745{Number}))
 }
 return 𝓟1740 = 𝓟1741{fl}.map(𝓟1742{$Lambda112})
}
function 𝓟1745{pure} (𝓟1746{value}: [OOV]any): (𝓟1747: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
{
 return 𝓟1747 = 𝓟1681{now}(𝓟1746{value})
}
function 𝓟1748{raise} (𝓟1749{e}: [OOV]𝓟[ty]3170{Throwable}): (𝓟1750: (𝓟[ty]2850{PureFuture} ≠ 𝓟[ty]1779{IO}))
{
 return 𝓟1750 = 𝓟1950{CONSTRUCTOR}(𝓟814{Failure}(𝓟1749{e}))
}
function 𝓟1751{sequence} (𝓟1752{list}: [OOV]any): (𝓟1753: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}))
{
 return 𝓟1753 = 𝓟2191{ioSequence}(𝓟1752{list})
}
function 𝓟1754{gather} (𝓟1755{list}: [OOV]any): (𝓟1756: 𝓟[ty]1779{IO})
{
 return 𝓟1756 = 𝓟2209{ioListToFutureProcess}(𝓟1755{list},𝓟2665{sequence})
}
function 𝓟1757{shift} (𝓟1758{ec}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1309{Scheduler})): (𝓟1759: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]1779{IO}))
{
 if (𝓛12569{ExclamationToken}(𝓟1758{ec}))
 {
 return 𝓟1759 = 𝓟2067{ioShiftDefaultRef}
 }
 return 𝓟1759 = 𝓟2058{ioShift}(𝓟1758{ec})
}
function 𝓟1760{suspend} (𝓟1761{thunk}: 𝓛[ty]8696{Function}): (𝓟1762: 𝓟[ty]1779{IO})
{
 function 𝓟1763{$Lambda113} (): (𝓟1764: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1764 = 𝓟1761{thunk}()
 }
 return 𝓟1762 = 𝓟1772{unit}().flatMap(𝓟1763{$Lambda113})
}
function 𝓟1765{tailRecM} (𝓟1766{a}: [OOV]any,𝓟1767{f}: 𝓛[ty]8696{Function}): (𝓟1768: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}))
{
 {
 function 𝓟1769{$Lambda114} (𝓟1770{either}): (𝓟1771: [miss]𝓟[ty]1779{IO})
 {
 if (𝓟1770{either}.isRight())
 {
 return 𝓟1771 = 𝓟1681{now}(𝓟1770{either}.get())
 }
 else
 {
 return 𝓟1771 = 𝓟1765{tailRecM}(𝓟1770{either}.swap().get(),𝓟1767{f})
 }
 }
 return 𝓟1768 = 𝓟1767{f}(𝓟1766{a}).flatMap(𝓟1769{$Lambda114})
 }
}
function 𝓟1772{unit} (): (𝓟1773: (𝓟[ty]1982{IOAlways} ≠ 𝓟[ty]1779{IO}))
{
 return 𝓟1773 = 𝓟1959{ioUnitRef}
}
function 𝓟1774{unsafeStart} (𝓟1775{source}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟1776{context}: 𝓟[ty]2029{IOContext},𝓟1777{cb}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1778: [OOV]any)
{
 return 𝓟1778 = 𝓟2117{ioGenericRunLoop}(𝓟1775{source},𝓟1776{context}.scheduler,𝓟1776{context},𝓟1777{cb},𝓛12643{undefined},𝓛12643{undefined},𝓛12643{undefined})
}
class 𝓟[ty]1779{IO} extends 𝓛[ty]2{<UNKNOWN>}{
 𝓟1781{_tag}: [OOV]any;
 𝓟1782{_URI}: 𝓛[ty]10051{String};
 𝓟1783{_A}: [OOV]any;
 function 𝓟1921{recoverWith} (𝓟1922{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1923: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}))
 {
 return 𝓟1923 = 𝓟[ty]1779{IO}.transformWith(𝓟1922{f},𝓟1681{now} as any)
 }
 function 𝓟1886{followedBy} (𝓟1887{fb}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]1779{IO})): (𝓟1888: 𝓟[ty]1779{IO})
 {
 function 𝓟1889{$Lambda83} (): (𝓟1890: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1890 = 𝓟1887{fb}
 }
 return 𝓟1888 = 𝓟[ty]1779{IO}.flatMap(𝓟1889{$Lambda83})
 }
 function 𝓟1797{asyncBoundary} (𝓟1798{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟1799: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}))
 {
 function 𝓟1800{$Lambda64} (𝓟1801{a}): (𝓟1802: [miss]𝓟[ty]1779{IO})
 {
 function 𝓟1803{$Lambda65} (): (𝓟1804: [OOV]any)
 {
 return 𝓟1804 = 𝓟1801{a}
 }
 return 𝓟1802 = 𝓟1757{shift}(𝓟1798{ec}).map(𝓟1803{$Lambda65})
 }
 return 𝓟1799 = 𝓟[ty]1779{IO}.flatMap(𝓟1800{$Lambda64})
 }
 function 𝓟1852{executeForked} (𝓟1853{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟1854: 𝓟[ty]1779{IO})
 {
 return 𝓟1854 = 𝓟1620{fork}(𝓟[ty]1779{IO},𝓟1853{ec})
 }
 function 𝓟1902{map} (𝓟1903{f}: 𝓛[ty]8696{Function}): (𝓟1904: (𝓟[ty]811{TFailure} ≠ 𝓟[ty]1779{IO}))
 {
 function 𝓟1905{$Lambda86} (𝓟1906{a}: [OOV]any): (𝓟1907: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1907 = 𝓟1681{now}(𝓟1903{f}(𝓟1906{a}))
 }
 return 𝓟1904 = 𝓟1986{CONSTRUCTOR}(𝓟[ty]1779{IO},𝓟1905{$Lambda86})
 }
 function 𝓟1839{doOnCancel} (𝓟1840{callback}: (𝓟[ty]2084{RestartCallback} ≠ 𝓟[ty]1779{IO})): (𝓟1841: (𝓛[ty]8654{Promise} ≠ 𝓟[ty]1779{IO}))
 {
 function 𝓟1842{$Lambda75} (𝓟1843{ctx},𝓟1844{cb}): (𝓟1845: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟1846{ec} = 𝓟1843{ctx}.scheduler;
 function 𝓟1847{$Lambda76} (): (𝓟1848: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟1849{conn} = 𝓟1843{ctx}.connection;
 function 𝓟1850{$Lambda77} (): (𝓟1851: [OOV]any)
 {
 return 𝓟1851 = 𝓟1840{callback}.run(𝓟1846{ec})
 }
 𝓟1849{conn}.push(𝓟8{of}(𝓟1850{$Lambda77}))
 𝓟1774{unsafeStart}(𝓟[ty]1779{IO},𝓟1843{ctx},𝓟2165{ioSafeCallback}(𝓟1846{ec},𝓟1849{conn},𝓟1844{cb}))
 }
 𝓟1846{ec}.trampoline(𝓟1847{$Lambda76})
 }
 return 𝓟1841 = 𝓟1563{asyncUnsafe}(𝓟1842{$Lambda75})
 }
 function 𝓟1784{run} (𝓟1785{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟1786: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2729{Future}))
 {
 return 𝓟1786 = 𝓟2151{taskToFutureRunLoop}(𝓟[ty]1779{IO},𝓟1785{ec})
 }
 function 𝓟1813{delayResult} (𝓟1814{delay}: [OOV]any): (𝓟1815: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}))
 {
 function 𝓟1816{$Lambda67} (𝓟1817{err}): (𝓟1818: [miss]𝓟[ty]1779{IO})
 {
 function 𝓟1819{$Lambda68} (): (𝓟1820: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1820 = 𝓟1748{raise}(𝓟1817{err})
 }
 return 𝓟1818 = 𝓟1593{delayedTick}(𝓟1814{delay}).flatMap(𝓟1819{$Lambda68})
 }
 function 𝓟1821{$Lambda69} (𝓟1822{a}): (𝓟1823: [miss]𝓟[ty]1779{IO})
 {
 function 𝓟1824{$Lambda70} (): (𝓟1825: [OOV]any)
 {
 return 𝓟1825 = 𝓟1822{a}
 }
 return 𝓟1823 = 𝓟1593{delayedTick}(𝓟1814{delay}).map(𝓟1824{$Lambda70})
 }
 return 𝓟1815 = 𝓟[ty]1779{IO}.transformWith(𝓟1816{$Lambda67},𝓟1821{$Lambda69})
 }
 function 𝓟1866{executeWithOptions} (𝓟1867{set}: [OOV]𝓟[ty]1541{IOOptions}): (𝓟1868: 𝓟[ty]1779{IO})
 {
 function 𝓟1869{$Lambda80} (𝓟1870{ctx},𝓟1871{cb}): (𝓟1872: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟1873{ec} = 𝓟1870{ctx}.scheduler;
 const 𝓟1874{ctx2}: [miss]𝓟[ty]2029{IOContext} = 𝓟2020{CONSTRUCTOR}(𝓟1873{ec},𝓟1870{ctx}.connection,𝓟1867{set});
 function 𝓟1875{$Lambda81} (): (𝓟1876: [OOV]any)
 {
 return 𝓟1876 = 𝓟1774{unsafeStart}(𝓟[ty]1779{IO},𝓟1874{ctx2},𝓟1871{cb})
 }
 𝓟1873{ec}.trampoline(𝓟1875{$Lambda81})
 }
 return 𝓟1868 = 𝓟1563{asyncUnsafe}(𝓟1869{$Lambda80})
 }
 function 𝓟1880{ap} (𝓟1881{ff}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO})): (𝓟1882: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
 {
 function 𝓟1883{$Lambda82} (𝓟1884{f}): (𝓟1885: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1885 = 𝓟[ty]1779{IO}.map(𝓟1884{f})
 }
 return 𝓟1882 = 𝓟1881{ff}.flatMap(𝓟1883{$Lambda82})
 }
 function 𝓟1891{forEach} (𝓟1892{cb}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1893: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
 {
 return 𝓟1893 = 𝓟[ty]1779{IO}.map(𝓟1892{cb})
 }
 function 𝓟1912{memoizeOnSuccess} (): (𝓟1913: (𝓟[ty]1309{Scheduler} ≠ 𝓟[ty]1779{IO}))
 {
 𝓛12577{$Switch}(𝓟[ty]1779{IO}._tag)
 𝓛12634{$Case}(𝓛8743{String})
 𝓛12634{$Case}(𝓛8743{String})
 𝓛12634{$Case}(𝓛8743{String})
 return 𝓟1913 = 𝓟[ty]1779{IO}
 𝓛12634{$Case}(𝓛8743{String})
 const 𝓟1914{always}: [miss]𝓟[ty]1982{IOAlways} = 𝓟[ty]1779{IO} as any as 𝓟[ty]1982{IOAlways};
 return 𝓟1913 = 𝓟1960{CONSTRUCTOR}(𝓟1914{always}.thunk,𝓛8744{Boolean})
 return 𝓟1913 = 𝓟2008{CONSTRUCTOR}(𝓟[ty]1779{IO},𝓛8744{Boolean})
 }
 function 𝓟1826{doOnFinish} (𝓟1827{f}: 𝓛[ty]8696{Function}): (𝓟1828: (𝓛[ty]8654{Promise} ≠ 𝓟[ty]1779{IO}))
 {
 function 𝓟1829{$Lambda71} (𝓟1830{e}): (𝓟1831: [miss]𝓟[ty]1779{IO})
 {
 function 𝓟1832{$Lambda72} (): (𝓟1833: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1833 = 𝓟1748{raise}(𝓟1830{e})
 }
 return 𝓟1831 = 𝓟1827{f}(𝓟614{Some}(𝓟1830{e})).flatMap(𝓟1832{$Lambda72})
 }
 function 𝓟1834{$Lambda73} (𝓟1835{a}): (𝓟1836: [miss]𝓟[ty]1779{IO})
 {
 function 𝓟1837{$Lambda74} (): (𝓟1838: [OOV]any)
 {
 return 𝓟1838 = 𝓟1835{a}
 }
 return 𝓟1836 = 𝓟1827{f}(𝓟624{None}).map(𝓟1837{$Lambda74})
 }
 return 𝓟1828 = 𝓟[ty]1779{IO}.transformWith(𝓟1829{$Lambda71},𝓟1834{$Lambda73})
 }
 function 𝓟1915{recover} (𝓟1916{f}: 𝓛[ty]8696{Function}): (𝓟1917: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}))
 {
 function 𝓟1918{$Lambda87} (𝓟1919{a}): (𝓟1920: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1920 = 𝓟1681{now}(𝓟1916{f}(𝓟1919{a}))
 }
 return 𝓟1917 = 𝓟[ty]1779{IO}.recoverWith(𝓟1918{$Lambda87})
 }
 function 𝓟1894{forEffect} (𝓟1895{fb}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO})): (𝓟1896: 𝓟[ty]1779{IO})
 {
 function 𝓟1897{$Lambda84} (𝓟1898{a}): (𝓟1899: [miss]𝓟[ty]1779{IO})
 {
 function 𝓟1900{$Lambda85} (): (𝓟1901: [OOV]any)
 {
 return 𝓟1901 = 𝓟1898{a}
 }
 return 𝓟1899 = 𝓟1895{fb}.map(𝓟1900{$Lambda85})
 }
 return 𝓟1896 = 𝓟[ty]1779{IO}.flatMap(𝓟1897{$Lambda84})
 }
 function 𝓟1928{timeoutTo} (𝓟1929{after}: [OOV]any,𝓟1930{fallback}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1779{IO})): (𝓟1931: 𝓟[ty]1779{IO})
 {
 function 𝓟1932{$Lambda88} (): (𝓟1933: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1933 = 𝓟1930{fallback}
 }
 const 𝓟1934{other}: [miss]𝓟[ty]1779{IO} = 𝓟1593{delayedTick}(𝓟1929{after}).flatMap(𝓟1932{$Lambda88});
 const 𝓟1935{lst}: 𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓟[ty]1779{IO},𝓟1934{other});
 return 𝓟1931 = 𝓟1604{firstCompletedOf}(𝓟1935{lst})
 }
 function 𝓟1877{flatMap} (𝓟1878{f}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function})): (𝓟1879: (𝓟[ty]811{TFailure} ≠ 𝓟[ty]1779{IO}))
 {
 return 𝓟1879 = 𝓟1986{CONSTRUCTOR}(𝓟[ty]1779{IO},𝓟1878{f})
 }
 function 𝓟1808{delayExecution} (𝓟1809{delay}: [OOV]any): (𝓟1810: 𝓟[ty]1779{IO})
 {
 function 𝓟1811{$Lambda66} (): (𝓟1812: [OOV]any)
 {
 return 𝓟1812 = 𝓟[ty]1779{IO}
 }
 return 𝓟1810 = 𝓟1593{delayedTick}(𝓟1809{delay}).flatMap(𝓟1811{$Lambda66})
 }
 function 𝓟1787{runOnComplete} (𝓟1788{cb}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟1789{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟1790: [OOV]𝓟[ty]1{ICancelable})
 {
 const 𝓟1791{ref} = 𝓟2117{ioGenericRunLoop}(𝓟[ty]1779{IO},𝓟1789{ec},𝓛12643{undefined},𝓟1788{cb},𝓛12643{undefined},𝓛12643{undefined},𝓛12643{undefined});
 return 𝓟1790 = 𝓛12546{BarBarToken}(𝓟1791{ref},𝓟11{empty}())
 }
 function 𝓟1792{attempt} (): (𝓟1793: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
 {
 function 𝓟1794{$Lambda63} (𝓟1795{_}): (𝓟1796: [OOV]any)
 {
 return 𝓟1796 = 𝓟314{left}(𝓟1795{_})
 }
 return 𝓟1793 = 𝓟[ty]1779{IO}.transform(𝓟1794{$Lambda63},𝓟317{right})
 }
 function 𝓟1946{transformWith} (𝓟1947{failure}: (𝓟[ty]811{TFailure} ≠ 𝓛[ty]8696{Function}),𝓟1948{success}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8696{Function})): (𝓟1949: (𝓟[ty]811{TFailure} ≠ 𝓟[ty]1779{IO}))
 {
 return 𝓟1949 = 𝓟1986{CONSTRUCTOR}(𝓟[ty]1779{IO},𝓟1948{success},𝓟1947{failure})
 }
 function 𝓟1924{timeout} (𝓟1925{after}: [OOV]any): (𝓟1926: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
 {
 const 𝓟1927{fb}: [miss]𝓟[ty]1779{IO} = 𝓟1748{raise}(𝓟3233{CONSTRUCTOR}(𝓟1221{of}(𝓟1925{after}).toString()));
 return 𝓟1926 = 𝓟[ty]1779{IO}.timeoutTo(𝓟1925{after},𝓟1927{fb})
 }
 function 𝓟1805{chain} (𝓟1806{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟1807: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}))
 {
 return 𝓟1807 = 𝓟[ty]1779{IO}.flatMap(𝓟1806{f})
 }
 function 𝓟1936{transform} (𝓟1937{failure}: 𝓛[ty]8696{Function},𝓟1938{success}: 𝓛[ty]8696{Function}): (𝓟1939: (𝓟[ty]533{Option} ≠ 𝓟[ty]1779{IO}))
 {
 function 𝓟1940{$Lambda89} (𝓟1941{e}): (𝓟1942: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1942 = 𝓟1681{now}(𝓟1937{failure}(𝓟1941{e}))
 }
 function 𝓟1943{$Lambda90} (𝓟1944{a}): (𝓟1945: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟1945 = 𝓟1681{now}(𝓟1938{success}(𝓟1944{a}))
 }
 return 𝓟1939 = 𝓟[ty]1779{IO}.transformWith(𝓟1940{$Lambda89},𝓟1943{$Lambda90})
 }
 function 𝓟1855{executeWithModel} (𝓟1856{em}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1380{ExecutionModel})): (𝓟1857: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
 {
 function 𝓟1858{$Lambda78} (𝓟1859{ctx},𝓟1860{cb}): (𝓟1861: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟1862{ec} = 𝓟1859{ctx}.scheduler.withExecutionModel(𝓟1856{em});
 const 𝓟1863{ctx2}: [miss]𝓟[ty]2029{IOContext} = 𝓟2020{CONSTRUCTOR}(𝓟1862{ec},𝓟1859{ctx}.connection,𝓟1859{ctx}.options);
 function 𝓟1864{$Lambda79} (): (𝓟1865: [OOV]any)
 {
 return 𝓟1865 = 𝓟1774{unsafeStart}(𝓟[ty]1779{IO},𝓟1863{ctx2},𝓟1860{cb})
 }
 𝓟1862{ec}.trampoline(𝓟1864{$Lambda79})
 }
 return 𝓟1857 = 𝓟1563{asyncUnsafe}(𝓟1858{$Lambda78})
 }
 function 𝓟1908{memoize} (): (𝓟1909: (𝓟[ty]2014{IOMemoize} ≠ 𝓟[ty]1779{IO}))
 {
 𝓛12577{$Switch}(𝓟[ty]1779{IO}._tag)
 𝓛12634{$Case}(𝓛8743{String})
 return 𝓟1909 = 𝓟[ty]1779{IO}
 𝓛12634{$Case}(𝓛8743{String})
 const 𝓟1910{always}: [miss]𝓟[ty]1982{IOAlways} = 𝓟[ty]1779{IO} as any as 𝓟[ty]1982{IOAlways};
 return 𝓟1909 = 𝓟1960{CONSTRUCTOR}(𝓟1910{always}.thunk,𝓛8744{Boolean})
 𝓛12634{$Case}(𝓛8743{String})
 const 𝓟1911{mem}: [miss]𝓟[ty]2014{IOMemoize} = 𝓟[ty]1779{IO} as any as 𝓟[ty]2014{IOMemoize};
 if (𝓛12569{ExclamationToken}(𝓟1911{mem}.onlySuccess))
 {
 return 𝓟1909 = 𝓟1911{mem}
 }
 return 𝓟1909 = 𝓟2008{CONSTRUCTOR}(𝓟[ty]1779{IO},𝓛8744{Boolean})
 return 𝓟1909 = 𝓟2008{CONSTRUCTOR}(𝓟[ty]1779{IO},𝓛8744{Boolean})
 }
}
function 𝓟1950{CONSTRUCTOR} (𝓟1951{value}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]715{Try})): (𝓟[ty]1955{IOPure})
{
 const 𝓟[ty]1955{IOPure};
 const 𝓟[ty]1955{IOPure};
 𝓟[ty]1955{IOPure}._tag ⟵ 𝓛8743{String};
 𝓟[ty]1955{IOPure}.value ⟵ 𝓟1951{value};
 𝓟[ty]1955{IOPure}()
}
class 𝓟[ty]1955{IOPure} extends 𝓟[ty]1779{IO}{
 𝓟1957{_tag}: 𝓛[ty]10051{String};
 𝓟1958{value}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]715{Try});
}
const 𝓟1959{ioUnitRef}: 𝓟[ty]1955{IOPure} = 𝓟1950{CONSTRUCTOR}(𝓟662{unit}());
function 𝓟1960{CONSTRUCTOR} (𝓟1961{thunk}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8696{Function}),𝓟1962{onlyOnSuccess}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8666{Boolean})): (𝓟[ty]1966{IOOnce})
{
 const 𝓟[ty]1966{IOOnce};
 const 𝓟[ty]1966{IOOnce};
 𝓟[ty]1966{IOOnce}._tag ⟵ 𝓛8743{String};
 𝓟[ty]1966{IOOnce}()
 𝓟[ty]1966{IOOnce}._thunk ⟵ 𝓟1961{thunk};
 𝓟[ty]1966{IOOnce}.onlyOnSuccess ⟵ 𝓟1962{onlyOnSuccess};
}
class 𝓟[ty]1966{IOOnce} extends 𝓟[ty]1779{IO}{
 𝓟1968{_tag}: 𝓛[ty]10051{String};
 𝓟1969{_thunk}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function});
 𝓟1970{cache}: (𝓟[ty]1779{IO} ≠ 𝓟[ty]715{Try});
 𝓟1971{onlyOnSuccess}: 𝓛[ty]8666{Boolean};
 function 𝓟1972{memoize} (): (𝓟1973: (𝓟[ty]2850{PureFuture} ≠ 𝓟[ty]1779{IO}))
 {
 if (𝓛12592{AmpersandAmpersandToken}(𝓟[ty]1966{IOOnce}.onlyOnSuccess,𝓟[ty]1966{IOOnce}._thunk))
 {
 return 𝓟1973 = 𝓟1960{CONSTRUCTOR}(𝓟[ty]1966{IOOnce}._thunk,𝓛8744{Boolean})
 }
 else
 {
 return 𝓟1973 = 𝓟[ty]1966{IOOnce}
 }
 }
 function 𝓟1974{runTry} (): (𝓟1975: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]715{Try}))
 {
 if (𝓟[ty]1966{IOOnce}._thunk)
 {
 const 𝓟1976{result} = 𝓟656{of}(𝓟[ty]1966{IOOnce}._thunk);
 if (𝓛12546{BarBarToken}(𝓟1976{result}.isSuccess(),𝓛12569{ExclamationToken}(𝓟[ty]1966{IOOnce}.onlyOnSuccess)))
 {
 𝓛12622{$Delete}(𝓟[ty]1966{IOOnce}._thunk)
 𝓛12622{$Delete}(𝓟[ty]1966{IOOnce}.onlyOnSuccess)
 𝓟[ty]1966{IOOnce}.cache ⟵ 𝓟1976{result};
 }
 return 𝓟1975 = 𝓟1976{result}
 }
 return 𝓟1975 = 𝓟[ty]1966{IOOnce}.cache
 }
}
function 𝓟1977{CONSTRUCTOR} (𝓟1978{thunk}: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]1982{IOAlways})
{
 const 𝓟[ty]1982{IOAlways};
 const 𝓟[ty]1982{IOAlways};
 𝓟[ty]1982{IOAlways}.thunk ⟵ 𝓟1978{thunk};
 𝓟[ty]1982{IOAlways}._tag ⟵ 𝓛8743{String};
 𝓟[ty]1982{IOAlways}()
}
class 𝓟[ty]1982{IOAlways} extends 𝓟[ty]1779{IO}{
 𝓟1984{_tag}: 𝓛[ty]10051{String};
 𝓟1985{thunk}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8696{Function});
}
function 𝓟1986{CONSTRUCTOR} (𝓟1987{source}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]1779{IO}),𝓟1988{f}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8696{Function}),𝓟1989{g}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]1993{IOFlatMap})
{
 const 𝓟[ty]1993{IOFlatMap};
 const 𝓟[ty]1993{IOFlatMap};
 𝓟[ty]1993{IOFlatMap}.source ⟵ 𝓟1987{source};
 𝓟[ty]1993{IOFlatMap}.g ⟵ 𝓟1989{g};
 𝓟[ty]1993{IOFlatMap}._tag ⟵ 𝓛8743{String};
 𝓟[ty]1993{IOFlatMap}.f ⟵ 𝓟1988{f};
 𝓟[ty]1993{IOFlatMap}()
}
class 𝓟[ty]1993{IOFlatMap} extends 𝓟[ty]1779{IO}{
 𝓟1995{_tag}: 𝓛[ty]10051{String};
 𝓟1996{source}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]1779{IO});
 𝓟1997{f}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8696{Function});
 𝓟1998{g}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8696{Function});
}
function 𝓟1999{CONSTRUCTOR} (𝓟2000{register}: [OOV]𝓟[ty]1539{IORegister}): (𝓟[ty]2004{IOAsync})
{
 const 𝓟[ty]2004{IOAsync};
 const 𝓟[ty]2004{IOAsync};
 𝓟[ty]2004{IOAsync}._tag ⟵ 𝓛8743{String};
 𝓟[ty]2004{IOAsync}.register ⟵ 𝓟2000{register};
 𝓟[ty]2004{IOAsync}()
}
class 𝓟[ty]2004{IOAsync} extends 𝓟[ty]1779{IO}{
 𝓟2006{_tag}: 𝓛[ty]10051{String};
 𝓟2007{register}: [OOV]𝓟[ty]1539{IORegister};
}
function 𝓟2008{CONSTRUCTOR} (𝓟2009{source}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]1779{IO}),𝓟2010{onlySuccess}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8666{Boolean})): (𝓟[ty]2014{IOMemoize})
{
 const 𝓟[ty]2014{IOMemoize};
 const 𝓟[ty]2014{IOMemoize};
 𝓟[ty]2014{IOMemoize}._tag ⟵ 𝓛8743{String};
 𝓟[ty]2014{IOMemoize}()
 𝓟[ty]2014{IOMemoize}.source ⟵ 𝓟2009{source};
 𝓟[ty]2014{IOMemoize}.result ⟵ 𝓛12643{undefined};
 𝓟[ty]2014{IOMemoize}.onlySuccess ⟵ 𝓟2010{onlySuccess};
}
class 𝓟[ty]2014{IOMemoize} extends 𝓟[ty]1779{IO}{
 𝓟2016{_tag}: 𝓛[ty]10051{String};
 𝓟2017{result}: [OOV]any;
 𝓟2018{source}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]1779{IO});
 𝓟2019{onlySuccess}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8666{Boolean});
}
function 𝓟2020{CONSTRUCTOR} (𝓟2021{scheduler}: 𝓟[ty]1309{Scheduler},𝓟2022{connection}: (𝓟[ty]2729{Future} ≠ 𝓟[ty]219{StackedCancelable}),𝓟2023{options}: [OOV]𝓟[ty]1541{IOOptions}): (𝓟[ty]2029{IOContext})
{
 const 𝓟[ty]2029{IOContext};
 const 𝓟[ty]2029{IOContext};
 𝓟[ty]2029{IOContext}.scheduler ⟵ 𝓟2021{scheduler};
 𝓟[ty]2029{IOContext}.options ⟵ 𝓟2023{options};
 𝓟[ty]2029{IOContext}.connection ⟵ 𝓟2022{connection};
 if (𝓟2023{options}.autoCancelableRunLoops)
 {
 function 𝓟2027{$Lambda115} (): (𝓟2028: [OOV]any)
 {
 return 𝓟2028 = 𝓟2022{connection}.isCanceled()
 }
 𝓟[ty]2029{IOContext}.shouldCancel ⟵ 𝓟2027{$Lambda115};
 }
}
class 𝓟[ty]2029{IOContext}{
 𝓟2031{scheduler}: 𝓟[ty]1309{Scheduler};
 𝓟2032{connection}: (𝓟[ty]1309{Scheduler} ≠ 𝓟[ty]219{StackedCancelable});
 𝓟2033{options}: [OOV]𝓟[ty]1541{IOOptions};
 function 𝓟2034{markAsyncBoundary} (): (𝓟2035: 𝓛[ty]10033{Void})
 {
 𝓟[ty]2029{IOContext}.scheduler.batchIndex ⟵ 𝓛8745{Number};
 }
 function 𝓟2036{shouldCancel} (): (𝓟2037: 𝓛[ty]8666{Boolean})
 {
 return 𝓟2037 = 𝓛8744{Boolean}
 }
}
function 𝓟2038{$Lambda116} (𝓟2039{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟2040{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO})): (𝓟2041: [miss]𝓟[ty]1779{IO})
{
 return 𝓟2041 = 𝓟2040{fa}.map(𝓟2039{f})
}
function 𝓟2042{$Lambda117} (𝓟2043{ff}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]1779{IO}),𝓟2044{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO})): (𝓟2045: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
{
 return 𝓟2045 = 𝓟2044{fa}.ap(𝓟2043{ff})
}
function 𝓟2046{$Lambda118} (𝓟2047{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟2048{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO})): (𝓟2049: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
{
 return 𝓟2049 = 𝓟2048{fa}.flatMap(𝓟2047{f})
}
function 𝓟2050{$Lambda119} (𝓟2051{f}: 𝓛[ty]8696{Function},𝓟2052{a}: [OOV]any): (𝓟2053: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
{
 function 𝓟2054{$Lambda120} (𝓟2055{a}): (𝓟2056: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟2056 = 𝓟2051{f}(𝓟314{left} as any,𝓟317{right} as any,𝓟2055{a})
 }
 return 𝓟2053 = 𝓟1765{tailRecM}(𝓟2052{a},𝓟2054{$Lambda120})
}
const 𝓟2057{IOModule}: [OOV]𝓛[ty]2{<UNKNOWN>} = {map: 𝓟2038{$Lambda116},ap: 𝓟2042{$Lambda117},chainRec: 𝓟2050{$Lambda119},chain: 𝓟2046{$Lambda118},of: 𝓟1745{pure}};
𝓟282{fantasyLandRegister}(𝓛12643{undefined},𝓟2057{IOModule})
function 𝓟2058{ioShift} (𝓟2059{ec}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2060: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
{
 function 𝓟2061{$Lambda121} (𝓟2062{ctx},𝓟2063{cb}): (𝓟2064: [miss]𝓛[ty]10033{Void})
 {
 function 𝓟2065{$Lambda122} (): (𝓟2066: [miss]𝓛[ty]10033{Void})
 {
 return 𝓟2066 = 𝓟2063{cb}(𝓟662{unit}())
 }
 𝓛12546{BarBarToken}(𝓟2059{ec},𝓟2062{ctx}.scheduler).executeAsync(𝓟2065{$Lambda122})
 }
 return 𝓟2060 = 𝓟1563{asyncUnsafe}(𝓟2061{$Lambda121})
}
const 𝓟2067{ioShiftDefaultRef}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}) = 𝓟2058{ioShift}();
function 𝓟2068{_ioPopNextBind} (𝓟2069{bFirst}: [OOV]any,𝓟2070{bRest}: [OOV]any): (𝓟2071: [OOV]any)
{
 let 𝓟2072{f}: [OOV]any = 𝓛12643{undefined};
 if (𝓟2069{bFirst})
 {
 𝓟2072{f} ⟵ 𝓟2069{bFirst};
 }
 else
 {
 if (𝓛12592{AmpersandAmpersandToken}(𝓟2070{bRest},𝓛12595{GreaterThanToken}(𝓟2070{bRest}.length,𝓛8745{Number})))
 {
 𝓟2072{f} ⟵ 𝓟2070{bRest}.pop();
 }
 }
 if (𝓟2072{f})
 {
 return 𝓟2071 = (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟2072{f}),𝓛8743{String}) ? 𝓟2072{f} : 𝓟2072{f}.access(𝓛8745{Number})
 }
 return 𝓟2071 = 𝓛12643{undefined}
}
function 𝓟2073{_ioFindErrorHandler} (𝓟2074{bFirst}: [OOV]any,𝓟2075{bRest}: [OOV]any): (𝓟2076: [OOV]any)
{
 let 𝓟2077{cursor}: [OOV]any = 𝓟2074{bFirst};
 while (𝓟2077{cursor})
 {
 if (𝓛12592{AmpersandAmpersandToken}(𝓟2077{cursor},𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟2077{cursor}),𝓛8743{String})))
 {
 return 𝓟2076 = 𝓟2077{cursor}.access(𝓛8745{Number})
 }
 𝓟2077{cursor} ⟵ (𝓟2075{bRest} ? 𝓟2075{bRest}.pop() : 𝓛12643{undefined};
 }
 return 𝓟2076 = 𝓛12643{undefined}
}
function 𝓟2078{CONSTRUCTOR} (𝓟2079{context}: 𝓟[ty]2029{IOContext},𝓟2080{callback}: (𝓟[ty]2084{RestartCallback} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]2084{RestartCallback})
{
 const 𝓟[ty]2084{RestartCallback};
 const 𝓟[ty]2084{RestartCallback};
 𝓟[ty]2084{RestartCallback}.bRest ⟵ 𝓛12643{undefined};
 𝓟[ty]2084{RestartCallback}.bFirst ⟵ 𝓛12643{undefined};
 𝓟[ty]2084{RestartCallback}.canCall ⟵ 𝓛8744{Boolean};
 𝓟[ty]2084{RestartCallback}.asFunction ⟵ 𝓟[ty]2084{RestartCallback}.signal.bind(𝓟[ty]2084{RestartCallback});
}
class 𝓟[ty]2084{RestartCallback}{
 𝓟2086{canCall}: [miss]𝓛[ty]8666{Boolean};
 𝓟2087{bFirst}: [OOV]any;
 𝓟2088{bRest}: [OOV]any;
 𝓟2089{asFunction}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8696{Function});
 function 𝓟2090{prepare} (𝓟2091{bFirst}: [OOV]any,𝓟2092{bRest}: [OOV]any): (𝓟2093: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]2084{RestartCallback}.bFirst ⟵ 𝓟2091{bFirst};
 𝓟[ty]2084{RestartCallback}.bRest ⟵ 𝓟2092{bRest};
 𝓟[ty]2084{RestartCallback}.canCall ⟵ 𝓛8744{Boolean};
 }
 function 𝓟2094{signal} (𝓟2095{result}: 𝓟[ty]715{Try}): (𝓟2096: (𝓟[ty]533{Option} ≠ 𝓛[ty]10033{Void}))
 {
 if (𝓟[ty]2084{RestartCallback}.canCall)
 {
 𝓟[ty]2084{RestartCallback}.canCall ⟵ 𝓛8744{Boolean};
 𝓟2117{ioGenericRunLoop}(𝓟1950{CONSTRUCTOR}(𝓟2095{result}),𝓟[ty]2084{RestartCallback}.context.scheduler,𝓟[ty]2084{RestartCallback}.context,𝓟[ty]2084{RestartCallback}.callback,𝓟[ty]2084{RestartCallback},𝓟[ty]2084{RestartCallback}.bFirst,𝓟[ty]2084{RestartCallback}.bRest)
 }
 else
 {
 if (𝓟2095{result}.isFailure())
 {
 𝓟[ty]2084{RestartCallback}.context.scheduler.reportFailure(𝓟2095{result}.failed().get())
 }
 }
 }
}
function 𝓟2097{ioExecuteAsync} (𝓟2098{register}: [OOV]𝓟[ty]1539{IORegister},𝓟2099{context}: 𝓟[ty]2029{IOContext},𝓟2100{cb}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function}),𝓟2101{rcb}: [OOV]any,𝓟2102{bFirst}: [OOV]any,𝓟2103{bRest}: [OOV]any,𝓟2104{frameIndex}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8655{Number})): (𝓟2105: [miss]𝓛[ty]10033{Void})
{
 if (𝓛12569{ExclamationToken}(𝓟2099{context}.shouldCancel()))
 {
 𝓟2099{context}.scheduler.batchIndex ⟵ 𝓟2104{frameIndex};
 const 𝓟2106{restart}: [miss]𝓟[ty]2084{RestartCallback} = 𝓛12546{BarBarToken}(𝓟2101{rcb},𝓟2078{CONSTRUCTOR}(𝓟2099{context},𝓟2100{cb}));
 𝓟2106{restart}.prepare(𝓟2102{bFirst},𝓟2103{bRest})
 𝓟2098{register}(𝓟2099{context},𝓟2106{restart}.asFunction)
 }
}
function 𝓟2107{ioRestartAsync} (𝓟2108{start}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1779{IO}),𝓟2109{context}: 𝓟[ty]2029{IOContext},𝓟2110{cb}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function}),𝓟2111{rcb}: [OOV]any,𝓟2112{bFirstInit}: [OOV]any,𝓟2113{bRestInit}: [OOV]any): (𝓟2114: 𝓛[ty]10033{Void})
{
 if (𝓛12569{ExclamationToken}(𝓟2109{context}.shouldCancel()))
 {
 function 𝓟2115{$Lambda123} (): (𝓟2116: [miss]𝓛[ty]10033{Void})
 {
 𝓟2117{ioGenericRunLoop}(𝓟2108{start},𝓟2109{context}.scheduler,𝓟2109{context},𝓟2110{cb},𝓟2111{rcb},𝓟2112{bFirstInit},𝓟2113{bRestInit})
 }
 𝓟2109{context}.scheduler.executeAsync(𝓟2115{$Lambda123})
 }
}
function 𝓟2117{ioGenericRunLoop} (𝓟2118{start}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟2119{scheduler}: (𝓟[ty]2729{Future} ≠ 𝓟[ty]1309{Scheduler}),𝓟2120{context}: [OOV]any,𝓟2121{cb}: 𝓛[ty]8696{Function},𝓟2122{rcb}: [OOV]any,𝓟2123{bFirstInit}: [OOV]any,𝓟2124{bRestInit}: [OOV]any): (𝓟2125: [OOV]any)
{
 let 𝓟2126{current}: [OOV]any = 𝓟2118{start};
 let 𝓟2127{bFirst}: [OOV]any = 𝓟2123{bFirstInit};
 let 𝓟2128{bRest}: [OOV]any = 𝓟2124{bRestInit};
 const 𝓟2129{modulus}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓟2119{scheduler}.executionModel.recommendedBatchSize,𝓛8745{Number});
 let 𝓟2130{frameIndex} = 𝓟2119{scheduler}.batchIndex;
 while (𝓛8744{Boolean})
 {
 if (𝓛1{<UNKNOWN>}(𝓟2126{current},𝓛12643{undefined}))
 {
 if (𝓟2126{current}.isSuccess())
 {
 const 𝓟2131{bind}: [miss]𝓛[ty]8696{Function} = 𝓟2068{_ioPopNextBind}(𝓟2127{bFirst},𝓟2128{bRest});
 if (𝓛12569{ExclamationToken}(𝓟2131{bind}))
 {
 𝓟2119{scheduler}.batchIndex ⟵ 𝓟2130{frameIndex};
 return 𝓟2125 = 𝓟2121{cb}(𝓟2126{current})
 }
 {
 𝓟2126{current} ⟵ 𝓟2131{bind}(𝓟2126{current}.get());
 }
 }
 else
 {
 const 𝓟2132{bind}: [miss]𝓛[ty]8696{Function} = 𝓟2073{_ioFindErrorHandler}(𝓟2127{bFirst},𝓟2128{bRest});
 if (𝓛12569{ExclamationToken}(𝓟2132{bind}))
 {
 𝓟2119{scheduler}.batchIndex ⟵ 𝓟2130{frameIndex};
 return 𝓟2125 = 𝓟2121{cb}(𝓟2126{current})
 }
 {
 𝓟2126{current} ⟵ 𝓟2132{bind}(𝓟2126{current} as 𝓟[ty]715{Try}.failed().get());
 }
 }
 𝓟2127{bFirst} ⟵ 𝓛12643{undefined};
 const 𝓟2133{nextIndex}: [miss]𝓛[ty]8655{Number} = 𝓛12608{AmpersandToken}(𝓛12641{PlusToken}(𝓟2130{frameIndex},𝓛8745{Number}),𝓟2129{modulus});
 if (𝓟2133{nextIndex})
 {
 𝓟2130{frameIndex} ⟵ 𝓟2133{nextIndex};
 }
 else
 {
 const 𝓟2134{ctx}: [miss]𝓟[ty]2029{IOContext} = 𝓛12546{BarBarToken}(𝓟2120{context},𝓟2020{CONSTRUCTOR}(𝓟2119{scheduler}));
 const 𝓟2135{boxed} = (𝓛1{<UNKNOWN>}(𝓟2126{current},𝓛12643{undefined}) ? 𝓟1950{CONSTRUCTOR}(𝓟2126{current}) : 𝓟2126{current};
 𝓟2107{ioRestartAsync}(𝓟2135{boxed},𝓟2134{ctx},𝓟2121{cb},𝓟2122{rcb},𝓟2127{bFirst},𝓟2128{bRest})
 return 𝓟2125 = 𝓟2134{ctx}.connection
 }
 }
 else
 {
 𝓛12577{$Switch}(𝓟2126{current}._tag)
 𝓛12634{$Case}(𝓛8743{String})
 𝓟2126{current} ⟵ 𝓟2126{current} as 𝓟[ty]1955{IOPure}.value;
 𝓛12634{$Case}(𝓛8743{String})
 𝓟2126{current} ⟵ 𝓟656{of}(𝓟2126{current} as 𝓟[ty]1982{IOAlways}.thunk);
 𝓛12634{$Case}(𝓛8743{String})
 𝓟2126{current} ⟵ 𝓟2126{current} as 𝓟[ty]1966{IOOnce}.runTry();
 𝓛12634{$Case}(𝓛8743{String})
 const 𝓟2136{flatM}: (𝓟[ty]2528{FlatMap} ≠ 𝓟[ty]1993{IOFlatMap}) = 𝓟2126{current} as any;
 if (𝓟2127{bFirst})
 {
 if (𝓛12569{ExclamationToken}(𝓟2128{bRest}))
 {
 𝓟2128{bRest} ⟵ 𝓛8757{Array}();
 }
 𝓟2128{bRest}.push(𝓟2127{bFirst})
 }
 𝓟2127{bFirst} ⟵ (𝓛12569{ExclamationToken}(𝓟2136{flatM}.g) ? 𝓟2136{flatM}.f : 𝓛8757{Array}(𝓟2136{flatM}.f,𝓟2136{flatM}.g);
 𝓟2126{current} ⟵ 𝓟2136{flatM}.source;
 𝓛12634{$Case}(𝓛8743{String})
 const 𝓟2137{async}: (𝓟[ty]2938{AsyncFuture} ≠ 𝓟[ty]2004{IOAsync}) = 𝓟2126{current} as any;
 const 𝓟2138{ctx}: [miss]𝓟[ty]2029{IOContext} = 𝓛12546{BarBarToken}(𝓟2120{context},𝓟2020{CONSTRUCTOR}(𝓟2119{scheduler}));
 𝓟2097{ioExecuteAsync}(𝓟2137{async}.register,𝓟2138{ctx},𝓟2121{cb},𝓟2122{rcb},𝓟2127{bFirst},𝓟2128{bRest},𝓟2130{frameIndex})
 return 𝓟2125 = 𝓟2138{ctx}.connection
 𝓛12634{$Case}(𝓛8743{String})
 const 𝓟2139{mem}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2014{IOMemoize}) = 𝓟2126{current} as any;
 return 𝓟2125 = 𝓟2176{ioStartMemoize}(𝓟2139{mem},𝓟2119{scheduler},𝓟2120{context},𝓟2121{cb},𝓟2127{bFirst},𝓟2128{bRest},𝓟2130{frameIndex})
 }
 }
}
function 𝓟2140{ioToFutureGoAsync} (𝓟2141{start}: (𝓛[ty]8642{Object} ≠ 𝓟[ty]1779{IO}),𝓟2142{scheduler}: (𝓟[ty]2014{IOMemoize} ≠ 𝓟[ty]1309{Scheduler}),𝓟2143{bFirst}: [OOV]any,𝓟2144{bRest}: [OOV]any,𝓟2145{forcedAsync}: (𝓟[ty]1982{IOAlways} ≠ 𝓛[ty]8666{Boolean})): (𝓟2146: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}))
{
 function 𝓟2147{$Lambda124} (𝓟2148{cb}): (𝓟2149: [OOV]any)
 {
 const 𝓟2150{ctx}: [miss]𝓟[ty]2029{IOContext} = 𝓟2020{CONSTRUCTOR}(𝓟2142{scheduler});
 if (𝓟2145{forcedAsync})
 {
 𝓟2107{ioRestartAsync}(𝓟2141{start} as any,𝓟2150{ctx},𝓟2148{cb} as any,𝓛12643{undefined},𝓟2143{bFirst},𝓟2144{bRest})
 }
 else
 {
 𝓟2117{ioGenericRunLoop}(𝓟2141{start} as any,𝓟2142{scheduler},𝓟2150{ctx},𝓟2148{cb} as any,𝓛12643{undefined},𝓟2143{bFirst},𝓟2144{bRest})
 }
 return 𝓟2149 = 𝓟2150{ctx}.connection
 }
 return 𝓟2146 = 𝓟2608{create}(𝓟2147{$Lambda124})
}
function 𝓟2151{taskToFutureRunLoop} (𝓟2152{start}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1779{IO}),𝓟2153{scheduler}: (𝓟[ty]2729{Future} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2154: (𝓟[ty]1251{Duration} ≠ 𝓟[ty]2729{Future}))
{
 let 𝓟2155{current}: [OOV]any = 𝓟2152{start};
 let 𝓟2156{bFirst}: [OOV]any = 𝓛12643{undefined};
 let 𝓟2157{bRest}: [OOV]any = 𝓛12643{undefined};
 const 𝓟2158{modulus}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓟2153{scheduler}.executionModel.recommendedBatchSize,𝓛8745{Number});
 let 𝓟2159{frameIndex} = 𝓟2153{scheduler}.batchIndex;
 while (𝓛8744{Boolean})
 {
 if (𝓛1{<UNKNOWN>}(𝓟2155{current},𝓛12643{undefined}))
 {
 if (𝓟2155{current}.isSuccess())
 {
 const 𝓟2160{bind}: [miss]𝓛[ty]8696{Function} = 𝓟2068{_ioPopNextBind}(𝓟2156{bFirst},𝓟2157{bRest});
 if (𝓛12569{ExclamationToken}(𝓟2160{bind}))
 {
 𝓟2153{scheduler}.batchIndex ⟵ 𝓟2159{frameIndex};
 return 𝓟2154 = 𝓟2600{pure}(𝓟2155{current}.get())
 }
 {
 𝓟2155{current} ⟵ 𝓟2160{bind}(𝓟2155{current}.get());
 }
 }
 else
 {
 const 𝓟2161{err} = 𝓟2155{current} as 𝓟[ty]715{Try}.failed().get();
 const 𝓟2162{bind}: [miss]𝓛[ty]8696{Function} = 𝓟2073{_ioFindErrorHandler}(𝓟2156{bFirst},𝓟2157{bRest});
 if (𝓛12569{ExclamationToken}(𝓟2162{bind}))
 {
 𝓟2153{scheduler}.batchIndex ⟵ 𝓟2159{frameIndex};
 return 𝓟2154 = 𝓟2604{raise}(𝓟2161{err})
 }
 {
 𝓟2155{current} ⟵ 𝓟2162{bind}(𝓟2161{err});
 }
 }
 𝓟2156{bFirst} ⟵ 𝓛12643{undefined};
 const 𝓟2163{nextIndex}: [miss]𝓛[ty]8655{Number} = 𝓛12608{AmpersandToken}(𝓛12641{PlusToken}(𝓟2159{frameIndex},𝓛8745{Number}),𝓟2158{modulus});
 if (𝓟2163{nextIndex})
 {
 𝓟2159{frameIndex} ⟵ 𝓟2163{nextIndex};
 }
 else
 {
 return 𝓟2154 = 𝓟2140{ioToFutureGoAsync}(𝓟2155{current},𝓟2153{scheduler},𝓟2156{bFirst},𝓟2157{bRest},𝓛8744{Boolean})
 }
 }
 else
 {
 𝓛12577{$Switch}(𝓟2155{current}._tag)
 𝓛12634{$Case}(𝓛8743{String})
 𝓟2155{current} ⟵ 𝓟2155{current} as 𝓟[ty]1955{IOPure}.value;
 𝓛12634{$Case}(𝓛8743{String})
 𝓟2155{current} ⟵ 𝓟656{of}(𝓟2155{current} as 𝓟[ty]1982{IOAlways}.thunk);
 𝓛12634{$Case}(𝓛8743{String})
 𝓟2155{current} ⟵ 𝓟2155{current} as 𝓟[ty]1966{IOOnce}.runTry();
 𝓛12634{$Case}(𝓛8743{String})
 const 𝓟2164{flatM}: (𝓟[ty]2528{FlatMap} ≠ 𝓟[ty]1993{IOFlatMap}) = 𝓟2155{current} as any;
 if (𝓟2156{bFirst})
 {
 if (𝓛12569{ExclamationToken}(𝓟2157{bRest}))
 {
 𝓟2157{bRest} ⟵ 𝓛8757{Array}();
 }
 𝓟2157{bRest}.push(𝓟2156{bFirst})
 }
 𝓟2156{bFirst} ⟵ (𝓛12569{ExclamationToken}(𝓟2164{flatM}.g) ? 𝓟2164{flatM}.f : 𝓛8757{Array}(𝓟2164{flatM}.f,𝓟2164{flatM}.g);
 𝓟2155{current} ⟵ 𝓟2164{flatM}.source;
 𝓛12634{$Case}(𝓛8743{String})
 𝓛12634{$Case}(𝓛8743{String})
 return 𝓟2154 = 𝓟2140{ioToFutureGoAsync}(𝓟2155{current},𝓟2153{scheduler},𝓟2156{bFirst},𝓟2157{bRest},𝓛8744{Boolean})
 }
 }
}
function 𝓟2165{ioSafeCallback} (𝓟2166{ec}: (𝓟[ty]2014{IOMemoize} ≠ 𝓟[ty]1309{Scheduler}),𝓟2167{conn}: (𝓟[ty]430{TLeft} ≠ 𝓟[ty]219{StackedCancelable}),𝓟2168{cb}: 𝓛[ty]8696{Function}): (𝓟2169: 𝓛[ty]8696{Function})
{
 let 𝓟2170{called}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
 function 𝓟2171{$Lambda125} (𝓟2172{r}: 𝓟[ty]715{Try}): (𝓟2173: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12569{ExclamationToken}(𝓟2170{called}))
 {
 𝓟2170{called} ⟵ 𝓛8744{Boolean};
 function 𝓟2174{$Lambda126} (): (𝓟2175: [miss]𝓛[ty]10033{Void})
 {
 𝓟2167{conn}.pop()
 𝓟2168{cb}(𝓟2172{r})
 }
 𝓟2166{ec}.trampoline(𝓟2174{$Lambda126})
 }
 else
 {
 if (𝓟2172{r}.isFailure())
 {
 𝓟2166{ec}.reportFailure(𝓟2172{r}.failed().get())
 }
 }
 }
 return 𝓟2169 = 𝓟2171{$Lambda125}
}
function 𝓟2176{ioStartMemoize} (𝓟2177{fa}: 𝓟[ty]2014{IOMemoize},𝓟2178{ec}: (𝓟[ty]2729{Future} ≠ 𝓟[ty]1309{Scheduler}),𝓟2179{context}: [OOV]any,𝓟2180{cb}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function}),𝓟2181{bFirstInit}: [OOV]any,𝓟2182{bRestInit}: [OOV]any,𝓟2183{frameIndex}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8655{Number})): (𝓟2184: [OOV]any)
{
 𝓟2178{ec}.batchIndex ⟵ 𝓟2183{frameIndex};
 let 𝓟2185{state}: [OOV]any;
 if (𝓟2177{fa}.result)
 {
 𝓟2185{state} ⟵ 𝓟2177{fa}.result;
 }
 else
 {
 const 𝓟2186{f} = 𝓟2140{ioToFutureGoAsync}(𝓟2177{fa}.source as any,𝓟2178{ec},𝓛12643{undefined},𝓛12643{undefined},𝓛8744{Boolean});
 if (𝓟2186{f}.value().isEmpty())
 {
 𝓟2177{fa}.result ⟵ 𝓟2186{f};
 𝓟2185{state} ⟵ 𝓟2186{f};
 function 𝓟2187{$Lambda127} (𝓟2188{r}): (𝓟2189: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12546{BarBarToken}(𝓟2188{r}.isSuccess(),𝓛12569{ExclamationToken}(𝓟2177{fa}.onlySuccess)))
 {
 𝓟2177{fa}.result ⟵ 𝓟2188{r} as any;
 𝓛12622{$Delete}(𝓟2177{fa}.source)
 }
 else
 {
 𝓟2177{fa}.result ⟵ 𝓛12643{undefined};
 }
 }
 𝓟2186{f}.onComplete(𝓟2187{$Lambda127})
 }
 else
 {
 𝓟2185{state} ⟵ 𝓟2186{f}.value().get() as any as 𝓟[ty]715{Try};
 if (𝓛12546{BarBarToken}(𝓟2185{state}.isSuccess(),𝓛12569{ExclamationToken}(𝓟2177{fa}.onlySuccess)))
 {
 𝓟2177{fa}.result ⟵ 𝓟2185{state} as any;
 }
 }
 }
 const 𝓟2190{io}: (𝓟[ty]1955{IOPure} ≠ 𝓟[ty]1779{IO}) = (𝓛1{<UNKNOWN>}(𝓟2185{state},𝓛12643{undefined}) ? 𝓟1950{CONSTRUCTOR}(𝓟2185{state}) : 𝓟1607{fromFuture}(𝓟2185{state});
 𝓟2117{ioGenericRunLoop}(𝓟2190{io},𝓟2178{ec},𝓟2179{context},𝓟2180{cb},𝓛12643{undefined},𝓟2181{bFirstInit},𝓟2182{bRestInit})
}
function 𝓟2191{ioSequence} (𝓟2192{list}: [OOV]any): (𝓟2193: 𝓟[ty]1779{IO})
{
 function 𝓟2194{$Lambda128} (): (𝓟2195: [OOV]𝓟[ty]910{IteratorLike})
 {
 return 𝓟2195 = 𝓟914{iteratorOf}(𝓟2192{list})
 }
 function 𝓟2196{$Lambda129} (𝓟2197{cursor}): (𝓟2198: [miss]𝓟[ty]1779{IO})
 {
 return 𝓟2198 = 𝓟2199{ioSequenceLoop}(𝓛8757{Array}(),𝓟2197{cursor})
 }
 return 𝓟2193 = 𝓟1684{of}(𝓟2194{$Lambda128}).flatMap(𝓟2196{$Lambda129})
}
function 𝓟2199{ioSequenceLoop} (𝓟2200{acc}: 𝓛[ty]8670{Array},𝓟2201{cursor}: [OOV]𝓟[ty]910{IteratorLike}): (𝓟2202: 𝓟[ty]1779{IO})
{
 while (𝓛8744{Boolean})
 {
 const 𝓟2203{elem}: [miss]𝓛[ty]8642{Object} = 𝓟2201{cursor}.next();
 const 𝓟2204{isDone}: [miss]𝓛[ty]8666{Boolean} = 𝓟2203{elem}.done;
 if (𝓟2203{elem}.value)
 {
 const 𝓟2205{io}: (𝓟[ty]1982{IOAlways} ≠ 𝓟[ty]1779{IO}) = 𝓟2203{elem}.value;
 function 𝓟2206{$Lambda130} (𝓟2207{a}): (𝓟2208: [miss]𝓟[ty]1779{IO})
 {
 𝓟2200{acc}.push(𝓟2207{a})
 if (𝓟2204{isDone})
 {
 return 𝓟2208 = 𝓟1745{pure}(𝓟2200{acc})
 }
 return 𝓟2208 = 𝓟2199{ioSequenceLoop}(𝓟2200{acc},𝓟2201{cursor})
 }
 return 𝓟2202 = 𝓟2205{io}.flatMap(𝓟2206{$Lambda130})
 }
 else
 {
 if (𝓟2204{isDone})
 {
 return 𝓟2202 = 𝓟1745{pure}(𝓟2200{acc})
 }
 }
 }
}
function 𝓟2209{ioListToFutureProcess} (𝓟2210{list}: [OOV]any,𝓟2211{f}: 𝓛[ty]8696{Function}): (𝓟2212: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]1779{IO}))
{
 function 𝓟2213{$Lambda131} (𝓟2214{ctx},𝓟2215{cb}): (𝓟2216: [miss]𝓛[ty]10033{Void})
 {
 function 𝓟2217{$Lambda132} (): (𝓟2218: [miss]𝓛[ty]10033{Void})
 {
 let 𝓟2219{streamErrors}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
 {
 const 𝓟2220{futures}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
 const 𝓟2221{array}: 𝓛[ty]8670{Array} = 𝓟2238{iterableToArray}(𝓟2210{list});
 𝓟2219{streamErrors} ⟵ 𝓛8744{Boolean};
 {
 let 𝓟2222{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓛1{<UNKNOWN>}(𝓟2222{i},𝓟2221{array}.length))
 {
 {
 const 𝓟2223{io}: [miss]𝓟[ty]1779{IO} = 𝓟2221{array}.access(𝓟2222{i});
 const 𝓟2224{f} = 𝓟2223{io}.run(𝓟2214{ctx}.scheduler);
 𝓟2220{futures}.push(𝓟2224{f})
 }
 𝓛12556{POST_PlusPlusToken}(𝓟2222{i})
 }
 }
 const 𝓟2225{all} = 𝓟2211{f}(𝓟2220{futures},𝓟2214{ctx}.scheduler);
 𝓟2214{ctx}.connection.push(𝓟2225{all})
 𝓟2225{all}.onComplete(𝓟2165{ioSafeCallback}(𝓟2214{ctx}.scheduler,𝓟2214{ctx}.connection,𝓟2215{cb}) as any)
 }
 }
 𝓟2214{ctx}.scheduler.trampoline(𝓟2217{$Lambda132})
 }
 return 𝓟2212 = 𝓟1563{asyncUnsafe}(𝓟2213{$Lambda131})
}

Module: packages/funfix/src/index

Module: packages/funfix-exec/src/internals

function 𝓟2226{arrayBSearchInsertPos} (𝓟2227{array}: 𝓛[ty]8670{Array},𝓟2228{f}: 𝓛[ty]8696{Function}): (𝓟2229: 𝓛[ty]8696{Function})
{
 function 𝓟2230{$Lambda188} (𝓟2231{search}): (𝓟2232: [miss]𝓛[ty]8655{Number})
 {
 let 𝓟2233{minIndex}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 let 𝓟2234{maxIndex}: [miss]𝓛[ty]8655{Number} = 𝓛12616{MinusToken}(𝓟2227{array}.length,𝓛8745{Number});
 while (𝓛12582{LessThanEqualsToken}(𝓟2233{minIndex},𝓟2234{maxIndex}))
 {
 const 𝓟2235{index}: [miss]𝓛[ty]8655{Number} = 𝓛12618{BarToken}(𝓛12573{SlashToken}(𝓛12641{PlusToken}(𝓟2233{minIndex},𝓟2234{maxIndex}),𝓛8745{Number}),𝓛8745{Number});
 const 𝓟2236{current}: [miss]𝓛[ty]8655{Number} = 𝓟2228{f}(𝓟2227{array}.access(𝓟2235{index}));
 const 𝓟2237{next}: [miss]𝓛[ty]8655{Number} = (𝓛12582{LessThanEqualsToken}(𝓛12641{PlusToken}(𝓟2235{index},𝓛8745{Number}),𝓟2234{maxIndex}) ? 𝓟2228{f}(𝓟2227{array}.access(𝓛12641{PlusToken}(𝓟2235{index},𝓛8745{Number}))) : 𝓛12643{undefined};
 if (𝓛12592{AmpersandAmpersandToken}(𝓛12582{LessThanEqualsToken}(𝓟2236{current},𝓟2231{search}),𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟2237{next},𝓛12643{undefined}),𝓛1{<UNKNOWN>}(𝓟2231{search},𝓟2237{next}))))
 {
 return 𝓟2232 = 𝓛12641{PlusToken}(𝓟2235{index},𝓛8745{Number})
 }
 else
 {
 if (𝓛12582{LessThanEqualsToken}(𝓟2236{current},𝓟2231{search}))
 {
 𝓟2233{minIndex} ⟵ 𝓛12641{PlusToken}(𝓟2235{index},𝓛8745{Number});
 }
 else
 {
 𝓟2234{maxIndex} ⟵ 𝓛12616{MinusToken}(𝓟2235{index},𝓛8745{Number});
 }
 }
 }
 return 𝓟2232 = 𝓛8745{Number}
 }
 return 𝓟2229 = 𝓟2230{$Lambda188}
}
function 𝓟2238{iterableToArray} (𝓟2239{values}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]5968{Iterable})): (𝓟2240: 𝓛[ty]8670{Array})
{
 if (𝓛12569{ExclamationToken}(𝓟2239{values}))
 {
 return 𝓟2240 = 𝓛8757{Array}()
 }
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓛8741{Object}.prototype.toString.call(𝓟2239{values}),𝓛8743{String}))
 {
 return 𝓟2240 = 𝓟2239{values} as 𝓛[ty]8670{Array}
 }
 const 𝓟2241{cursor}: [OOV]𝓛[ty]5961{Iterator} = 𝓟2239{values}.access(𝓛10031{Symbol}.iterator)();
 const 𝓟2242{arr}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
 while (𝓛8744{Boolean})
 {
 const 𝓟2243{item}: [OOV]𝓛[ty]5964{IteratorResult} = 𝓟2241{cursor}.next();
 if (𝓟2243{item}.value)
 {
 𝓟2242{arr}.push(𝓟2243{item}.value)
 }
 if (𝓟2243{item}.done)
 {
 return 𝓟2240 = 𝓟2242{arr}
 }
 }
}
const 𝓟2244{lnOf2}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.log(𝓛8745{Number});
function 𝓟2245{log2} (𝓟2246{x}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8655{Number})): (𝓟2247: 𝓛[ty]8655{Number})
{
 return 𝓟2247 = 𝓛12573{SlashToken}(𝓛8746{Math}.log(𝓟2246{x}),𝓟2244{lnOf2})
}
const 𝓟2248{maxPowerOf2}: 𝓛[ty]8655{Number} = 𝓛12560{LessThanLessThanToken}(𝓛8745{Number},𝓛8745{Number});
function 𝓟2249{nextPowerOf2} (𝓟2250{nr}: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8655{Number})): (𝓟2251: 𝓛[ty]8655{Number})
{
 if (𝓛1{<UNKNOWN>}(𝓟2250{nr},𝓛8745{Number}))
 {
 𝓟3217{CONSTRUCTOR}(𝓛8743{String})
 }
 const 𝓟2252{bit}: [miss]𝓛[ty]8655{Number} = 𝓛8746{Math}.ceil(𝓟2245{log2}(𝓟2250{nr}));
 return 𝓟2251 = 𝓛12560{LessThanLessThanToken}(𝓛8745{Number},(𝓛12595{GreaterThanToken}(𝓟2252{bit},𝓛8745{Number}) ? 𝓛8745{Number} : 𝓛12608{AmpersandToken}(𝓟2252{bit},𝓟2252{bit}))
}

Module: test-common/chain-rec-tests

function 𝓟2253{chainRecCheck} (𝓟2254{genFA}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2255{genFB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2256{genFC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2257{genAtoB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2258{genBtoC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2259{genFAtoB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2260{genFBtoC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2261{genA}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2262{check}: 𝓛[ty]8696{Function},𝓟2263{F}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2264{lawsRef}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2265{includeSuperTypes}: 𝓛[ty]8666{Boolean}): (𝓟2266: [miss]𝓛[ty]10033{Void})
{
 const 𝓟2267{laws} = 𝓛12546{BarBarToken}(𝓟2264{lawsRef},𝓟3255{ChainRecLaws}.CONSTRUCTOR(𝓟2263{F}));
 𝓟870{chainCheck}(𝓟2254{genFA},𝓟2255{genFB},𝓟2256{genFC},𝓟2257{genAtoB},𝓟2258{genBtoC},𝓟2259{genFAtoB},𝓟2260{genFBtoC},𝓟2262{check},𝓟2263{F},𝓟2264{lawsRef},𝓟2265{includeSuperTypes})
 function 𝓟2268{$Lambda5} (𝓟2269{a},𝓟2270{f}): (𝓟2271: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟2271 = 𝓟2262{check}(𝓟2267{laws}.chainRecConsistency(𝓟2269{a},𝓟2270{f}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟2261{genA},𝓛1{<UNKNOWN>}(𝓟2254{genFA}),𝓟2268{$Lambda5})
}

Module: test-common/monad-tests

function 𝓟2272{monadCheck} (𝓟2273{genFA}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2274{genFB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2275{genFC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2276{genAtoB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2277{genBtoC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2278{genFAtoB}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2279{genFBtoC}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2280{genA}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2281{check}: 𝓛[ty]8696{Function},𝓟2282{F}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2283{lawsRef}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟2284{includeSuperTypes}: 𝓛[ty]8666{Boolean}): (𝓟2285: [miss]𝓛[ty]10033{Void})
{
 const 𝓟2286{laws} = 𝓛12546{BarBarToken}(𝓟2283{lawsRef},𝓟3256{MonadLaws}.CONSTRUCTOR(𝓟2282{F}));
 if (𝓟2284{includeSuperTypes})
 {
 𝓟842{applicativeCheck}(𝓟2273{genFA},𝓟2276{genAtoB},𝓟2277{genBtoC},𝓟2278{genFAtoB},𝓟2279{genFBtoC},𝓟2280{genA},𝓟2281{check},𝓟2282{F},𝓟2286{laws})
 𝓟2253{chainRecCheck}(𝓟2273{genFA},𝓟2274{genFB},𝓟2275{genFC},𝓟2276{genAtoB},𝓟2277{genBtoC},𝓟2278{genFAtoB},𝓟2279{genFBtoC},𝓟2280{genA},𝓟2281{check},𝓟2282{F},𝓟2286{laws},𝓛8744{Boolean})
 }
 function 𝓟2287{$Lambda10} (𝓟2288{a},𝓟2289{f}): (𝓟2290: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟2290 = 𝓟2281{check}(𝓟2286{laws}.monadLeftIdentity(𝓟2288{a},𝓟2289{f}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟2280{genA},𝓛1{<UNKNOWN>}(𝓟2274{genFB}),𝓟2287{$Lambda10})
 function 𝓟2291{$Lambda11} (𝓟2292{fa}): (𝓟2293: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟2293 = 𝓟2281{check}(𝓟2286{laws}.monadRightIdentity(𝓟2292{fa}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟2273{genFA},𝓟2291{$Lambda11})
 function 𝓟2294{$Lambda12} (𝓟2295{fa},𝓟2296{f}): (𝓟2297: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟2297 = 𝓟2281{check}(𝓟2286{laws}.monadMap(𝓟2295{fa},𝓟2296{f}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟2273{genFA},𝓟2276{genAtoB},𝓟2294{$Lambda12})
 function 𝓟2298{$Lambda13} (): (𝓟2299: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟2299 = 𝓟2281{check}(𝓟2286{laws}.monadChainRecStackSafety())
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟2298{$Lambda13})
}

Module: packages/funfix-exec/src/ref

function 𝓟2300{CONSTRUCTOR} (𝓟2301{fn}: (𝓟[ty]621{TNone} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]2308{DynamicRef})
{
 const 𝓟[ty]2308{DynamicRef};
 const 𝓟[ty]2308{DynamicRef};
 𝓟[ty]2308{DynamicRef}._previous ⟵ 𝓛8757{Array}();
 𝓟[ty]2308{DynamicRef}.get ⟵ 𝓟2301{fn};
}
function 𝓟2305{of} (𝓟2306{fn}: (𝓟[ty]621{TNone} ≠ 𝓛[ty]8696{Function})): (𝓟2307: 𝓟[ty]2308{DynamicRef})
{
 return 𝓟2307 = 𝓟2300{CONSTRUCTOR}(𝓟2306{fn})
}
class 𝓟[ty]2308{DynamicRef}{
 𝓟2310{_previous}: 𝓛[ty]8670{Array};
 𝓟2311{get}: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8696{Function});
 function 𝓟2329{bindL} (𝓟2330{value}: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8696{Function}),𝓟2331{thunk}: 𝓛[ty]8696{Function}): (𝓟2332: [OOV]any)
 {
 const 𝓟2333{oldFn}: [miss]𝓛[ty]8696{Function} = 𝓟[ty]2308{DynamicRef}.get;
 const 𝓟2334{oldPrev}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]2308{DynamicRef}._previous.slice(𝓛8745{Number});
 const 𝓟2335{ta} = 𝓟[ty]2308{DynamicRef} as any;
 {
 𝓟2335{ta}.get ⟵ 𝓟2330{value};
 return 𝓟2332 = 𝓟2331{thunk}()
 }
 {
 𝓟2335{ta}.get ⟵ 𝓟2333{oldFn};
 𝓟2335{ta}._previous ⟵ 𝓟2334{oldPrev};
 }
 }
 function 𝓟2312{set} (𝓟2313{value}: [OOV]any): (𝓟2314: (𝓟[ty]533{Option} ≠ 𝓛[ty]10033{Void}))
 {
 function 𝓟2315{$Lambda189} (): (𝓟2316: [OOV]any)
 {
 return 𝓟2316 = 𝓟2313{value}
 }
 return 𝓟2314 = 𝓟[ty]2308{DynamicRef}.setL(𝓟2315{$Lambda189})
 }
 function 𝓟2323{bind} (𝓟2324{value}: [OOV]any,𝓟2325{thunk}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟2326: [OOV]any)
 {
 function 𝓟2327{$Lambda190} (): (𝓟2328: [OOV]any)
 {
 return 𝓟2328 = 𝓟2324{value}
 }
 return 𝓟2326 = 𝓟[ty]2308{DynamicRef}.bindL(𝓟2327{$Lambda190},𝓟2325{thunk})
 }
 function 𝓟2317{setL} (𝓟2318{thunk}: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8696{Function})): (𝓟2319: 𝓛[ty]10033{Void})
 {
 𝓟[ty]2308{DynamicRef}._previous.push(𝓟[ty]2308{DynamicRef}.get)
 𝓟[ty]2308{DynamicRef}.get ⟵ 𝓟2318{thunk};
 }
 function 𝓟2320{revert} (): (𝓟2321: 𝓛[ty]10033{Void})
 {
 const 𝓟2322{thunk}: [miss]𝓛[ty]8696{Function} = 𝓟[ty]2308{DynamicRef}._previous.pop();
 if (𝓟2322{thunk})
 {
 𝓟[ty]2308{DynamicRef}.get ⟵ 𝓟2322{thunk};
 }
 }
}

Module: packages/funfix-core/src/kinds

type 𝓟[ty]2336{HK2} extends 𝓟[ty]2337{HK} = {_L: any}
type 𝓟[ty]2337{HK} = {_URI: any, _A: any}
type 𝓟[ty]2338{Constructor} = any
type 𝓟[ty]2339{HK3} extends 𝓟[ty]2336{HK2} = {_U: any}

Module: packages/funfix-effect/src/eval

type 𝓟[ty]2340{Bind} = (any)->𝓟[ty]2437{Eval}
type 𝓟[ty]2437{Eval} = 𝓟[ty]2437{Eval}
type 𝓛[ty]2{<UNKNOWN>} = 𝓛[ty]2{<UNKNOWN>}
type 𝓛[ty]8670{Array} = 𝓛[ty]8670{Array}
const 𝓟2344{_Class}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval});
function 𝓟2345{CONSTRUCTOR} (): (𝓟[ty]2437{Eval})
{
 const 𝓟[ty]2437{Eval};
 const 𝓟[ty]2437{Eval};
}
function 𝓟2349{of} (𝓟2350{thunk}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟2351: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2437{Eval}))
{
 return 𝓟2351 = 𝓟2360{always}(𝓟2350{thunk})
}
function 𝓟2352{pure} (𝓟2353{value}: [OOV]any): (𝓟2354: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2437{Eval}))
{
 return 𝓟2354 = 𝓟2355{now}(𝓟2353{value})
}
function 𝓟2355{now} (𝓟2356{value}: [OOV]any): (𝓟2357: (𝓟[ty]441{TRight} ≠ 𝓟[ty]2437{Eval}))
{
 return 𝓟2357 = 𝓟2472{CONSTRUCTOR}(𝓟2356{value})
}
function 𝓟2358{unit} (): (𝓟2359: (𝓟[ty]2938{AsyncFuture} ≠ 𝓟[ty]2437{Eval}))
{
 return 𝓟2359 = 𝓟2485{evalUnitRef}
}
function 𝓟2360{always} (𝓟2361{thunk}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function})): (𝓟2362: (𝓟[ty]2084{RestartCallback} ≠ 𝓟[ty]2437{Eval}))
{
 return 𝓟2362 = 𝓟2501{CONSTRUCTOR}(𝓟2361{thunk})
}
function 𝓟2363{once} (𝓟2364{thunk}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟2365: (𝓟[ty]2084{RestartCallback} ≠ 𝓟[ty]2437{Eval}))
{
 return 𝓟2365 = 𝓟2486{CONSTRUCTOR}(𝓟2364{thunk})
}
function 𝓟2366{suspend} (𝓟2367{thunk}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function})): (𝓟2368: (𝓟[ty]2084{RestartCallback} ≠ 𝓟[ty]2437{Eval}))
{
 return 𝓟2368 = 𝓟2511{CONSTRUCTOR}(𝓟2367{thunk})
}
function 𝓟2369{defer} (𝓟2370{thunk}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function})): (𝓟2371: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2437{Eval}))
{
 return 𝓟2371 = 𝓟2366{suspend}(𝓟2370{thunk})
}
function 𝓟2372{tailRecM} (𝓟2373{a}: [OOV]any,𝓟2374{f}: 𝓛[ty]8696{Function}): (𝓟2375: (𝓟[ty]533{Option} ≠ 𝓟[ty]2437{Eval}))
{
 function 𝓟2376{$Lambda47} (𝓟2377{either}): (𝓟2378: [miss]𝓟[ty]2437{Eval})
 {
 if (𝓟2377{either}.isRight())
 {
 return 𝓟2378 = 𝓟2355{now}(𝓟2377{either}.get())
 }
 else
 {
 return 𝓟2378 = 𝓟2372{tailRecM}(𝓟2377{either}.swap().get(),𝓟2374{f})
 }
 }
 return 𝓟2375 = 𝓟2374{f}(𝓟2373{a}).flatMap(𝓟2376{$Lambda47})
}
function 𝓟2379{sequence} (𝓟2380{list}: [OOV]any): (𝓟2381: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2437{Eval}))
{
 return 𝓟2381 = 𝓟2568{evalSequence}(𝓟2380{list})
}
function 𝓟2382{map2} (𝓟2383{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2384{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2385{f}: 𝓛[ty]8696{Function}): (𝓟2386: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2437{Eval}))
{
 const 𝓟2387{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]2437{Eval}) = 𝓟2379{sequence}(𝓛8757{Array}(𝓟2383{fa1},𝓟2384{fa2}) as 𝓛[ty]8670{Array});
 function 𝓟2388{$Lambda48} (𝓟2389{lst}): (𝓟2390: [OOV]any)
 {
 return 𝓟2390 = 𝓟2385{f}(𝓟2389{lst}.access(𝓛8745{Number}),𝓟2389{lst}.access(𝓛8745{Number}))
 }
 return 𝓟2386 = 𝓟2387{fl}.map(𝓟2388{$Lambda48})
}
function 𝓟2391{map3} (𝓟2392{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2393{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2394{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2395{f}: 𝓛[ty]8696{Function}): (𝓟2396: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2437{Eval}))
{
 const 𝓟2397{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]2437{Eval}) = 𝓟2379{sequence}(𝓛8757{Array}(𝓟2392{fa1},𝓟2393{fa2},𝓟2394{fa3}) as 𝓛[ty]8670{Array});
 function 𝓟2398{$Lambda49} (𝓟2399{lst}): (𝓟2400: [OOV]any)
 {
 return 𝓟2400 = 𝓟2395{f}(𝓟2399{lst}.access(𝓛8745{Number}),𝓟2399{lst}.access(𝓛8745{Number}),𝓟2399{lst}.access(𝓛8745{Number}))
 }
 return 𝓟2396 = 𝓟2397{fl}.map(𝓟2398{$Lambda49})
}
function 𝓟2401{map4} (𝓟2402{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2403{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2404{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2405{fa4}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2406{f}: 𝓛[ty]8696{Function}): (𝓟2407: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2437{Eval}))
{
 const 𝓟2408{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]2437{Eval}) = 𝓟2379{sequence}(𝓛8757{Array}(𝓟2402{fa1},𝓟2403{fa2},𝓟2404{fa3},𝓟2405{fa4}) as 𝓛[ty]8670{Array});
 function 𝓟2409{$Lambda50} (𝓟2410{lst}): (𝓟2411: [OOV]any)
 {
 return 𝓟2411 = 𝓟2406{f}(𝓟2410{lst}.access(𝓛8745{Number}),𝓟2410{lst}.access(𝓛8745{Number}),𝓟2410{lst}.access(𝓛8745{Number}),𝓟2410{lst}.access(𝓛8745{Number}))
 }
 return 𝓟2407 = 𝓟2408{fl}.map(𝓟2409{$Lambda50})
}
function 𝓟2412{map5} (𝓟2413{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2414{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2415{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2416{fa4}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2417{fa5}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]2437{Eval}),𝓟2418{f}: 𝓛[ty]8696{Function}): (𝓟2419: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2437{Eval}))
{
 const 𝓟2420{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]2437{Eval}) = 𝓟2379{sequence}(𝓛8757{Array}(𝓟2413{fa1},𝓟2414{fa2},𝓟2415{fa3},𝓟2416{fa4},𝓟2417{fa5}) as 𝓛[ty]8670{Array});
 function 𝓟2421{$Lambda51} (𝓟2422{lst}): (𝓟2423: [OOV]any)
 {
 return 𝓟2423 = 𝓟2418{f}(𝓟2422{lst}.access(𝓛8745{Number}),𝓟2422{lst}.access(𝓛8745{Number}),𝓟2422{lst}.access(𝓛8745{Number}),𝓟2422{lst}.access(𝓛8745{Number}),𝓟2422{lst}.access(𝓛8745{Number}))
 }
 return 𝓟2419 = 𝓟2420{fl}.map(𝓟2421{$Lambda51})
}
function 𝓟2424{map6} (𝓟2425{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2426{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2427{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2428{fa4}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval}),𝓟2429{fa5}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]2437{Eval}),𝓟2430{fa6}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]2437{Eval}),𝓟2431{f}: 𝓛[ty]8696{Function}): (𝓟2432: (𝓟[ty]2938{AsyncFuture} ≠ 𝓟[ty]2437{Eval}))
{
 const 𝓟2433{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]2437{Eval}) = 𝓟2379{sequence}(𝓛8757{Array}(𝓟2425{fa1},𝓟2426{fa2},𝓟2427{fa3},𝓟2428{fa4},𝓟2429{fa5},𝓟2430{fa6}) as 𝓛[ty]8670{Array});
 function 𝓟2434{$Lambda52} (𝓟2435{lst}): (𝓟2436: [OOV]any)
 {
 return 𝓟2436 = 𝓟2431{f}(𝓟2435{lst}.access(𝓛8745{Number}),𝓟2435{lst}.access(𝓛8745{Number}),𝓟2435{lst}.access(𝓛8745{Number}),𝓟2435{lst}.access(𝓛8745{Number}),𝓟2435{lst}.access(𝓛8745{Number}),𝓟2435{lst}.access(𝓛8745{Number}))
 }
 return 𝓟2432 = 𝓟2433{fl}.map(𝓟2434{$Lambda52})
}
class 𝓟[ty]2437{Eval} extends 𝓛[ty]2{<UNKNOWN>}{
 𝓟2439{_tag}: [OOV]any;
 𝓟2440{_URI}: 𝓛[ty]10051{String};
 𝓟2441{_A}: [OOV]any;
 function 𝓟2444{map} (𝓟2445{f}: 𝓛[ty]8696{Function}): (𝓟2446: (𝓟[ty]811{TFailure} ≠ 𝓟[ty]2437{Eval}))
 {
 function 𝓟2447{$Lambda44} (𝓟2448{a}: [OOV]any): (𝓟2449: [miss]𝓟[ty]2437{Eval})
 {
 return 𝓟2449 = 𝓟2355{now}(𝓟2445{f}(𝓟2448{a}))
 }
 return 𝓟2446 = 𝓟2522{CONSTRUCTOR}(𝓟[ty]2437{Eval},𝓟2447{$Lambda44})
 }
 function 𝓟2456{ap} (𝓟2457{ff}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2437{Eval})): (𝓟2458: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2437{Eval}))
 {
 function 𝓟2459{$Lambda45} (𝓟2460{f}): (𝓟2461: [miss]𝓟[ty]2437{Eval})
 {
 return 𝓟2461 = 𝓟[ty]2437{Eval}.map(𝓟2460{f})
 }
 return 𝓟2458 = 𝓟2457{ff}.flatMap(𝓟2459{$Lambda45})
 }
 function 𝓟2469{forEach} (𝓟2470{cb}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟2471: 𝓛[ty]10033{Void})
 {
 𝓟[ty]2437{Eval}.forEachL(𝓟2470{cb}).get()
 }
 function 𝓟2466{forEachL} (𝓟2467{cb}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟2468: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2437{Eval}))
 {
 return 𝓟2468 = 𝓟[ty]2437{Eval}.map(𝓟2467{cb})
 }
 function 𝓟2450{flatMap} (𝓟2451{f}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function})): (𝓟2452: (𝓟[ty]811{TFailure} ≠ 𝓟[ty]2437{Eval}))
 {
 return 𝓟2452 = 𝓟2522{CONSTRUCTOR}(𝓟[ty]2437{Eval},𝓟2451{f})
 }
 function 𝓟2442{get} (): (𝓟2443: [OOV]any)
 {
 return 𝓟2443 = 𝓟2559{evalRunLoop}(𝓟[ty]2437{Eval})
 }
 function 𝓟2453{chain} (𝓟2454{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟2455: (𝓟[ty]533{Option} ≠ 𝓟[ty]2437{Eval}))
 {
 return 𝓟2455 = 𝓟[ty]2437{Eval}.flatMap(𝓟2454{f})
 }
 function 𝓟2462{memoize} (): (𝓟2463: (𝓟[ty]441{TRight} ≠ 𝓟[ty]2437{Eval}))
 {
 𝓛12577{$Switch}(𝓟[ty]2437{Eval}._tag)
 𝓛12634{$Case}(𝓛8743{String})
 𝓛12634{$Case}(𝓛8743{String})
 return 𝓟2463 = 𝓟[ty]2437{Eval}
 𝓛12634{$Case}(𝓛8743{String})
 return 𝓟2463 = 𝓟2486{CONSTRUCTOR}(𝓟[ty]2437{Eval}.get)
 function 𝓟2464{$Lambda46} (): (𝓟2465: [OOV]any)
 {
 return 𝓟2465 = 𝓟[ty]2437{Eval}.get()
 }
 return 𝓟2463 = 𝓟2486{CONSTRUCTOR}(𝓟2464{$Lambda46})
 }
}
function 𝓟2472{CONSTRUCTOR} (𝓟2473{value}: [OOV]any): (𝓟[ty]2477{Now})
{
 const 𝓟[ty]2477{Now};
 const 𝓟[ty]2477{Now};
 𝓟[ty]2477{Now}._tag ⟵ 𝓛8743{String};
 𝓟[ty]2477{Now}.value ⟵ 𝓟2473{value};
 𝓟[ty]2477{Now}()
}
class 𝓟[ty]2477{Now} extends 𝓟[ty]2437{Eval}{
 𝓟2479{_tag}: 𝓛[ty]10051{String};
 𝓟2480{value}: [OOV]any;
 function 𝓟2481{get} (): (𝓟2482: [OOV]any)
 {
 return 𝓟2482 = 𝓟[ty]2477{Now}.value
 }
 function 𝓟2483{toString} (): (𝓟2484: 𝓛[ty]10051{String})
 {
 return 𝓟2484 = 𝓛12607{$Template}(𝓛8756{JSON}.stringify(𝓟[ty]2477{Now}.value))
 }
}
const 𝓟2485{evalUnitRef}: (𝓟[ty]362{Either} ≠ 𝓟[ty]2477{Now}) = 𝓟2472{CONSTRUCTOR}(𝓛12643{undefined});
function 𝓟2486{CONSTRUCTOR} (𝓟2487{thunk}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]2491{Once})
{
 const 𝓟[ty]2491{Once};
 const 𝓟[ty]2491{Once};
 𝓟[ty]2491{Once}._tag ⟵ 𝓛8743{String};
 𝓟[ty]2491{Once}()
 𝓟[ty]2491{Once}._thunk ⟵ 𝓟2487{thunk};
}
class 𝓟[ty]2491{Once} extends 𝓟[ty]2437{Eval}{
 𝓟2493{_tag}: 𝓛[ty]10051{String};
 𝓟2494{_thunk}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function});
 𝓟2495{_cache}: [OOV]any;
 𝓟2496{_isError}: 𝓛[ty]8666{Boolean};
 function 𝓟2497{get} (): (𝓟2498: [OOV]any)
 {
 if (𝓟[ty]2491{Once}._thunk)
 {
 {
 𝓟[ty]2491{Once}._cache ⟵ 𝓟[ty]2491{Once}._thunk();
 𝓟[ty]2491{Once}._isError ⟵ 𝓛8744{Boolean};
 }
 𝓛12622{$Delete}(𝓟[ty]2491{Once}._thunk)
 }
 if (𝓟[ty]2491{Once}._isError)
 {
 𝓟[ty]2491{Once}._cache
 }
 return 𝓟2498 = 𝓟[ty]2491{Once}._cache as 𝓛[ty]2{<UNKNOWN>}
 }
 function 𝓟2499{toString} (): (𝓟2500: 𝓛[ty]10051{String})
 {
 return 𝓟2500 = 𝓛8743{String}
 }
}
function 𝓟2501{CONSTRUCTOR} (𝓟2502{thunk}: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]2506{Always})
{
 const 𝓟[ty]2506{Always};
 const 𝓟[ty]2506{Always};
 𝓟[ty]2506{Always}._tag ⟵ 𝓛8743{String};
 𝓟[ty]2506{Always}()
 𝓟[ty]2506{Always}.get ⟵ 𝓟2502{thunk};
}
class 𝓟[ty]2506{Always} extends 𝓟[ty]2437{Eval}{
 𝓟2508{_tag}: 𝓛[ty]10051{String};
 function 𝓟2509{toString} (): (𝓟2510: 𝓛[ty]10051{String})
 {
 return 𝓟2510 = 𝓛8743{String}
 }
}
function 𝓟2511{CONSTRUCTOR} (𝓟2512{thunk}: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]2516{Suspend})
{
 const 𝓟[ty]2516{Suspend};
 const 𝓟[ty]2516{Suspend};
 𝓟[ty]2516{Suspend}.thunk ⟵ 𝓟2512{thunk};
 𝓟[ty]2516{Suspend}._tag ⟵ 𝓛8743{String};
 𝓟[ty]2516{Suspend}()
}
class 𝓟[ty]2516{Suspend} extends 𝓟[ty]2437{Eval}{
 𝓟2518{_tag}: 𝓛[ty]10051{String};
 𝓟2519{thunk}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8696{Function});
 function 𝓟2520{toString} (): (𝓟2521: 𝓛[ty]10051{String})
 {
 return 𝓟2521 = 𝓛8743{String}
 }
}
function 𝓟2522{CONSTRUCTOR} (𝓟2523{source}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]2437{Eval}),𝓟2524{f}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8696{Function})): (𝓟[ty]2528{FlatMap})
{
 const 𝓟[ty]2528{FlatMap};
 const 𝓟[ty]2528{FlatMap};
 𝓟[ty]2528{FlatMap}.source ⟵ 𝓟2523{source};
 𝓟[ty]2528{FlatMap}._tag ⟵ 𝓛8743{String};
 𝓟[ty]2528{FlatMap}.f ⟵ 𝓟2524{f};
 𝓟[ty]2528{FlatMap}()
}
class 𝓟[ty]2528{FlatMap} extends 𝓟[ty]2437{Eval}{
 𝓟2530{_tag}: 𝓛[ty]10051{String};
 𝓟2531{source}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]2437{Eval});
 𝓟2532{f}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8696{Function});
 function 𝓟2533{toString} (): (𝓟2534: 𝓛[ty]10051{String})
 {
 return 𝓟2534 = 𝓛12607{$Template}(𝓛8743{String}(𝓟[ty]2528{FlatMap}.source))
 }
}
function 𝓟2535{$Lambda53} (𝓟2536{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟2537{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2437{Eval})): (𝓟2538: [miss]𝓟[ty]2437{Eval})
{
 return 𝓟2538 = 𝓟2537{fa}.map(𝓟2536{f})
}
function 𝓟2539{$Lambda54} (𝓟2540{ff}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]2437{Eval}),𝓟2541{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2437{Eval})): (𝓟2542: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2437{Eval}))
{
 return 𝓟2542 = 𝓟2541{fa}.ap(𝓟2540{ff})
}
function 𝓟2543{$Lambda55} (𝓟2544{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟2545{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2437{Eval})): (𝓟2546: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2437{Eval}))
{
 return 𝓟2546 = 𝓟2545{fa}.flatMap(𝓟2544{f})
}
function 𝓟2547{$Lambda56} (𝓟2548{f}: 𝓛[ty]8696{Function},𝓟2549{a}: [OOV]any): (𝓟2550: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2437{Eval}))
{
 function 𝓟2551{$Lambda57} (𝓟2552{a}): (𝓟2553: [miss]𝓟[ty]2437{Eval})
 {
 return 𝓟2553 = 𝓟2548{f}(𝓟314{left} as any,𝓟317{right} as any,𝓟2552{a})
 }
 return 𝓟2550 = 𝓟2372{tailRecM}(𝓟2549{a},𝓟2551{$Lambda57})
}
const 𝓟2554{EvalModule}: [OOV]𝓛[ty]2{<UNKNOWN>} = {map: 𝓟2535{$Lambda53},ap: 𝓟2539{$Lambda54},chainRec: 𝓟2547{$Lambda56},chain: 𝓟2543{$Lambda55},of: 𝓟2352{pure}};
𝓟282{fantasyLandRegister}(𝓛12643{undefined},𝓟2554{EvalModule})
function 𝓟2555{_popNextBind} (𝓟2556{bFirst}: [OOV]any,𝓟2557{bRest}: [OOV]any): (𝓟2558: [OOV]any)
{
 if (𝓟2556{bFirst})
 {
 return 𝓟2558 = 𝓟2556{bFirst}
 }
 if (𝓛12592{AmpersandAmpersandToken}(𝓟2557{bRest},𝓛12595{GreaterThanToken}(𝓟2557{bRest}.length,𝓛8745{Number})))
 {
 return 𝓟2558 = 𝓟2557{bRest}.pop()
 }
 return 𝓟2558 = 𝓛12643{undefined}
}
function 𝓟2559{evalRunLoop} (𝓟2560{start}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2437{Eval})): (𝓟2561: [OOV]any)
{
 let 𝓟2562{current}: (𝓟[ty]1309{Scheduler} ≠ 𝓟[ty]2437{Eval}) = 𝓟2560{start};
 let 𝓟2563{bFirst}: [OOV]any = 𝓛12643{undefined};
 let 𝓟2564{bRest}: [OOV]any = 𝓛12643{undefined};
 while (𝓛8744{Boolean})
 {
 𝓛12577{$Switch}(𝓟2562{current}._tag)
 𝓛12634{$Case}(𝓛8743{String})
 const 𝓟2565{now}: [miss]𝓟[ty]2477{Now} = 𝓟2562{current} as 𝓟[ty]2477{Now};
 const 𝓟2566{bind}: [miss]𝓛[ty]8696{Function} = 𝓟2555{_popNextBind}(𝓟2563{bFirst},𝓟2564{bRest});
 if (𝓛12569{ExclamationToken}(𝓟2566{bind}))
 {
 return 𝓟2561 = 𝓟2565{now}.value
 }
 𝓟2563{bFirst} ⟵ 𝓛12643{undefined};
 𝓟2562{current} ⟵ 𝓟2566{bind}(𝓟2565{now}.value);
 𝓛12634{$Case}(𝓛8743{String})
 𝓛12634{$Case}(𝓛8743{String})
 𝓟2562{current} ⟵ 𝓟2472{CONSTRUCTOR}(𝓟2562{current}.get());
 𝓛12634{$Case}(𝓛8743{String})
 𝓟2562{current} ⟵ 𝓟2562{current} as 𝓟[ty]2516{Suspend}.thunk();
 𝓛12634{$Case}(𝓛8743{String})
 if (𝓟2563{bFirst})
 {
 if (𝓛12569{ExclamationToken}(𝓟2564{bRest}))
 {
 𝓟2564{bRest} ⟵ 𝓛8757{Array}();
 }
 𝓟2564{bRest}.push(𝓟2563{bFirst})
 }
 const 𝓟2567{fm}: [miss]𝓟[ty]2528{FlatMap} = 𝓟2562{current} as 𝓟[ty]2528{FlatMap};
 𝓟2563{bFirst} ⟵ 𝓟2567{fm}.f;
 𝓟2562{current} ⟵ 𝓟2567{fm}.source;
 }
}
function 𝓟2568{evalSequence} (𝓟2569{list}: [OOV]any): (𝓟2570: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2437{Eval}))
{
 function 𝓟2571{$Lambda58} (): (𝓟2572: [OOV]𝓟[ty]910{IteratorLike})
 {
 return 𝓟2572 = 𝓟914{iteratorOf}(𝓟2569{list})
 }
 function 𝓟2573{$Lambda59} (𝓟2574{cursor}): (𝓟2575: [miss]𝓟[ty]2437{Eval})
 {
 return 𝓟2575 = 𝓟2576{evalSequenceLoop}(𝓛8757{Array}(),𝓟2574{cursor})
 }
 return 𝓟2570 = 𝓟2349{of}(𝓟2571{$Lambda58}).flatMap(𝓟2573{$Lambda59})
}
function 𝓟2576{evalSequenceLoop} (𝓟2577{acc}: 𝓛[ty]8670{Array},𝓟2578{cursor}: [OOV]𝓟[ty]910{IteratorLike}): (𝓟2579: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2437{Eval}))
{
 while (𝓛8744{Boolean})
 {
 const 𝓟2580{elem}: [miss]𝓛[ty]8642{Object} = 𝓟2578{cursor}.next();
 const 𝓟2581{isDone}: [miss]𝓛[ty]8666{Boolean} = 𝓟2580{elem}.done;
 if (𝓟2580{elem}.value)
 {
 const 𝓟2582{io}: (𝓟[ty]1982{IOAlways} ≠ 𝓟[ty]2437{Eval}) = 𝓟2580{elem}.value;
 function 𝓟2583{$Lambda60} (𝓟2584{a}): (𝓟2585: [miss]𝓟[ty]2437{Eval})
 {
 𝓟2577{acc}.push(𝓟2584{a})
 if (𝓟2581{isDone})
 {
 return 𝓟2585 = 𝓟2352{pure}(𝓟2577{acc})
 }
 return 𝓟2585 = 𝓟2576{evalSequenceLoop}(𝓟2577{acc},𝓟2578{cursor})
 }
 return 𝓟2579 = 𝓟2582{io}.flatMap(𝓟2583{$Lambda60})
 }
 else
 {
 if (𝓟2581{isDone})
 {
 return 𝓟2579 = 𝓟2352{pure}(𝓟2577{acc})
 }
 }
 }
}

Module: packages/funfix-core/src/index

Module: test-common/index

Module: packages/funfix-exec/src/future

type 𝓟[ty]2586{IPromiseLike} = {then: (((any)->any),((𝓟[ty]3170{Throwable})->any))->𝓟[ty]2586{IPromiseLike}}
type 𝓛[ty]2{<UNKNOWN>} = 𝓛[ty]2{<UNKNOWN>}
const 𝓟2588{_Class}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future});
function 𝓟2589{CONSTRUCTOR} (): (𝓟[ty]2729{Future})
{
 const 𝓟[ty]2729{Future};
 const 𝓟[ty]2729{Future};
}
function 𝓟2593{of} (𝓟2594{thunk}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟2595{ec}: (𝓟[ty]2729{Future} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2596: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2729{Future}))
{
 const 𝓟2597{ref}: [miss]𝓟[ty]2977{FutureMaker} = 𝓟2969{empty}(𝓟2595{ec});
 function 𝓟2598{$Lambda150} (): (𝓟2599: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟2599 = 𝓟2597{ref}.tryComplete(𝓟656{of}(𝓟2594{thunk}))
 }
 𝓟2595{ec}.executeAsync(𝓟2598{$Lambda150})
 return 𝓟2596 = 𝓟2597{ref}.future()
}
function 𝓟2600{pure} (𝓟2601{a}: [OOV]any,𝓟2602{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2603: (𝓟[ty]1966{IOOnce} ≠ 𝓟[ty]2729{Future}))
{
 return 𝓟2603 = 𝓟2844{CONSTRUCTOR}(𝓟803{Success}(𝓟2601{a}),𝓟2602{ec})
}
function 𝓟2604{raise} (𝓟2605{e}: [OOV]𝓟[ty]3170{Throwable},𝓟2606{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2607: (𝓟[ty]2850{PureFuture} ≠ 𝓟[ty]2729{Future}))
{
 return 𝓟2607 = 𝓟2844{CONSTRUCTOR}(𝓟814{Failure}(𝓟2605{e}),𝓟2606{ec})
}
function 𝓟2608{create} (𝓟2609{register}: 𝓛[ty]8696{Function},𝓟2610{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2611: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}))
{
 const 𝓟2612{ref}: [miss]𝓟[ty]2977{FutureMaker} = 𝓟2969{empty}(𝓟2610{ec});
 {
 const 𝓟2613{cRef} = 𝓟2609{register}(𝓟2612{ref}.complete);
 return 𝓟2611 = 𝓟2612{ref}.future(𝓛12546{BarBarToken}(𝓟2613{cRef},𝓛12643{undefined}))
 }
}
function 𝓟2614{unit} (𝓟2615{ec}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2616: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]2729{Future}))
{
 const 𝓟2617{ecAny} = 𝓟2615{ec} as any;
 let 𝓟2618{ref} = 𝓛12592{AmpersandAmpersandToken}(𝓟2617{ecAny}.access(𝓛8743{String}),𝓟2617{ecAny}.access(𝓛8743{String}).access(𝓛8743{String}));
 if (𝓛12569{ExclamationToken}(𝓟2618{ref}))
 {
 𝓟2618{ref} ⟵ 𝓟2844{CONSTRUCTOR}(𝓟803{Success}(𝓛12643{undefined}),𝓟2615{ec});
 𝓟2617{ecAny}.access(𝓛8743{String}) ⟵ 𝓛12546{BarBarToken}(𝓟2617{ecAny}.access(𝓛8743{String}),{});
 𝓟2617{ecAny}.access(𝓛8743{String}).access(𝓛8743{String}) ⟵ 𝓟2618{ref};
 }
 return 𝓟2616 = 𝓟2618{ref}
}
function 𝓟2619{delayedTick} (𝓟2620{delay}: [OOV]any,𝓟2621{ec}: (𝓟[ty]1779{IO} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2622: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}))
{
 function 𝓟2623{$Lambda151} (𝓟2624{cb}): (𝓟2625: [OOV]𝓟[ty]1{ICancelable})
 {
 function 𝓟2626{$Lambda152} (): (𝓟2627: [miss]𝓛[ty]10033{Void})
 {
 return 𝓟2627 = 𝓟2624{cb}(𝓟803{Success}(𝓛12643{undefined}))
 }
 return 𝓟2625 = 𝓟2621{ec}.scheduleOnce(𝓟2620{delay},𝓟2626{$Lambda152})
 }
 return 𝓟2622 = 𝓟2608{create}(𝓟2623{$Lambda151},𝓟2621{ec})
}
function 𝓟2628{tailRecM} (𝓟2629{a}: [OOV]any,𝓟2630{f}: 𝓛[ty]8696{Function},𝓟2631{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2632: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}))
{
 function 𝓟2633{$Lambda153} (𝓟2634{r}): (𝓟2635: [miss]𝓟[ty]2729{Future})
 {
 if (𝓟2634{r}.isRight())
 {
 return 𝓟2635 = 𝓟2600{pure}(𝓟2634{r}.get(),𝓟2631{ec})
 }
 return 𝓟2635 = 𝓟2628{tailRecM}(𝓟2634{r}.swap().get(),𝓟2630{f},𝓟2631{ec})
 }
 return 𝓟2632 = 𝓟2630{f}(𝓟2629{a}).flatMap(𝓟2633{$Lambda153})
}
function 𝓟2636{fromPromise} (𝓟2637{ref}: [OOV]𝓟[ty]2586{IPromiseLike},𝓟2638{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2639: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}))
{
 if (𝓛1{<UNKNOWN>}(𝓟2637{ref},𝓛12643{undefined}))
 {
 return 𝓟2639 = 𝓟2637{ref} as 𝓟[ty]2729{Future}.withScheduler(𝓟2638{ec})
 }
 else
 {
 function 𝓟2640{$Lambda154} (𝓟2641{cb}): (𝓟2642: [miss]𝓛[ty]10033{Void})
 {
 function 𝓟2643{$Lambda155} (𝓟2644{value}): (𝓟2645: [miss]𝓛[ty]10033{Void})
 {
 return 𝓟2645 = 𝓟2641{cb}(𝓟803{Success}(𝓟2644{value}))
 }
 function 𝓟2646{$Lambda156} (𝓟2647{err}): (𝓟2648: [miss]𝓛[ty]10033{Void})
 {
 return 𝓟2648 = 𝓟2641{cb}(𝓟814{Failure}(𝓟2647{err}))
 }
 𝓟2637{ref}.then(𝓟2643{$Lambda155},𝓟2646{$Lambda156})
 }
 return 𝓟2639 = 𝓟2608{create}(𝓟2640{$Lambda154},𝓟2638{ec})
 }
}
function 𝓟2649{fromTry} (𝓟2650{value}: (𝓛[ty]10051{String} ≠ 𝓟[ty]715{Try}),𝓟2651{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2652: (𝓟[ty]2477{Now} ≠ 𝓟[ty]2729{Future}))
{
 return 𝓟2652 = 𝓟2844{CONSTRUCTOR}(𝓟2650{value},𝓟2651{ec})
}
function 𝓟2653{firstCompletedOf} (𝓟2654{list}: [OOV]any,𝓟2655{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2656: (𝓛[ty]8654{Promise} ≠ 𝓟[ty]2729{Future}))
{
 return 𝓟2656 = 𝓟3063{futureFirstCompletedOf}(𝓟2654{list},𝓟2655{ec})
}
function 𝓟2657{traverse} (𝓟2658{list}: [OOV]any,𝓟2659{parallelism}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8655{Number}),𝓟2660{ec}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2661: 𝓛[ty]8696{Function})
{
 function 𝓟2662{$Lambda157} (𝓟2663{f}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function})): (𝓟2664: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2664 = 𝓟3080{futureTraverse}(𝓟2658{list},𝓟2663{f},𝓟2659{parallelism},𝓟2660{ec})
 }
 return 𝓟2661 = 𝓟2662{$Lambda157}
}
function 𝓟2665{sequence} (𝓟2666{list}: [OOV]any,𝓟2667{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2668: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}))
{
 return 𝓟2668 = 𝓟3043{futureSequence}(𝓟2666{list},𝓟2667{ec})
}
function 𝓟2669{map2} (𝓟2670{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2671{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2672{f}: 𝓛[ty]8696{Function},𝓟2673{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2674: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2729{Future}))
{
 const 𝓟2675{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}) = 𝓟2665{sequence}(𝓛8757{Array}(𝓟2670{fa1},𝓟2671{fa2}) as 𝓛[ty]8670{Array},𝓟2673{ec});
 function 𝓟2676{$Lambda158} (𝓟2677{lst}): (𝓟2678: [OOV]any)
 {
 return 𝓟2678 = 𝓟2672{f}(𝓟2677{lst}.access(𝓛8745{Number}),𝓟2677{lst}.access(𝓛8745{Number}))
 }
 return 𝓟2674 = 𝓟2675{fl}.map(𝓟2676{$Lambda158})
}
function 𝓟2679{map3} (𝓟2680{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2681{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2682{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2683{f}: 𝓛[ty]8696{Function},𝓟2684{ec}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2685: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2729{Future}))
{
 const 𝓟2686{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}) = 𝓟2665{sequence}(𝓛8757{Array}(𝓟2680{fa1},𝓟2681{fa2},𝓟2682{fa3}) as 𝓛[ty]8670{Array},𝓟2684{ec});
 function 𝓟2687{$Lambda159} (𝓟2688{lst}): (𝓟2689: [OOV]any)
 {
 return 𝓟2689 = 𝓟2683{f}(𝓟2688{lst}.access(𝓛8745{Number}),𝓟2688{lst}.access(𝓛8745{Number}),𝓟2688{lst}.access(𝓛8745{Number}))
 }
 return 𝓟2685 = 𝓟2686{fl}.map(𝓟2687{$Lambda159})
}
function 𝓟2690{map4} (𝓟2691{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2692{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2693{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2694{fa4}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2695{f}: 𝓛[ty]8696{Function},𝓟2696{ec}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2697: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2729{Future}))
{
 const 𝓟2698{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}) = 𝓟2665{sequence}(𝓛8757{Array}(𝓟2691{fa1},𝓟2692{fa2},𝓟2693{fa3},𝓟2694{fa4}) as 𝓛[ty]8670{Array},𝓟2696{ec});
 function 𝓟2699{$Lambda160} (𝓟2700{lst}): (𝓟2701: [OOV]any)
 {
 return 𝓟2701 = 𝓟2695{f}(𝓟2700{lst}.access(𝓛8745{Number}),𝓟2700{lst}.access(𝓛8745{Number}),𝓟2700{lst}.access(𝓛8745{Number}),𝓟2700{lst}.access(𝓛8745{Number}))
 }
 return 𝓟2697 = 𝓟2698{fl}.map(𝓟2699{$Lambda160})
}
function 𝓟2702{map5} (𝓟2703{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2704{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2705{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2706{fa4}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2707{fa5}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]2729{Future}),𝓟2708{f}: 𝓛[ty]8696{Function},𝓟2709{ec}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2710: (𝓟[ty]2938{AsyncFuture} ≠ 𝓟[ty]2729{Future}))
{
 const 𝓟2711{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}) = 𝓟2665{sequence}(𝓛8757{Array}(𝓟2703{fa1},𝓟2704{fa2},𝓟2705{fa3},𝓟2706{fa4},𝓟2707{fa5}) as 𝓛[ty]8670{Array},𝓟2709{ec});
 function 𝓟2712{$Lambda161} (𝓟2713{lst}): (𝓟2714: [OOV]any)
 {
 return 𝓟2714 = 𝓟2708{f}(𝓟2713{lst}.access(𝓛8745{Number}),𝓟2713{lst}.access(𝓛8745{Number}),𝓟2713{lst}.access(𝓛8745{Number}),𝓟2713{lst}.access(𝓛8745{Number}),𝓟2713{lst}.access(𝓛8745{Number}))
 }
 return 𝓟2710 = 𝓟2711{fl}.map(𝓟2712{$Lambda161})
}
function 𝓟2715{map6} (𝓟2716{fa1}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2717{fa2}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2718{fa3}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2719{fa4}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2729{Future}),𝓟2720{fa5}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]2729{Future}),𝓟2721{fa6}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]2729{Future}),𝓟2722{f}: 𝓛[ty]8696{Function},𝓟2723{ec}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2724: (𝓟[ty]2938{AsyncFuture} ≠ 𝓟[ty]2729{Future}))
{
 const 𝓟2725{fl}: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}) = 𝓟2665{sequence}(𝓛8757{Array}(𝓟2716{fa1},𝓟2717{fa2},𝓟2718{fa3},𝓟2719{fa4},𝓟2720{fa5},𝓟2721{fa6}) as 𝓛[ty]8670{Array},𝓟2723{ec});
 function 𝓟2726{$Lambda162} (𝓟2727{lst}): (𝓟2728: [OOV]any)
 {
 return 𝓟2728 = 𝓟2722{f}(𝓟2727{lst}.access(𝓛8745{Number}),𝓟2727{lst}.access(𝓛8745{Number}),𝓟2727{lst}.access(𝓛8745{Number}),𝓟2727{lst}.access(𝓛8745{Number}),𝓟2727{lst}.access(𝓛8745{Number}),𝓟2727{lst}.access(𝓛8745{Number}))
 }
 return 𝓟2724 = 𝓟2725{fl}.map(𝓟2726{$Lambda162})
}
class 𝓟[ty]2729{Future} extends 𝓛[ty]2{<UNKNOWN>}{
 𝓟2731{_scheduler}: (𝓟[ty]2014{IOMemoize} ≠ 𝓟[ty]1309{Scheduler});
 𝓟2732{_cancelable}: [OOV]𝓟[ty]1{ICancelable};
 𝓟2733{_URI}: 𝓛[ty]10051{String};
 𝓟2734{_A}: [OOV]any;
 function 𝓟2785{recoverWith} (𝓟2786{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟2787: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}))
 {
 return 𝓟2787 = 𝓟[ty]2729{Future}.transformWith(𝓟2786{f},𝓟2600{pure})
 }
 function 𝓟2740{cancel} (): (𝓟2741: 𝓛[ty]10033{Void})
 {
 }
 function 𝓟2779{map} (𝓟2780{f}: 𝓛[ty]8696{Function}): (𝓟2781: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}))
 {
 function 𝓟2782{$Lambda137} (𝓟2783{a}): (𝓟2784: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2784 = 𝓟2600{pure}(𝓟2780{f}(𝓟2783{a}),𝓟[ty]2729{Future}._scheduler)
 }
 return 𝓟2781 = 𝓟[ty]2729{Future}.transformWith(𝓟2604{raise},𝓟2782{$Lambda137})
 }
 function 𝓟2817{delayResult} (𝓟2818{delay}: [OOV]any): (𝓟2819: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}))
 {
 function 𝓟2820{$Lambda144} (𝓟2821{err}): (𝓟2822: [miss]𝓟[ty]2729{Future})
 {
 function 𝓟2823{$Lambda145} (): (𝓟2824: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2824 = 𝓟2604{raise}(𝓟2821{err},𝓟[ty]2729{Future}._scheduler)
 }
 return 𝓟2822 = 𝓟2619{delayedTick}(𝓟2818{delay},𝓟[ty]2729{Future}._scheduler).flatMap(𝓟2823{$Lambda145})
 }
 function 𝓟2825{$Lambda146} (𝓟2826{a}): (𝓟2827: [miss]𝓟[ty]2729{Future})
 {
 function 𝓟2828{$Lambda147} (): (𝓟2829: [OOV]any)
 {
 return 𝓟2829 = 𝓟2826{a}
 }
 return 𝓟2827 = 𝓟2619{delayedTick}(𝓟2818{delay},𝓟[ty]2729{Future}._scheduler).map(𝓟2828{$Lambda147})
 }
 return 𝓟2819 = 𝓟[ty]2729{Future}.transformWith(𝓟2820{$Lambda144},𝓟2825{$Lambda146})
 }
 function 𝓟2767{ap} (𝓟2768{ff}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future})): (𝓟2769: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}))
 {
 function 𝓟2770{$Lambda135} (𝓟2771{f}): (𝓟2772: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2772 = 𝓟[ty]2729{Future}.map(𝓟2771{f})
 }
 return 𝓟2769 = 𝓟2768{ff}.flatMap(𝓟2770{$Lambda135})
 }
 function 𝓟2773{forEach} (𝓟2774{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟2775: 𝓛[ty]10033{Void})
 {
 function 𝓟2776{$Lambda136} (𝓟2777{r}): (𝓟2778: [OOV]any)
 {
 return 𝓟2778 = 𝓟2777{r}.forEach(𝓟2774{f})
 }
 𝓟[ty]2729{Future}.onComplete(𝓟2776{$Lambda136})
 }
 function 𝓟2788{recover} (𝓟2789{f}: 𝓛[ty]8696{Function}): (𝓟2790: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}))
 {
 function 𝓟2791{$Lambda138} (𝓟2792{e}): (𝓟2793: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2793 = 𝓟2600{pure}(𝓟2789{f}(𝓟2792{e}),𝓟[ty]2729{Future}._scheduler)
 }
 function 𝓟2794{$Lambda139} (𝓟2795{a}): (𝓟2796: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2796 = 𝓟2600{pure}(𝓟2795{a},𝓟[ty]2729{Future}._scheduler)
 }
 return 𝓟2790 = 𝓟[ty]2729{Future}.transformWith(𝓟2791{$Lambda138},𝓟2794{$Lambda139})
 }
 function 𝓟2808{toPromise} (): (𝓟2809: 𝓛[ty]8654{Promise})
 {
 function 𝓟2810{$Lambda142} (𝓟2811{resolve},𝓟2812{reject}): (𝓟2813: [miss]𝓛[ty]10033{Void})
 {
 function 𝓟2814{$Lambda143} (𝓟2815{_}): (𝓟2816: [OOV]any)
 {
 return 𝓟2816 = 𝓟2815{_}.fold(𝓟2812{reject},𝓟2811{resolve})
 }
 𝓟[ty]2729{Future}.onComplete(𝓟2814{$Lambda143})
 }
 return 𝓟2809 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟2810{$Lambda142})
 }
 function 𝓟2836{timeoutTo} (𝓟2837{after}: [OOV]any,𝓟2838{fallback}: 𝓛[ty]8696{Function}): (𝓟2839: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2729{Future}))
 {
 function 𝓟2840{$Lambda149} (): (𝓟2841: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2841 = 𝓟2838{fallback}()
 }
 const 𝓟2842{other}: [miss]𝓟[ty]2729{Future} = 𝓟2619{delayedTick}(𝓟2837{after},𝓟[ty]2729{Future}._scheduler).flatMap(𝓟2840{$Lambda149});
 const 𝓟2843{lst}: 𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓟[ty]2729{Future},𝓟2842{other});
 return 𝓟2839 = 𝓟2653{firstCompletedOf}(𝓟2843{lst},𝓟[ty]2729{Future}._scheduler)
 }
 function 𝓟2761{flatMap} (𝓟2762{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟2763: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}))
 {
 return 𝓟2763 = 𝓟[ty]2729{Future}.transformWith(𝓟2604{raise},𝓟2762{f})
 }
 function 𝓟2797{then} (𝓟2798{onFulfilled}: [OOV]any,𝓟2799{onRejected}: [OOV]any): (𝓟2800: (𝓟[ty]715{Try} ≠ 𝓟[ty]2729{Future}))
 {
 if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟2798{onFulfilled}),𝓛12569{ExclamationToken}(𝓟2799{onRejected})))
 {
 return 𝓟2800 = 𝓟[ty]2729{Future} as any
 }
 const 𝓟2801{ec}: [miss]𝓟[ty]1309{Scheduler} = 𝓟[ty]2729{Future}._scheduler;
 function 𝓟2802{$Lambda140} (𝓟2803{e}): (𝓟2804: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2804 = 𝓟2604{raise}(𝓟2803{e},𝓟2801{ec})
 }
 function 𝓟2805{$Lambda141} (𝓟2806{a}): (𝓟2807: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2807 = 𝓟2600{pure}(𝓟2806{a},𝓟2801{ec})
 }
 return 𝓟2800 = 𝓟[ty]2729{Future}.transformWith(𝓟3019{promiseThen}(𝓟2799{onRejected},𝓟2802{$Lambda140},𝓟2801{ec}),𝓟3019{promiseThen}(𝓟2798{onFulfilled},𝓟2805{$Lambda141},𝓟2801{ec})) as any
 }
 function 𝓟2742{withScheduler} (𝓟2743{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2744: (𝓛[ty]10033{Void} ≠ 𝓟[ty]2729{Future}))
 {
 }
 function 𝓟2759{attempt} (): (𝓟2760: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}))
 {
 return 𝓟2760 = 𝓟[ty]2729{Future}.transform(𝓟433{Left},𝓟444{Right})
 }
 function 𝓟2745{transformWith} (𝓟2746{failure}: (𝓟[ty]811{TFailure} ≠ 𝓛[ty]8696{Function}),𝓟2747{success}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8696{Function})): (𝓟2748: (𝓛[ty]10033{Void} ≠ 𝓟[ty]2729{Future}))
 {
 }
 function 𝓟2737{onComplete} (𝓟2738{f}: (𝓟[ty]2308{DynamicRef} ≠ 𝓛[ty]8696{Function})): (𝓟2739: 𝓛[ty]10033{Void})
 {
 }
 function 𝓟2830{timeout} (𝓟2831{after}: [OOV]any): (𝓟2832: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}))
 {
 const 𝓟2833{fb}: [miss]𝓟[ty]2729{Future} = 𝓟2604{raise}(𝓟3233{CONSTRUCTOR}(𝓟1221{of}(𝓟2831{after}).toString()),𝓟[ty]2729{Future}._scheduler);
 function 𝓟2834{$Lambda148} (): (𝓟2835: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2835 = 𝓟2833{fb}
 }
 return 𝓟2832 = 𝓟[ty]2729{Future}.timeoutTo(𝓟2831{after},𝓟2834{$Lambda148})
 }
 function 𝓟2764{chain} (𝓟2765{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟2766: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}))
 {
 return 𝓟2766 = 𝓟[ty]2729{Future}.flatMap(𝓟2765{f})
 }
 function 𝓟2749{transform} (𝓟2750{failure}: 𝓛[ty]8696{Function},𝓟2751{success}: 𝓛[ty]8696{Function}): (𝓟2752: (𝓟[ty]533{Option} ≠ 𝓟[ty]2729{Future}))
 {
 function 𝓟2753{$Lambda133} (𝓟2754{e}): (𝓟2755: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2755 = 𝓟2600{pure}(𝓟2750{failure}(𝓟2754{e}),𝓟[ty]2729{Future}._scheduler)
 }
 function 𝓟2756{$Lambda134} (𝓟2757{a}): (𝓟2758: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2758 = 𝓟2600{pure}(𝓟2751{success}(𝓟2757{a}),𝓟[ty]2729{Future}._scheduler)
 }
 return 𝓟2752 = 𝓟[ty]2729{Future}.transformWith(𝓟2753{$Lambda133},𝓟2756{$Lambda134})
 }
 function 𝓟2735{value} (): (𝓟2736: (𝓛[ty]10033{Void} ≠ 𝓟[ty]533{Option}))
 {
 }
}
function 𝓟2844{CONSTRUCTOR} (𝓟2845{_value}: (𝓛[ty]10051{String} ≠ 𝓟[ty]715{Try}),𝓟2846{_scheduler}: 𝓟[ty]1309{Scheduler}): (𝓟[ty]2850{PureFuture})
{
 const 𝓟[ty]2850{PureFuture};
 const 𝓟[ty]2850{PureFuture};
 𝓟[ty]2850{PureFuture}()
}
class 𝓟[ty]2850{PureFuture} extends 𝓟[ty]2729{Future}{
 function 𝓟2852{cancel} (): (𝓟2853: 𝓛[ty]10033{Void})
 {
 }
 function 𝓟2868{toPromise} (): (𝓟2869: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8654{Promise}))
 {
 function 𝓟2870{$Lambda164} (𝓟2871{e}): (𝓟2872: [miss]𝓛[ty]8654{Promise})
 {
 return 𝓟2872 = 𝓛1062{Promise}.reject(𝓟2871{e})
 }
 function 𝓟2873{$Lambda165} (𝓟2874{a}): (𝓟2875: [miss]𝓛[ty]8654{Promise})
 {
 return 𝓟2875 = 𝓛1062{Promise}.resolve(𝓟2874{a})
 }
 return 𝓟2869 = 𝓟[ty]2850{PureFuture}._value.fold(𝓟2870{$Lambda164},𝓟2873{$Lambda165})
 }
 function 𝓟2856{withScheduler} (𝓟2857{ec}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2858: (𝓟[ty]2850{PureFuture} ≠ 𝓟[ty]2729{Future}))
 {
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]2850{PureFuture}._scheduler,𝓟2857{ec}))
 {
 return 𝓟2858 = 𝓟[ty]2850{PureFuture}
 }
 return 𝓟2858 = 𝓟2844{CONSTRUCTOR}(𝓟[ty]2850{PureFuture}._value,𝓟2857{ec})
 }
 function 𝓟2864{transformWith} (𝓟2865{failure}: (𝓟[ty]811{TFailure} ≠ 𝓛[ty]8696{Function}),𝓟2866{success}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8696{Function})): (𝓟2867: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2729{Future}))
 {
 return 𝓟2867 = 𝓟3004{genericTransformWith}(𝓟[ty]2850{PureFuture},𝓟2865{failure},𝓟2866{success},𝓟[ty]2850{PureFuture}._scheduler)
 }
 function 𝓟2859{onComplete} (𝓟2860{f}: 𝓛[ty]8696{Function}): (𝓟2861: 𝓛[ty]10033{Void})
 {
 function 𝓟2862{$Lambda163} (): (𝓟2863: [miss]𝓛[ty]10033{Void})
 {
 return 𝓟2863 = 𝓟2860{f}(𝓟[ty]2850{PureFuture}._value)
 }
 𝓟[ty]2850{PureFuture}._scheduler.executeBatched(𝓟2862{$Lambda163})
 }
 function 𝓟2854{value} (): (𝓟2855: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}))
 {
 return 𝓟2855 = 𝓟614{Some}(𝓟[ty]2850{PureFuture}._value)
 }
}
function 𝓟2876{CONSTRUCTOR} (): (𝓟[ty]2880{AsyncFutureState})
{
 const 𝓟[ty]2880{AsyncFutureState};
 const 𝓟[ty]2880{AsyncFutureState};
 𝓟[ty]2880{AsyncFutureState}.id ⟵ 𝓛12643{undefined};
 𝓟[ty]2880{AsyncFutureState}.ref ⟵ 𝓛12643{undefined};
}
class 𝓟[ty]2880{AsyncFutureState}{
 𝓟2882{id}: [OOV]any;
 𝓟2883{ref}: [OOV]any;
 function 𝓟2899{chainTo} (𝓟2900{target}: (𝓟[ty]2029{IOContext} ≠ 𝓟[ty]2880{AsyncFutureState}),𝓟2901{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2902: 𝓛[ty]10033{Void})
 {
 𝓛12577{$Switch}(𝓟[ty]2880{AsyncFutureState}.id)
 𝓛12634{$Case}(𝓛12643{undefined})
 const 𝓟2903{xs}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]2880{AsyncFutureState}.ref as any;
 𝓟[ty]2880{AsyncFutureState}.id ⟵ 𝓛8743{String};
 𝓟[ty]2880{AsyncFutureState}.ref ⟵ 𝓟2900{target}.compressedRoot();
 if (𝓛12592{AmpersandAmpersandToken}(𝓟2903{xs},𝓛12595{GreaterThanToken}(𝓟2903{xs}.length,𝓛8745{Number})))
 {
 {
 let 𝓟2904{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓛1{<UNKNOWN>}(𝓟2904{i},𝓟2903{xs}.length))
 {
 𝓟2900{target}.onComplete(𝓟2903{xs}.access(𝓟2904{i}),𝓟2901{ec})
 𝓛12556{POST_PlusPlusToken}(𝓟2904{i})
 }
 }
 }
 𝓛12634{$Case}(𝓛8743{String})
 𝓟[ty]2880{AsyncFutureState}.compressedRoot().chainTo(𝓟2900{target}.compressedRoot(),𝓟2901{ec})
 𝓛12634{$Case}(𝓛8743{String})
 𝓟2900{target}.tryComplete(𝓟[ty]2880{AsyncFutureState}.ref as 𝓟[ty]715{Try},𝓟2901{ec})
 }
 function 𝓟2905{onComplete} (𝓟2906{f}: 𝓛[ty]8696{Function},𝓟2907{ec}: (𝓟[ty]2729{Future} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2908: 𝓛[ty]10033{Void})
 {
 𝓛12577{$Switch}(𝓟[ty]2880{AsyncFutureState}.id)
 𝓛12634{$Case}(𝓛12643{undefined})
 if (𝓛12569{ExclamationToken}(𝓟[ty]2880{AsyncFutureState}.ref))
 {
 𝓟[ty]2880{AsyncFutureState}.ref ⟵ 𝓛8757{Array}();
 }
 𝓟[ty]2880{AsyncFutureState}.ref as 𝓛[ty]8670{Array}.push(𝓟2906{f})
 𝓛12634{$Case}(𝓛8743{String})
 function 𝓟2909{$Lambda167} (): (𝓟2910: [miss]𝓛[ty]10033{Void})
 {
 return 𝓟2910 = 𝓟2906{f}(𝓟[ty]2880{AsyncFutureState}.ref as 𝓟[ty]715{Try})
 }
 𝓟2907{ec}.executeBatched(𝓟2909{$Lambda167})
 𝓛12634{$Case}(𝓛8743{String})
 𝓟[ty]2880{AsyncFutureState}.ref as 𝓟[ty]2880{AsyncFutureState}.onComplete(𝓟2906{f},𝓟2907{ec})
 }
 function 𝓟2884{compressedRoot} (): (𝓟2885: (𝓟[ty]2029{IOContext} ≠ 𝓟[ty]2880{AsyncFutureState}))
 {
 let 𝓟2886{cursor}: 𝓟[ty]2880{AsyncFutureState} = 𝓟[ty]2880{AsyncFutureState};
 while (𝓛12559{EqualsEqualsEqualsToken}(𝓟2886{cursor}.id,𝓛8743{String}))
 {
 𝓟2886{cursor} ⟵ 𝓟2886{cursor}.ref as 𝓟[ty]2880{AsyncFutureState};
 𝓟[ty]2880{AsyncFutureState}.ref ⟵ 𝓟2886{cursor};
 }
 return 𝓟2885 = 𝓟2886{cursor}
 }
 function 𝓟2887{value} (): (𝓟2888: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}))
 {
 𝓛12577{$Switch}(𝓟[ty]2880{AsyncFutureState}.id)
 𝓛12634{$Case}(𝓛12643{undefined})
 return 𝓟2888 = 𝓟624{None}
 𝓛12634{$Case}(𝓛8743{String})
 return 𝓟2888 = 𝓟614{Some}(𝓟[ty]2880{AsyncFutureState}.ref as 𝓟[ty]715{Try})
 𝓛12634{$Case}(𝓛8743{String})
 return 𝓟2888 = 𝓟[ty]2880{AsyncFutureState}.compressedRoot().value()
 }
 function 𝓟2889{tryComplete} (𝓟2890{r}: (𝓟[ty]1982{IOAlways} ≠ 𝓟[ty]715{Try}),𝓟2891{ec}: (𝓟[ty]2729{Future} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2892: 𝓛[ty]8666{Boolean})
 {
 𝓛12577{$Switch}(𝓟[ty]2880{AsyncFutureState}.id)
 𝓛12634{$Case}(𝓛12643{undefined})
 const 𝓟2893{xs}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]2880{AsyncFutureState}.ref as any;
 𝓟[ty]2880{AsyncFutureState}.ref ⟵ 𝓟2890{r};
 𝓟[ty]2880{AsyncFutureState}.id ⟵ 𝓛8743{String};
 if (𝓟2893{xs})
 {
 {
 let 𝓟2894{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓛1{<UNKNOWN>}(𝓟2894{i},𝓟2893{xs}.length))
 {
 function 𝓟2895{$Lambda166} (): (𝓟2896: [miss]𝓛[ty]10033{Void})
 {
 return 𝓟2896 = 𝓟2893{xs}.access(𝓟2894{i})(𝓟2890{r})
 }
 𝓟2891{ec}.executeBatched(𝓟2895{$Lambda166})
 𝓛12556{POST_PlusPlusToken}(𝓟2894{i})
 }
 }
 }
 return 𝓟2892 = 𝓛8744{Boolean}
 𝓛12634{$Case}(𝓛8743{String})
 return 𝓟2892 = 𝓛8744{Boolean}
 𝓛12634{$Case}(𝓛8743{String})
 const 𝓟2897{ref}: [miss]𝓟[ty]2880{AsyncFutureState} = 𝓟[ty]2880{AsyncFutureState}.ref as 𝓟[ty]2880{AsyncFutureState}.compressedRoot();
 const 𝓟2898{result}: [miss]𝓛[ty]8666{Boolean} = 𝓟2897{ref}.tryComplete(𝓟2890{r},𝓟2891{ec});
 𝓟[ty]2880{AsyncFutureState}.id ⟵ 𝓛8743{String};
 𝓟[ty]2880{AsyncFutureState}.ref ⟵ (𝓟2898{result} ? 𝓟2890{r} : 𝓟2897{ref}.value().get();
 return 𝓟2892 = 𝓟2898{result}
 }
}
function 𝓟2911{$Lambda168} (𝓟2912{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟2913{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future})): (𝓟2914: [miss]𝓟[ty]2729{Future})
{
 return 𝓟2914 = 𝓟2913{fa}.map(𝓟2912{f})
}
function 𝓟2915{$Lambda169} (𝓟2916{ff}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]2729{Future}),𝓟2917{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future})): (𝓟2918: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}))
{
 return 𝓟2918 = 𝓟2917{fa}.ap(𝓟2916{ff})
}
function 𝓟2919{$Lambda170} (𝓟2920{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟2921{fa}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future})): (𝓟2922: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}))
{
 return 𝓟2922 = 𝓟2921{fa}.flatMap(𝓟2920{f})
}
function 𝓟2923{$Lambda171} (𝓟2924{f}: 𝓛[ty]8696{Function},𝓟2925{a}: [OOV]any): (𝓟2926: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}))
{
 function 𝓟2927{$Lambda172} (𝓟2928{a}): (𝓟2929: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟2929 = 𝓟2924{f}(𝓟314{left} as any,𝓟317{right} as any,𝓟2928{a})
 }
 return 𝓟2926 = 𝓟2628{tailRecM}(𝓟2925{a},𝓟2927{$Lambda172})
}
const 𝓟2930{FutureModule}: [OOV]𝓛[ty]2{<UNKNOWN>} = {map: 𝓟2911{$Lambda168},ap: 𝓟2915{$Lambda169},chainRec: 𝓟2923{$Lambda171},chain: 𝓟2919{$Lambda170},of: 𝓟2600{pure}};
𝓟282{fantasyLandRegister}(𝓛12643{undefined},𝓟2930{FutureModule})
function 𝓟2931{CONSTRUCTOR} (𝓟2932{state}: (𝓟[ty]2029{IOContext} ≠ 𝓟[ty]2880{AsyncFutureState}),𝓟2933{cRef}: [OOV]any,𝓟2934{ec}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]1309{Scheduler})): (𝓟[ty]2938{AsyncFuture})
{
 const 𝓟[ty]2938{AsyncFuture};
 const 𝓟[ty]2938{AsyncFuture};
 𝓟[ty]2938{AsyncFuture}()
 𝓟[ty]2938{AsyncFuture}.access(𝓛8743{String}) ⟵ 𝓟2932{state};
 𝓟[ty]2938{AsyncFuture}._scheduler ⟵ 𝓟2934{ec};
 if (𝓟2933{cRef})
 {
 𝓟[ty]2938{AsyncFuture}._cancelable ⟵ 𝓟2933{cRef};
 }
}
class 𝓟[ty]2938{AsyncFuture} extends 𝓟[ty]2729{Future}{
 𝓟2940{$ComputedPropertyName}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2880{AsyncFutureState});
 𝓟2941{_scheduler}: (𝓟[ty]2014{IOMemoize} ≠ 𝓟[ty]1309{Scheduler});
 𝓟2942{_cancelable}: [OOV]𝓟[ty]1{ICancelable};
 function 𝓟2948{cancel} (): (𝓟2949: 𝓛[ty]10033{Void})
 {
 if (𝓟[ty]2938{AsyncFuture}._cancelable)
 {
 {
 𝓟[ty]2938{AsyncFuture}._cancelable.cancel()
 }
 {
 𝓛12622{$Delete}(𝓟[ty]2938{AsyncFuture}._cancelable)
 }
 }
 }
 function 𝓟2950{withScheduler} (𝓟2951{ec}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2952: (𝓟[ty]2938{AsyncFuture} ≠ 𝓟[ty]2729{Future}))
 {
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]2938{AsyncFuture}._scheduler,𝓟2951{ec}))
 {
 return 𝓟2952 = 𝓟[ty]2938{AsyncFuture}
 }
 return 𝓟2952 = 𝓟2931{CONSTRUCTOR}(𝓟[ty]2938{AsyncFuture}.access(𝓛8743{String}),𝓟[ty]2938{AsyncFuture}._cancelable,𝓟2951{ec})
 }
 function 𝓟2953{transformWith} (𝓟2954{failure}: (𝓟[ty]811{TFailure} ≠ 𝓛[ty]8696{Function}),𝓟2955{success}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8696{Function})): (𝓟2956: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2729{Future}))
 {
 return 𝓟2956 = 𝓟3004{genericTransformWith}(𝓟[ty]2938{AsyncFuture},𝓟2954{failure},𝓟2955{success},𝓟[ty]2938{AsyncFuture}._scheduler,𝓟[ty]2938{AsyncFuture}._cancelable)
 }
 function 𝓟2945{onComplete} (𝓟2946{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟2947: (𝓟[ty]533{Option} ≠ 𝓛[ty]10033{Void}))
 {
 return 𝓟2947 = 𝓟[ty]2938{AsyncFuture}.access(𝓛8743{String}).onComplete(𝓟2946{f},𝓟[ty]2938{AsyncFuture}._scheduler)
 }
 function 𝓟2943{value} (): (𝓟2944: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]533{Option}))
 {
 return 𝓟2944 = 𝓟[ty]2938{AsyncFuture}.access(𝓛8743{String}).value()
 }
}
function 𝓟2957{CONSTRUCTOR} (𝓟2958{state}: (𝓟[ty]2029{IOContext} ≠ 𝓟[ty]2880{AsyncFutureState}),𝓟2959{ec}: (𝓟[ty]928{TimeUnit} ≠ 𝓟[ty]1309{Scheduler})): (𝓟[ty]2977{FutureMaker})
{
 const 𝓟[ty]2977{FutureMaker};
 const 𝓟[ty]2977{FutureMaker};
 function 𝓟2963{$Lambda173} (𝓟2964{r}): (𝓟2965: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟2965 = 𝓟[ty]2977{FutureMaker}.access(𝓛8743{String}).tryComplete(𝓟2964{r},𝓟[ty]2977{FutureMaker}._scheduler)
 }
 function 𝓟2966{$Lambda174} (𝓟2967{r}): (𝓟2968: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12569{ExclamationToken}(𝓟[ty]2977{FutureMaker}.tryComplete(𝓟2967{r})))
 {
 𝓟3209{CONSTRUCTOR}(𝓛8743{String})
 }
 }
 𝓟[ty]2977{FutureMaker}.tryComplete ⟵ 𝓟2963{$Lambda173};
 𝓟[ty]2977{FutureMaker}.complete ⟵ 𝓟2966{$Lambda174};
 𝓟[ty]2977{FutureMaker}.access(𝓛8743{String}) ⟵ 𝓟2958{state};
 𝓟[ty]2977{FutureMaker}._scheduler ⟵ 𝓟2959{ec};
}
function 𝓟2969{empty} (𝓟2970{ec}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2971: 𝓟[ty]2977{FutureMaker})
{
 return 𝓟2971 = 𝓟2957{CONSTRUCTOR}(𝓟2876{CONSTRUCTOR}(),𝓟2970{ec})
}
function 𝓟2972{completed} (𝓟2973{value}: (𝓟[ty]1982{IOAlways} ≠ 𝓟[ty]715{Try}),𝓟2974{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟2975: 𝓟[ty]2977{FutureMaker})
{
 const 𝓟2976{state}: [miss]𝓟[ty]2880{AsyncFutureState} = 𝓟2876{CONSTRUCTOR}();
 𝓟2976{state}.id ⟵ 𝓛8743{String};
 𝓟2976{state}.ref ⟵ 𝓟2973{value};
 return 𝓟2975 = 𝓟2957{CONSTRUCTOR}(𝓟2976{state},𝓟2974{ec})
}
class 𝓟[ty]2977{FutureMaker}{
 𝓟2979{$ComputedPropertyName}: (𝓛[ty]10051{String} ≠ 𝓟[ty]2880{AsyncFutureState});
 𝓟2980{_scheduler}: (𝓟[ty]2014{IOMemoize} ≠ 𝓟[ty]1309{Scheduler});
 𝓟2981{tryComplete}: 𝓛[ty]8696{Function};
 𝓟2982{complete}: 𝓛[ty]8696{Function};
 function 𝓟2992{failure} (𝓟2993{error}: [OOV]𝓟[ty]3170{Throwable}): (𝓟2994: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]10033{Void}))
 {
 return 𝓟2994 = 𝓟[ty]2977{FutureMaker}.complete(𝓟814{Failure}(𝓟2993{error}))
 }
 function 𝓟2986{success} (𝓟2987{value}: [OOV]any): (𝓟2988: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]10033{Void}))
 {
 return 𝓟2988 = 𝓟[ty]2977{FutureMaker}.complete(𝓟803{Success}(𝓟2987{value}))
 }
 function 𝓟2998{future} (𝓟2999{cancelable}: [OOV]𝓟[ty]1{ICancelable}): (𝓟3000: (𝓟[ty]1309{Scheduler} ≠ 𝓟[ty]2729{Future}))
 {
 𝓛12577{$Switch}(𝓟[ty]2977{FutureMaker}.access(𝓛8743{String}).id)
 𝓛12634{$Case}(𝓛8743{String})
 return 𝓟3000 = 𝓟2844{CONSTRUCTOR}(𝓟[ty]2977{FutureMaker}.access(𝓛8743{String}).ref as 𝓟[ty]715{Try},𝓟[ty]2977{FutureMaker}._scheduler)
 return 𝓟3000 = 𝓟2931{CONSTRUCTOR}(𝓟[ty]2977{FutureMaker}.access(𝓛8743{String}),𝓟2999{cancelable},𝓟[ty]2977{FutureMaker}._scheduler)
 }
 function 𝓟2989{tryFailure} (𝓟2990{error}: [OOV]𝓟[ty]3170{Throwable}): (𝓟2991: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8666{Boolean}))
 {
 return 𝓟2991 = 𝓟[ty]2977{FutureMaker}.tryComplete(𝓟814{Failure}(𝓟2990{error}))
 }
 function 𝓟2995{chainTo} (𝓟2996{target}: (𝓛[ty]8642{Object} ≠ 𝓟[ty]2977{FutureMaker})): (𝓟2997: 𝓛[ty]10033{Void})
 {
 𝓟[ty]2977{FutureMaker}.access(𝓛8743{String}).chainTo(𝓟2996{target}.access(𝓛8743{String}),𝓟[ty]2977{FutureMaker}._scheduler)
 }
 function 𝓟3001{withScheduler} (𝓟3002{ec}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1309{Scheduler})): (𝓟3003: 𝓟[ty]2977{FutureMaker})
 {
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]2977{FutureMaker}._scheduler,𝓟3002{ec}))
 {
 return 𝓟3003 = 𝓟[ty]2977{FutureMaker}
 }
 return 𝓟3003 = 𝓟2957{CONSTRUCTOR}(𝓟[ty]2977{FutureMaker}.access(𝓛8743{String}),𝓟3002{ec})
 }
 function 𝓟2983{trySuccess} (𝓟2984{value}: [OOV]any): (𝓟2985: (𝓟[ty]1779{IO} ≠ 𝓛[ty]8666{Boolean}))
 {
 return 𝓟2985 = 𝓟[ty]2977{FutureMaker}.tryComplete(𝓟803{Success}(𝓟2984{value}))
 }
}
function 𝓟3004{genericTransformWith} (𝓟3005{self}: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}),𝓟3006{failure}: (𝓟[ty]811{TFailure} ≠ 𝓛[ty]8696{Function}),𝓟3007{success}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8696{Function}),𝓟3008{scheduler}: (𝓟[ty]1457{TestScheduler} ≠ 𝓟[ty]1309{Scheduler}),𝓟3009{cancelable}: [OOV]𝓟[ty]1{ICancelable}): (𝓟3010: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2729{Future}))
{
 const 𝓟3011{defer}: [miss]𝓟[ty]2977{FutureMaker} = 𝓟2969{empty}(𝓟3008{scheduler});
 const 𝓟3012{cRef}: [miss]𝓟[ty]238{ChainedCancelable} = 𝓟231{CONSTRUCTOR}(𝓟3009{cancelable});
 function 𝓟3013{$Lambda175} (𝓟3014{tryA}): (𝓟3015: [miss]𝓛[ty]10033{Void})
 {
 let 𝓟3016{fb}: (𝓟[ty]1966{IOOnce} ≠ 𝓟[ty]2729{Future});
 {
 𝓟3016{fb} ⟵ 𝓟3014{tryA}.fold(𝓟3006{failure},𝓟3007{success});
 }
 if (𝓟3016{fb}.value().isEmpty())
 {
 const 𝓟3017{fbb} = 𝓟3016{fb} as any;
 const 𝓟3018{cNext} = 𝓟3017{fbb}._cancelable;
 if (𝓛12592{AmpersandAmpersandToken}(𝓟3018{cNext},𝓛1{<UNKNOWN>}(𝓟3018{cNext},𝓛12643{undefined})))
 {
 𝓟3018{cNext}.chainTo(𝓟3012{cRef})
 }
 else
 {
 if (𝓛12592{AmpersandAmpersandToken}(𝓟3018{cNext},𝓛12569{ExclamationToken}(𝓛1{<UNKNOWN>}(𝓟3018{cNext},𝓛12643{undefined}))))
 {
 𝓟3012{cRef}.update(𝓟3018{cNext})
 }
 }
 }
 else
 {
 𝓟3012{cRef}.clear()
 }
 if (𝓛1{<UNKNOWN>}(𝓟3016{fb},𝓛12643{undefined}))
 {
 𝓟3016{fb}.access(𝓛8743{String}).chainTo(𝓟3011{defer}.access(𝓛8743{String}),𝓟3008{scheduler})
 }
 else
 {
 𝓟3016{fb}.onComplete(𝓟3011{defer}.tryComplete)
 }
 }
 𝓟3005{self}.onComplete(𝓟3013{$Lambda175})
 return 𝓟3010 = 𝓟3011{defer}.future(𝓟3012{cRef})
}
function 𝓟3019{promiseThen} (𝓟3020{f}: [OOV]any,𝓟3021{alt}: 𝓛[ty]8696{Function},𝓟3022{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟3023: 𝓛[ty]8696{Function})
{
 function 𝓟3024{$Lambda176} (𝓟3025{value}): (𝓟3026: [OOV]any)
 {
 if (𝓛12612{ExclamationEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟3020{f}),𝓛8743{String}))
 {
 return 𝓟3026 = 𝓟3021{alt}(𝓟3025{value})
 }
 const 𝓟3027{fb} = 𝓟3020{f}(𝓟3025{value});
 if (𝓛12569{ExclamationToken}(𝓟3027{fb}))
 {
 return 𝓟3026 = 𝓟2600{pure}(𝓟3025{value},𝓟3022{ec})
 }
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟3027{fb} as any.then),𝓛8743{String}))
 {
 return 𝓟3026 = 𝓟2636{fromPromise}(𝓟3027{fb} as 𝓟[ty]2586{IPromiseLike},𝓟3022{ec})
 }
 else
 {
 return 𝓟3026 = 𝓟2600{pure}(𝓟3027{fb} as 𝓛[ty]2{<UNKNOWN>},𝓟3022{ec})
 }
 }
 return 𝓟3023 = 𝓟3024{$Lambda176}
}
function 𝓟3028{futureCancelAll} (𝓟3029{list}: 𝓛[ty]8670{Array},𝓟3030{ec}: (𝓟[ty]2729{Future} ≠ 𝓟[ty]1309{Scheduler}),𝓟3031{skip}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟3032: 𝓛[ty]10033{Void})
{
 const 𝓟3033{errors}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
 {
 let 𝓟3034{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓛1{<UNKNOWN>}(𝓟3034{i},𝓟3029{list}.length))
 {
 {
 if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟3034{i},𝓟3031{skip}))
 {
 𝓟3029{list}.access(𝓟3034{i}).cancel()
 }
 }
 𝓛12556{POST_PlusPlusToken}(𝓟3034{i})
 }
 }
 if (𝓛12595{GreaterThanToken}(𝓟3033{errors}.length,𝓛8745{Number}))
 {
 {
 const 𝓟3035{e} = 𝓛12589{$ArrayAccess}(𝓟3033{errors});
 while (𝓛8744{Boolean})
 {
 𝓟3030{ec}.reportFailure(𝓟3035{e})
 }
 }
 }
}
function 𝓟3036{futureIterableToArray} (𝓟3037{values}: [OOV]any,𝓟3038{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler})): (𝓟3039: 𝓛[ty]8670{Array})
{
 if (𝓛12569{ExclamationToken}(𝓟3037{values}))
 {
 return 𝓟3039 = 𝓛8757{Array}()
 }
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓛8741{Object}.prototype.toString.call(𝓟3037{values}),𝓛8743{String}))
 {
 return 𝓟3039 = 𝓟3037{values} as 𝓛[ty]8670{Array}
 }
 const 𝓟3040{arr}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
 {
 const 𝓟3041{cursor}: [OOV]𝓛[ty]5961{Iterator} = 𝓟3037{values}.access(𝓛10031{Symbol}.iterator)();
 while (𝓛8744{Boolean})
 {
 const 𝓟3042{item}: [OOV]𝓛[ty]5964{IteratorResult} = 𝓟3041{cursor}.next();
 if (𝓟3042{item}.value)
 {
 𝓟3040{arr}.push(𝓟3042{item}.value)
 }
 if (𝓟3042{item}.done)
 {
 }
 }
 return 𝓟3039 = 𝓟3040{arr}
 }
}
function 𝓟3043{futureSequence} (𝓟3044{values}: [OOV]any,𝓟3045{ec}: (𝓟[ty]2729{Future} ≠ 𝓟[ty]1309{Scheduler})): (𝓟3046: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}))
{
 function 𝓟3047{$Lambda177} (𝓟3048{cb}): (𝓟3049: [OOV]any)
 {
 {
 const 𝓟3050{futures}: [miss]𝓛[ty]8670{Array} = 𝓟3036{futureIterableToArray}(𝓟3044{values},𝓟3045{ec});
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟3050{futures}.length,𝓛8745{Number}))
 {
 return 𝓟3049 = 𝓟3048{cb}(𝓟803{Success}(𝓛8757{Array}()))
 }
 function 𝓟3051{$Lambda178} (): (𝓟3052: [miss]𝓛[ty]10033{Void})
 {
 return 𝓟3052 = 𝓟3028{futureCancelAll}(𝓟3050{futures},𝓟3045{ec})
 }
 const 𝓟3053{cRef}: [miss]𝓟[ty]21{Cancelable} = 𝓟8{of}(𝓟3051{$Lambda178});
 let 𝓟3054{isDone}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
 let 𝓟3055{finishedCount}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 let 𝓟3056{finalArray}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
 {
 let 𝓟3057{index}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓛1{<UNKNOWN>}(𝓟3057{index},𝓟3050{futures}.length))
 {
 {
 const 𝓟3058{fi}: [miss]𝓛[ty]8655{Number} = 𝓟3057{index};
 const 𝓟3059{fa}: [miss]𝓟[ty]2729{Future} = 𝓟3050{futures}.access(𝓟3057{index});
 function 𝓟3060{$Lambda179} (𝓟3061{result}): (𝓟3062: [miss]𝓛[ty]10033{Void})
 {
 𝓛12564{FirstCompoundAssignment}(𝓟3055{finishedCount},𝓛8745{Number})
 if (𝓟3061{result}.isSuccess())
 {
 if (𝓛12569{ExclamationToken}(𝓟3054{isDone}))
 {
 𝓟3056{finalArray}.access(𝓟3058{fi}) ⟵ 𝓟3061{result}.get();
 𝓟3054{isDone} ⟵ 𝓛12559{EqualsEqualsEqualsToken}(𝓟3055{finishedCount},𝓟3050{futures}.length);
 if (𝓟3054{isDone})
 {
 𝓟3048{cb}(𝓟803{Success}(𝓟3056{finalArray}))
 }
 }
 }
 else
 {
 if (𝓛12569{ExclamationToken}(𝓟3054{isDone}))
 {
 𝓟3054{isDone} ⟵ 𝓛8744{Boolean};
 𝓟3053{cRef}.cancel()
 𝓟3048{cb}(𝓟3061{result} as any)
 }
 else
 {
 𝓟3045{ec}.reportFailure(𝓟3061{result}.failed().get())
 }
 }
 }
 𝓟3059{fa}.onComplete(𝓟3060{$Lambda179})
 }
 𝓛12556{POST_PlusPlusToken}(𝓟3057{index})
 }
 }
 return 𝓟3049 = 𝓟3053{cRef}
 }
 }
 return 𝓟3046 = 𝓟2608{create}(𝓟3047{$Lambda177},𝓟3045{ec})
}
function 𝓟3063{futureFirstCompletedOf} (𝓟3064{iterable}: [OOV]any,𝓟3065{ec}: (𝓟[ty]1779{IO} ≠ 𝓟[ty]1309{Scheduler})): (𝓟3066: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}))
{
 function 𝓟3067{$Lambda180} (𝓟3068{cb}): (𝓟3069: [OOV]any)
 {
 {
 const 𝓟3070{futures}: [miss]𝓛[ty]8670{Array} = 𝓟3036{futureIterableToArray}(𝓟3064{iterable},𝓟3065{ec});
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟3070{futures}.length,𝓛8745{Number}))
 {
 return 𝓟3069 = 𝓟3068{cb}(𝓟814{Failure}(𝓟3217{CONSTRUCTOR}(𝓛8743{String})))
 }
 let 𝓟3071{isDone}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
 {
 let 𝓟3072{index}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓛1{<UNKNOWN>}(𝓟3072{index},𝓟3070{futures}.length))
 {
 {
 const 𝓟3073{fi}: [miss]𝓛[ty]8655{Number} = 𝓟3072{index};
 const 𝓟3074{fa}: [miss]𝓟[ty]2729{Future} = 𝓟3070{futures}.access(𝓟3072{index});
 function 𝓟3075{$Lambda181} (𝓟3076{result}): (𝓟3077: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12569{ExclamationToken}(𝓟3071{isDone}))
 {
 𝓟3071{isDone} ⟵ 𝓛8744{Boolean};
 𝓟3028{futureCancelAll}(𝓟3070{futures},𝓟3065{ec},𝓟3073{fi})
 𝓟3068{cb}(𝓟3076{result})
 }
 else
 {
 if (𝓟3076{result}.isFailure())
 {
 𝓟3065{ec}.reportFailure(𝓟3076{result}.failed().get())
 }
 }
 }
 𝓟3074{fa}.onComplete(𝓟3075{$Lambda181})
 }
 𝓛12556{POST_PlusPlusToken}(𝓟3072{index})
 }
 }
 function 𝓟3078{$Lambda182} (): (𝓟3079: [miss]𝓛[ty]10033{Void})
 {
 return 𝓟3079 = 𝓟3028{futureCancelAll}(𝓟3070{futures},𝓟3065{ec})
 }
 return 𝓟3069 = 𝓟8{of}(𝓟3078{$Lambda182})
 }
 }
 return 𝓟3066 = 𝓟2608{create}(𝓟3067{$Lambda180},𝓟3065{ec})
}
function 𝓟3080{futureTraverse} (𝓟3081{list}: [OOV]any,𝓟3082{f}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function}),𝓟3083{parallelism}: 𝓛[ty]8655{Number},𝓟3084{ec}: (𝓟[ty]2308{DynamicRef} ≠ 𝓟[ty]1309{Scheduler})): (𝓟3085: (𝓟[ty]1779{IO} ≠ 𝓟[ty]2729{Future}))
{
 if (𝓛12582{LessThanEqualsToken}(𝓟3083{parallelism},𝓛8745{Number}))
 {
 𝓟3217{CONSTRUCTOR}(𝓛8743{String})
 }
 function 𝓟3086{$Lambda183} (): (𝓟3087: [miss]𝓛[ty]8670{Array})
 {
 return 𝓟3087 = 𝓟2238{iterableToArray}(𝓟3081{list})
 }
 function 𝓟3088{$Lambda184} (𝓟3089{values}): (𝓟3090: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟3090 = 𝓟3091{futureTraverseLoop}(𝓟3089{values},𝓟3082{f},𝓟3083{parallelism},𝓟3084{ec},𝓛8745{Number},𝓛8757{Array}())
 }
 return 𝓟3085 = 𝓟2593{of}(𝓟3086{$Lambda183},𝓟3084{ec}).flatMap(𝓟3088{$Lambda184})
}
function 𝓟3091{futureTraverseLoop} (𝓟3092{list}: 𝓛[ty]8670{Array},𝓟3093{f}: 𝓛[ty]8696{Function},𝓟3094{parallelism}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟3095{ec}: (𝓛[ty]10051{String} ≠ 𝓟[ty]1309{Scheduler}),𝓟3096{index}: 𝓛[ty]8655{Number},𝓟3097{result}: 𝓛[ty]8670{Array}): (𝓟3098: (𝓟[ty]2977{FutureMaker} ≠ 𝓟[ty]2729{Future}))
{
 if (𝓛12596{GreaterThanEqualsToken}(𝓟3096{index},𝓟3092{list}.length))
 {
 return 𝓟3098 = 𝓟2600{pure}(𝓟3097{result},𝓟3095{ec})
 }
 let 𝓟3099{batch}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
 let 𝓟3100{length}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 {
 while (𝓛12592{AmpersandAmpersandToken}(𝓛1{<UNKNOWN>}(𝓟3096{index},𝓟3092{list}.length),𝓛1{<UNKNOWN>}(𝓟3100{length},𝓟3094{parallelism})))
 {
 𝓟3099{batch}.push(𝓟3093{f}(𝓟3092{list}.access(𝓛12556{POST_PlusPlusToken}(𝓟3096{index}))))
 𝓛12564{FirstCompoundAssignment}(𝓟3100{length},𝓛8745{Number})
 }
 function 𝓟3101{$Lambda185} (𝓟3102{b}): (𝓟3103: [miss]𝓛[ty]10033{Void})
 {
 {
 let 𝓟3104{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓛1{<UNKNOWN>}(𝓟3104{i},𝓟3102{b}.length))
 {
 𝓟3097{result}.push(𝓟3102{b}.access(𝓟3104{i}))
 𝓛12556{POST_PlusPlusToken}(𝓟3104{i})
 }
 }
 }
 const 𝓟3105{fa}: [miss]𝓟[ty]2729{Future} = 𝓟2665{sequence}(𝓟3099{batch},𝓟3095{ec}).map(𝓟3101{$Lambda185});
 if (𝓛12596{GreaterThanEqualsToken}(𝓟3096{index},𝓟3092{list}.length))
 {
 function 𝓟3106{$Lambda186} (): (𝓟3107: [miss]𝓛[ty]8670{Array})
 {
 return 𝓟3107 = 𝓟3097{result}
 }
 return 𝓟3098 = 𝓟3105{fa}.map(𝓟3106{$Lambda186})
 }
 else
 {
 function 𝓟3108{$Lambda187} (): (𝓟3109: [miss]𝓟[ty]2729{Future})
 {
 return 𝓟3109 = 𝓟3091{futureTraverseLoop}(𝓟3092{list},𝓟3093{f},𝓟3094{parallelism},𝓟3095{ec},𝓟3096{index},𝓟3097{result})
 }
 return 𝓟3098 = 𝓟3105{fa}.flatMap(𝓟3108{$Lambda187})
 }
 }
}

Module: packages/funfix-core/src/std

type 𝓟[ty]3110{IEquals} = {equals: (any)->𝓛[ty]8666{Boolean}, hashCode: ()->𝓛[ty]8655{Number}}
function 𝓟3111{isValueObject} (𝓟3112{ref}: [OOV]any): (𝓟3113: 𝓛[ty]8666{Boolean})
{
 return 𝓟3113 = 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12592{AmpersandAmpersandToken}(𝓟3112{ref},𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟3112{ref}.equals),𝓛8743{String})),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟3112{ref}.hashCode),𝓛8743{String}))))
}
function 𝓟3114{is} (𝓟3115{lh}: [OOV]any,𝓟3116{rh}: [OOV]any): (𝓟3117: 𝓛[ty]8666{Boolean})
{
 if (𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟3115{lh},𝓟3116{rh}),𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟3115{lh},𝓟3115{lh}),𝓛12612{ExclamationEqualsEqualsToken}(𝓟3116{rh},𝓟3116{rh}))))
 {
 return 𝓟3117 = 𝓛8744{Boolean}
 }
 if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟3115{lh}),𝓛12569{ExclamationToken}(𝓟3116{rh})))
 {
 return 𝓟3117 = 𝓛8744{Boolean}
 }
 if (𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟3115{lh}.valueOf),𝓛8743{String}),𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟3116{rh}.valueOf),𝓛8743{String})))
 {
 const 𝓟3118{lh2}: [miss]𝓛[ty]8642{Object} = 𝓟3115{lh}.valueOf();
 const 𝓟3119{rh2}: [miss]𝓛[ty]8642{Object} = 𝓟3116{rh}.valueOf();
 if (𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟3118{lh2},𝓟3119{rh2}),𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟3118{lh2},𝓟3118{lh2}),𝓛12612{ExclamationEqualsEqualsToken}(𝓟3119{rh2},𝓟3119{rh2}))))
 {
 return 𝓟3117 = 𝓛8744{Boolean}
 }
 if (𝓛12546{BarBarToken}(𝓛12569{ExclamationToken}(𝓟3118{lh2}),𝓛12569{ExclamationToken}(𝓟3119{rh2})))
 {
 return 𝓟3117 = 𝓛8744{Boolean}
 }
 }
 return 𝓟3117 = 𝓛12569{ExclamationToken}(𝓛12569{ExclamationToken}(𝓛12592{AmpersandAmpersandToken}(𝓟3111{isValueObject}(𝓟3115{lh}),𝓟3115{lh} as any.equals(𝓟3116{rh}))))
}
function 𝓟3120{equals} (𝓟3121{lh}: [OOV]any,𝓟3122{rh}: [OOV]any): (𝓟3123: (𝓟[ty]2977{FutureMaker} ≠ 𝓛[ty]8666{Boolean}))
{
 return 𝓟3123 = 𝓟3114{is}(𝓟3121{lh},𝓟3122{rh})
}
const 𝓟3124{universalSetoid}: [OOV]𝓛[ty]2{<UNKNOWN>} = {equals: 𝓟3120{equals}};
function 𝓟3125{hashCode} (𝓟3126{ref}: [OOV]any): (𝓟3127: 𝓛[ty]8655{Number})
{
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟3126{ref}),𝓛8743{String}))
 {
 return 𝓟3127 = 𝓛12608{AmpersandToken}(𝓟3126{ref},𝓟3126{ref})
 }
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟3126{ref}.valueOf),𝓛8743{String}))
 {
 const 𝓟3128{v} = 𝓟3126{ref}.valueOf();
 if (𝓛12612{ExclamationEqualsEqualsToken}(𝓟3128{v},𝓟3126{ref}))
 {
 return 𝓟3127 = 𝓟3125{hashCode}(𝓟3128{v})
 }
 }
 if (𝓟3111{isValueObject}(𝓟3126{ref}))
 {
 return 𝓟3127 = 𝓟3126{ref} as 𝓟[ty]3110{IEquals}.hashCode()
 }
 return 𝓟3127 = 𝓟3129{hashCodeOfString}(𝓛8743{String}(𝓟3126{ref}))
}
function 𝓟3129{hashCodeOfString} (𝓟3130{str}: 𝓛[ty]10051{String}): (𝓟3131: 𝓛[ty]8655{Number})
{
 let 𝓟3132{hash}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 if (𝓛12546{BarBarToken}(𝓛12599{EqualsEqualsToken}(𝓟3130{str},𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓟3130{str}.length,𝓛8745{Number})))
 {
 return 𝓟3131 = 𝓟3132{hash}
 }
 {
 let 𝓟3133{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓛1{<UNKNOWN>}(𝓟3133{i},𝓟3130{str}.length))
 {
 {
 const 𝓟3134{character}: [miss]𝓛[ty]8655{Number} = 𝓟3130{str}.charCodeAt(𝓟3133{i});
 𝓟3132{hash} ⟵ 𝓛12641{PlusToken}(𝓛12616{MinusToken}(𝓛12560{LessThanLessThanToken}(𝓟3132{hash},𝓛8745{Number}),𝓟3132{hash}),𝓟3134{character});
 𝓟3132{hash} ⟵ 𝓛12608{AmpersandToken}(𝓟3132{hash},𝓟3132{hash});
 }
 𝓛12556{POST_PlusPlusToken}(𝓟3133{i})
 }
 }
 return 𝓟3131 = 𝓟3132{hash}
}
function 𝓟3135{id} (𝓟3136{a}: [OOV]any): (𝓟3137: [OOV]any)
{
 return 𝓟3137 = 𝓟3136{a}
}
function 𝓟3138{applyMixins} (𝓟3139{derivedCtor}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8642{Object}),𝓟3140{baseCtors}: (𝓟[ty]928{TimeUnit} ≠ 𝓛[ty]8670{Array})): (𝓟3141: [miss]𝓛[ty]10033{Void})
{
 function 𝓟3142{$Lambda42} (𝓟3143{baseCtor}): (𝓟3144: [miss]𝓛[ty]10033{Void})
 {
 function 𝓟3145{$Lambda43} (𝓟3146{name}): (𝓟3147: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12569{ExclamationToken}(𝓟3139{derivedCtor}.prototype.access(𝓟3146{name})))
 {
 𝓟3139{derivedCtor}.prototype.access(𝓟3146{name}) ⟵ 𝓟3143{baseCtor}.prototype.access(𝓟3146{name});
 }
 }
 𝓛8741{Object}.getOwnPropertyNames(𝓟3143{baseCtor}.prototype).forEach(𝓟3145{$Lambda43})
 }
 𝓟3140{baseCtors}.forEach(𝓟3142{$Lambda42})
}

Module: test-common/setoid-tests

function 𝓟3148{setoidCheck} (𝓟3149{genA}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟3150{F}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟3151{lawsRef}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟3152: [miss]𝓛[ty]10033{Void})
{
 const 𝓟3153{laws} = 𝓛12546{BarBarToken}(𝓟3151{lawsRef},𝓟3257{SetoidLaws}.CONSTRUCTOR(𝓟3150{F}));
 function 𝓟3154{$Lambda14} (𝓟3155{p}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟3156: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟3156 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟3155{p}.lh,𝓟3155{p}.rh)
 }
 const 𝓟3157{eq}: [miss]𝓛[ty]8696{Function} = 𝓟3154{$Lambda14};
 function 𝓟3158{$Lambda15} (𝓟3159{x}): (𝓟3160: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟3160 = 𝓟3157{eq}(𝓟3153{laws}.reflexivity(𝓟3159{x}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟3149{genA},𝓟3158{$Lambda15})
 function 𝓟3161{$Lambda16} (𝓟3162{x},𝓟3163{y}): (𝓟3164: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟3164 = 𝓟3157{eq}(𝓟3153{laws}.symmetry(𝓟3162{x},𝓟3163{y}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟3149{genA},𝓟3149{genA},𝓟3161{$Lambda16})
 function 𝓟3165{$Lambda17} (𝓟3166{x},𝓟3167{y},𝓟3168{z}): (𝓟3169: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟3169 = 𝓟3157{eq}(𝓟3153{laws}.transitivity(𝓟3166{x},𝓟3167{y},𝓟3168{z}))
 }
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟3149{genA},𝓟3149{genA},𝓟3149{genA},𝓟3165{$Lambda17})
}

Module: packages/funfix-core/src/errors

type 𝓟[ty]3170{Throwable} = any
function 𝓟3171{CONSTRUCTOR} (𝓟3172{errors}: 𝓛[ty]8670{Array}): (𝓟[ty]3180{CompositeError})
{
 const 𝓟[ty]3180{CompositeError};
 const 𝓟[ty]3180{CompositeError};
 let 𝓟3176{reasons}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
 {
 const 𝓟3177{e}: [OOV]𝓟[ty]3170{Throwable} = 𝓛12589{$ArrayAccess}(𝓟3172{errors}.slice(𝓛8745{Number},𝓛8745{Number}));
 while (𝓛8744{Boolean})
 {
 let 𝓟3178{message}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
 if (𝓛1{<UNKNOWN>}(𝓟3177{e},𝓛8749{Error}))
 {
 𝓟3178{message} ⟵ 𝓛12607{$Template}(𝓟3177{e}.name,𝓟3177{e}.message);
 }
 else
 {
 𝓟3178{message} ⟵ 𝓛12607{$Template}(𝓟3177{e});
 }
 𝓛12564{FirstCompoundAssignment}(𝓟3176{reasons},𝓛12641{PlusToken}(𝓛8743{String},𝓟3178{message}))
 }
 }
 𝓟3176{reasons} ⟵ 𝓟3176{reasons}.slice(𝓛8745{Number});
 if (𝓛12595{GreaterThanToken}(𝓟3172{errors}.length,𝓛8745{Number}))
 {
 𝓟3176{reasons} ⟵ 𝓛12641{PlusToken}(𝓟3176{reasons},𝓛8743{String});
 }
 𝓟[ty]3180{CompositeError}(𝓟3176{reasons})
 𝓟[ty]3180{CompositeError}.name ⟵ 𝓛8743{String};
 𝓟[ty]3180{CompositeError}.errorsRef ⟵ 𝓟3172{errors};
 const 𝓟3179{self} = 𝓟[ty]3180{CompositeError} as any;
 𝓟3179{self}.constructor ⟵ 𝓛12643{undefined};
 𝓟3179{self}.__proto__ ⟵ 𝓛1{<UNKNOWN>};
}
class 𝓟[ty]3180{CompositeError} extends 𝓛[ty]10053{Error}{
 𝓟3182{errorsRef}: 𝓛[ty]8670{Array};
 function 𝓟3183{errors} (): (𝓟3184: 𝓛[ty]8670{Array})
 {
 return 𝓟3184 = 𝓟[ty]3180{CompositeError}.errorsRef.slice()
 }
}
function 𝓟3185{CONSTRUCTOR} (𝓟3186{message}: 𝓛[ty]10051{String}): (𝓟[ty]3191{DummyError})
{
 const 𝓟[ty]3191{DummyError};
 const 𝓟[ty]3191{DummyError};
 𝓟[ty]3191{DummyError}(𝓟3186{message})
 𝓟[ty]3191{DummyError}.name ⟵ 𝓛8743{String};
 const 𝓟3190{self} = 𝓟[ty]3191{DummyError} as any;
 𝓟3190{self}.constructor ⟵ 𝓛12643{undefined};
 𝓟3190{self}.__proto__ ⟵ 𝓛1{<UNKNOWN>};
}
class 𝓟[ty]3191{DummyError} extends 𝓛[ty]10053{Error}{
}
function 𝓟3193{CONSTRUCTOR} (𝓟3194{message}: 𝓛[ty]10051{String}): (𝓟[ty]3199{NoSuchElementError})
{
 const 𝓟[ty]3199{NoSuchElementError};
 const 𝓟[ty]3199{NoSuchElementError};
 𝓟[ty]3199{NoSuchElementError}(𝓟3194{message})
 𝓟[ty]3199{NoSuchElementError}.name ⟵ 𝓛8743{String};
 const 𝓟3198{self} = 𝓟[ty]3199{NoSuchElementError} as any;
 𝓟3198{self}.constructor ⟵ 𝓛12643{undefined};
 𝓟3198{self}.__proto__ ⟵ 𝓛1{<UNKNOWN>};
}
class 𝓟[ty]3199{NoSuchElementError} extends 𝓛[ty]10053{Error}{
}
function 𝓟3201{CONSTRUCTOR} (𝓟3202{message}: 𝓛[ty]10051{String}): (𝓟[ty]3207{IllegalInheritanceError})
{
 const 𝓟[ty]3207{IllegalInheritanceError};
 const 𝓟[ty]3207{IllegalInheritanceError};
 𝓟[ty]3207{IllegalInheritanceError}(𝓟3202{message})
 𝓟[ty]3207{IllegalInheritanceError}.name ⟵ 𝓛8743{String};
 const 𝓟3206{self} = 𝓟[ty]3207{IllegalInheritanceError} as any;
 𝓟3206{self}.constructor ⟵ 𝓛12643{undefined};
 𝓟3206{self}.__proto__ ⟵ 𝓛1{<UNKNOWN>};
}
class 𝓟[ty]3207{IllegalInheritanceError} extends 𝓛[ty]10053{Error}{
}
function 𝓟3209{CONSTRUCTOR} (𝓟3210{message}: 𝓛[ty]10051{String}): (𝓟[ty]3215{IllegalStateError})
{
 const 𝓟[ty]3215{IllegalStateError};
 const 𝓟[ty]3215{IllegalStateError};
 𝓟[ty]3215{IllegalStateError}(𝓟3210{message})
 𝓟[ty]3215{IllegalStateError}.name ⟵ 𝓛8743{String};
 const 𝓟3214{self} = 𝓟[ty]3215{IllegalStateError} as any;
 𝓟3214{self}.constructor ⟵ 𝓛12643{undefined};
 𝓟3214{self}.__proto__ ⟵ 𝓛1{<UNKNOWN>};
}
class 𝓟[ty]3215{IllegalStateError} extends 𝓛[ty]10053{Error}{
}
function 𝓟3217{CONSTRUCTOR} (𝓟3218{message}: 𝓛[ty]10051{String}): (𝓟[ty]3223{IllegalArgumentError})
{
 const 𝓟[ty]3223{IllegalArgumentError};
 const 𝓟[ty]3223{IllegalArgumentError};
 𝓟[ty]3223{IllegalArgumentError}(𝓟3218{message})
 𝓟[ty]3223{IllegalArgumentError}.name ⟵ 𝓛8743{String};
 const 𝓟3222{self} = 𝓟[ty]3223{IllegalArgumentError} as any;
 𝓟3222{self}.constructor ⟵ 𝓛12643{undefined};
 𝓟3222{self}.__proto__ ⟵ 𝓛1{<UNKNOWN>};
}
class 𝓟[ty]3223{IllegalArgumentError} extends 𝓛[ty]10053{Error}{
}
function 𝓟3225{CONSTRUCTOR} (𝓟3226{message}: 𝓛[ty]10051{String}): (𝓟[ty]3231{NotImplementedError})
{
 const 𝓟[ty]3231{NotImplementedError};
 const 𝓟[ty]3231{NotImplementedError};
 𝓟[ty]3231{NotImplementedError}(𝓟3226{message})
 𝓟[ty]3231{NotImplementedError}.name ⟵ 𝓛8743{String};
 const 𝓟3230{self} = 𝓟[ty]3231{NotImplementedError} as any;
 𝓟3230{self}.constructor ⟵ 𝓛12643{undefined};
 𝓟3230{self}.__proto__ ⟵ 𝓛1{<UNKNOWN>};
}
class 𝓟[ty]3231{NotImplementedError} extends 𝓛[ty]10053{Error}{
}
function 𝓟3233{CONSTRUCTOR} (𝓟3234{message}: 𝓛[ty]10051{String}): (𝓟[ty]3239{TimeoutError})
{
 const 𝓟[ty]3239{TimeoutError};
 const 𝓟[ty]3239{TimeoutError};
 𝓟[ty]3239{TimeoutError}(𝓟3234{message})
 𝓟[ty]3239{TimeoutError}.name ⟵ 𝓛8743{String};
 const 𝓟3238{self} = 𝓟[ty]3239{TimeoutError} as any;
 𝓟3238{self}.constructor ⟵ 𝓛12643{undefined};
 𝓟3238{self}.__proto__ ⟵ 𝓛1{<UNKNOWN>};
}
class 𝓟[ty]3239{TimeoutError} extends 𝓛[ty]10053{Error}{
}