LibAcc: 0.6379=37/58, ProjAcc: 1.0000=0/0, Missing: 92

Module: src/persistCache

function 𝓟1{$Lambda22} (𝓟2{options}: [OOV]𝓟[ty]692{ApolloPersistOptions}): (𝓟3: [miss]𝓛[ty]8654{Promise})
{
 const 𝓟4{persistor}: [OOV]𝓟[ty]228{CachePersistor} = 𝓟218{CONSTRUCTOR}(𝓟2{options});
 return 𝓟3 = 𝓟4{persistor}.restore()
}

Module: src/index

Module: src/Log

const 𝓟5{buffer}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
const 𝓟6{prefix}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
function 𝓟7{CONSTRUCTOR} (𝓟8{options}: [OOV]𝓟[ty]692{ApolloPersistOptions}): (𝓟[ty]13{Log})
{
 const 𝓟[ty]13{Log};
 const 𝓟[ty]13{Log};
 const 𝓟12{debug}: [miss]𝓛[ty]8666{Boolean} = 𝓟8{options}.debug;
 𝓟[ty]13{Log}.debug ⟵ 𝓟12{debug};
 𝓟[ty]13{Log}.lines ⟵ 𝓛8757{Array}();
}
class 𝓟[ty]13{Log}{
 𝓟15{debug}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8666{Boolean});
 𝓟16{lines}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array});
 function 𝓟37{warn} (𝓟38{message}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟39: 𝓛[ty]10033{Void})
 {
 𝓟[ty]13{Log}.write(𝓛8743{String},𝓟38{message})
 }
 function 𝓟22{tailLogs} (): (𝓟23: 𝓛[ty]10033{Void})
 {
 function 𝓟24{$Lambda13} (𝓟25{_}): (𝓟26: [miss]𝓛[ty]10033{Void})
 {
 }
 𝓟[ty]13{Log}.lines.forEach(𝓟24{$Lambda13})
 }
 function 𝓟34{info} (𝓟35{message}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟36: 𝓛[ty]10033{Void})
 {
 𝓟[ty]13{Log}.write(𝓛8743{String},𝓟35{message})
 }
 function 𝓟17{emit} (𝓟18{level}: [OOV]𝓛[ty]0{ANY},𝓟19{message}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟20: 𝓛[ty]10033{Void})
 {
 if (𝓟18{level}.InKeyword(𝓛12353{console}))
 {
 const 𝓟21{prefix}: [miss]𝓛[ty]10051{String} = 𝓟6{prefix};
 𝓛1{<UNKNOWN>}(𝓟18{level})(𝓟21{prefix},𝓛12551{$Spread}(𝓟19{message}))
 }
 }
 function 𝓟40{error} (𝓟41{message}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟42: 𝓛[ty]10033{Void})
 {
 𝓟[ty]13{Log}.write(𝓛8743{String},𝓟41{message})
 }
 function 𝓟27{getLogs} (): (𝓟28: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8670{Array}))
 {
 return 𝓟28 = 𝓟[ty]13{Log}.lines
 }
 function 𝓟29{write} (𝓟30{level}: [OOV]𝓛[ty]0{ANY},𝓟31{message}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟32: 𝓛[ty]10033{Void})
 {
 const 𝓟33{buffer}: [miss]𝓛[ty]8655{Number} = 𝓟5{buffer};
 𝓟[ty]13{Log}.lines ⟵ 𝓛8757{Array}(𝓛12551{$Spread}(𝓟[ty]13{Log}.lines.slice(𝓛8745{Number}.MinusToken(𝓟33{buffer}))),𝓛8757{Array}(𝓟30{level},𝓟31{message}));
 if (𝓟[ty]13{Log}.debug.BarBarToken(𝓟30{level}.ExclamationEqualsEqualsToken(𝓛8743{String})))
 {
 𝓟[ty]13{Log}.emit(𝓟30{level},𝓟31{message})
 }
 }
}

Module: src/__mocks__/simulate

function 𝓟43{$Async_$Lambda26} (𝓟44{_}): (𝓟45: [miss]𝓛[ty]8654{Promise})
{
}
const 𝓟46{simulateApp}: [miss]𝓛[ty]8696{Function} = 𝓛1{<UNKNOWN>};
function 𝓟47{$Async_$Lambda27} (𝓟48{_}): (𝓟49: [miss]𝓛[ty]8654{Promise})
{
}
const 𝓟50{simulateWrite}: [miss]𝓛[ty]8696{Function} = 𝓛1{<UNKNOWN>};

Module: src/onAppBackground

type 𝓟[ty]686{TriggerFunctionConfig} = {log: 𝓟[ty]13{Log}, cache: 𝓛[ty]2{<UNKNOWN>}}
function 𝓟52{$Lambda20} (𝓟53{_}: [OOV]𝓟[ty]686{TriggerFunctionConfig}): (𝓟54: [miss]𝓛[ty]8696{Function})
{
}

Module: src/Cache

function 𝓟55{CONSTRUCTOR} (𝓟56{options}: [OOV]𝓟[ty]692{ApolloPersistOptions}): (𝓟[ty]62{Cache})
{
 const 𝓟[ty]62{Cache};
 const 𝓟[ty]62{Cache};
 const 𝓟60{cache} = 𝓟56{options}.cache;
 const 𝓟61{serialize}: [miss]𝓛[ty]8666{Boolean} = 𝓟56{options}.serialize;
 𝓟[ty]62{Cache}.cache ⟵ 𝓟60{cache};
 𝓟[ty]62{Cache}.serialize ⟵ 𝓟61{serialize};
}
class 𝓟[ty]62{Cache}{
 𝓟64{cache}: [OOV]𝓛[ty]2{<UNKNOWN>};
 𝓟65{serialize}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8666{Boolean});
 function 𝓟66{extract} (): (𝓟67: [OOV]𝓛[ty]0{ANY})
 {
 let 𝓟68{data}: [OOV]𝓛[ty]0{ANY} = 𝓟[ty]62{Cache}.cache.extract() as 𝓛[ty]2{<UNKNOWN>};
 if (𝓟[ty]62{Cache}.serialize)
 {
 𝓟68{data} ⟵ 𝓛8756{JSON}.stringify(𝓟68{data}) as 𝓛[ty]10051{String};
 }
 return 𝓟67 = 𝓟68{data}
 }
 function 𝓟69{restore} (𝓟70{data}: [OOV]𝓛[ty]0{ANY}): (𝓟71: 𝓛[ty]10033{Void})
 {
 if (𝓟[ty]62{Cache}.serialize.AmpersandAmpersandToken(𝓛12550{$TypeOf}(𝓟70{data}).EqualsEqualsEqualsToken(𝓛8743{String})))
 {
 𝓟70{data} ⟵ 𝓛8756{JSON}.parse(𝓟70{data});
 }
 if (𝓟70{data}.ExclamationEqualsToken(𝓛12563{undefined}))
 {
 𝓟[ty]62{Cache}.cache.restore(𝓟70{data} as 𝓛[ty]2{<UNKNOWN>})
 }
 }
}

Module: src/Storage

function 𝓟72{CONSTRUCTOR} (𝓟73{options}: [OOV]𝓟[ty]692{ApolloPersistOptions}): (𝓟[ty]79{Storage})
{
 const 𝓟[ty]79{Storage};
 const 𝓟[ty]79{Storage};
 const 𝓟77{storage}: [OOV]𝓟[ty]690{PersistentStorage} = 𝓟73{options}.storage;
 const 𝓟78{key}: [miss]𝓛[ty]10051{String} = 𝓟73{options}.key;
 𝓟[ty]79{Storage}.storage ⟵ 𝓟77{storage};
 𝓟[ty]79{Storage}.key ⟵ 𝓟78{key};
}
class 𝓟[ty]79{Storage}{
 𝓟81{storage}: [OOV]𝓟[ty]690{PersistentStorage};
 𝓟82{key}: 𝓛[ty]10051{String};
 function 𝓟83{$Async_read} (): (𝓟84: (𝓛[ty]10051{String} ≠ 𝓛[ty]8654{Promise}))
 {
 return 𝓟84 = 𝓟[ty]79{Storage}.storage.getItem(𝓟[ty]79{Storage}.key)
 }
 function 𝓟85{$Async_write} (𝓟86{data}: [OOV]𝓛[ty]0{ANY}): (𝓟87: 𝓛[ty]8654{Promise})
 {
 𝓛12547{$Await}(𝓟[ty]79{Storage}.storage.setItem(𝓟[ty]79{Storage}.key,𝓟86{data}))
 }
 function 𝓟88{$Async_purge} (): (𝓟89: 𝓛[ty]8654{Promise})
 {
 𝓛12547{$Await}(𝓟[ty]79{Storage}.storage.removeItem(𝓟[ty]79{Storage}.key))
 }
 function 𝓟90{$Async_getSize} (): (𝓟91: (𝓛[ty]10051{String} ≠ 𝓛[ty]8654{Promise}))
 {
 const 𝓟92{data}: [OOV]𝓛[ty]0{ANY} = 𝓛12547{$Await}(𝓟[ty]79{Storage}.storage.getItem(𝓟[ty]79{Storage}.key));
 if (𝓟92{data}.EqualsEqualsToken(𝓛12563{undefined}))
 {
 return 𝓟91 = 𝓛8745{Number}
 }
 else
 {
 return 𝓟91 = (𝓛12550{$TypeOf}(𝓟92{data}).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟92{data}.length : 𝓛12563{undefined}
 }
 }
}

Module: src/Persistor

type 𝓟[ty]687{PersistorConfig} = {log: 𝓟[ty]13{Log}, cache: 𝓟[ty]62{Cache}, storage: 𝓟[ty]79{Storage}}
function 𝓟94{CONSTRUCTOR} (𝓟95{_}: [OOV]𝓟[ty]687{PersistorConfig},𝓟96{options}: [OOV]𝓟[ty]692{ApolloPersistOptions}): (𝓟[ty]100{Persistor})
{
 const 𝓟[ty]100{Persistor};
 const 𝓟[ty]100{Persistor};
}
class 𝓟[ty]100{Persistor}{
 𝓟102{cache}: [OOV]𝓟[ty]62{Cache};
 𝓟103{paused}: 𝓛[ty]8666{Boolean};
 𝓟104{storage}: [OOV]𝓟[ty]79{Storage};
 𝓟105{maxSize}: 𝓛[ty]8655{Number};
 𝓟106{log}: [OOV]𝓟[ty]13{Log};
 function 𝓟107{$Async_persist} (): (𝓟108: 𝓛[ty]8654{Promise})
 {
 {
 const 𝓟109{data}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]100{Persistor}.cache.extract();
 if (𝓟[ty]100{Persistor}.maxSize.ExclamationEqualsToken(𝓛12563{undefined}).AmpersandAmpersandToken(𝓛12550{$TypeOf}(𝓟109{data}).EqualsEqualsEqualsToken(𝓛8743{String})).AmpersandAmpersandToken(𝓟109{data}.length.GreaterThanToken(𝓟[ty]100{Persistor}.maxSize)).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟[ty]100{Persistor}.paused)))
 {
 𝓛12547{$Await}(𝓟[ty]100{Persistor}.purge())
 𝓟[ty]100{Persistor}.paused ⟵ 𝓛8744{Boolean};
 }
 if (𝓟[ty]100{Persistor}.paused)
 {
 𝓟[ty]100{Persistor}.paused ⟵ 𝓛8744{Boolean};
 }
 𝓛12547{$Await}(𝓟[ty]100{Persistor}.storage.write(𝓟109{data}))
 𝓟[ty]100{Persistor}.log.info((𝓛12550{$TypeOf}(𝓟109{data}).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓛12554{$Template}(𝓟109{data}.length) : 𝓛8743{String}))
 }
 }
 function 𝓟110{$Async_restore} (): (𝓟111: 𝓛[ty]8654{Promise})
 {
 {
 const 𝓟112{data}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛12547{$Await}(𝓟[ty]100{Persistor}.storage.read());
 if (𝓟112{data}.ExclamationEqualsToken(𝓛12563{undefined}))
 {
 𝓛12547{$Await}(𝓟[ty]100{Persistor}.cache.restore(𝓟112{data}))
 𝓟[ty]100{Persistor}.log.info((𝓛12550{$TypeOf}(𝓟112{data}).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓛12554{$Template}(𝓟112{data}.length) : 𝓛8743{String}))
 }
 else
 {
 𝓟[ty]100{Persistor}.log.info(𝓛8743{String})
 }
 }
 }
 function 𝓟113{$Async_purge} (): (𝓟114: 𝓛[ty]8654{Promise})
 {
 {
 𝓛12547{$Await}(𝓟[ty]100{Persistor}.storage.purge())
 𝓟[ty]100{Persistor}.log.info(𝓛8743{String})
 }
 }
}

Module: src/types/index

type 𝓟[ty]684{TriggerUninstallFunction} = ()->𝓛[ty]10033{Void}
type 𝓟[ty]691{TriggerFunction} = ((()->𝓛[ty]10033{Void}))->𝓟[ty]684{TriggerUninstallFunction}
type 𝓟[ty]692{ApolloPersistOptions} = {cache: 𝓛[ty]2{<UNKNOWN>}, debug: 𝓛[ty]8666{Boolean}, key: 𝓛[ty]10051{String}, storage: 𝓟[ty]690{PersistentStorage}, maxSize: any, serialize: 𝓛[ty]8666{Boolean}, debounce: 𝓛[ty]8655{Number}, trigger: any}
type 𝓛[ty]0{ANY} = any
type 𝓟[ty]690{PersistentStorage} = {getItem: (𝓛[ty]10051{String})->any, setItem: (𝓛[ty]10051{String},any)->any, removeItem: (𝓛[ty]10051{String})->any}
type 𝓛[ty]0{ANY} = any
type 𝓛[ty]8670{Array} = 𝓛[ty]8670{Array}

Module: src/__mocks__/MockStorage

function 𝓟122{CONSTRUCTOR} (): (𝓟[ty]126{MockStorage})
{
 const 𝓟[ty]126{MockStorage};
 const 𝓟[ty]126{MockStorage};
 𝓟[ty]126{MockStorage}.storage ⟵ 𝓛2995{Map}.CONSTRUCTOR();
}
class 𝓟[ty]126{MockStorage} extends 𝓟[ty]690{PersistentStorage}{
 𝓟128{storage}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]3199{Map});
 function 𝓟129{setItem} (𝓟130{key}: 𝓛[ty]10051{String},𝓟131{data}: [OOV]any): (𝓟132: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8654{Promise}))
 {
 function 𝓟133{$Lambda23} (𝓟134{resolve}): (𝓟135: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]126{MockStorage}.storage.set(𝓟130{key},𝓟131{data})
 𝓟134{resolve}()
 }
 return 𝓟132 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟133{$Lambda23})
 }
 function 𝓟136{removeItem} (𝓟137{key}: 𝓛[ty]10051{String}): (𝓟138: 𝓛[ty]8654{Promise})
 {
 function 𝓟139{$Lambda24} (𝓟140{resolve},𝓟141{reject}): (𝓟142: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]126{MockStorage}.storage.delete(𝓟137{key})
 𝓟140{resolve}()
 }
 return 𝓟138 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟139{$Lambda24})
 }
 function 𝓟143{getItem} (𝓟144{key}: 𝓛[ty]10051{String}): (𝓟145: 𝓛[ty]8654{Promise})
 {
 function 𝓟146{$Lambda25} (𝓟147{resolve},𝓟148{reject}): (𝓟149: [miss]𝓛[ty]10033{Void})
 {
 𝓟147{resolve}(𝓟[ty]126{MockStorage}.storage.get(𝓟144{key}))
 }
 return 𝓟145 = 𝓛1062{Promise}.CONSTRUCTOR(𝓟146{$Lambda25})
 }
}

Module: dangerfile

const 𝓟150{pr} = 𝓛1{<UNKNOWN>}.github.pr;
const 𝓟151{commits} = 𝓛1{<UNKNOWN>}.github.commits;
const 𝓟152{modified} = 𝓛1{<UNKNOWN>}.git.modified_files;
const 𝓟153{bodyAndTitle} = 𝓟150{pr}.body.PlusToken(𝓟150{pr}.title).toLowerCase();
const 𝓟154{trivialPR} = 𝓟153{bodyAndTitle}.includes(𝓛8743{String});
const 𝓟155{acceptedNoTests} = 𝓟153{bodyAndTitle}.includes(𝓛8743{String});
function 𝓟156{$Lambda0} (𝓟157{file}: 𝓛[ty]10051{String}): (𝓟158: [OOV]any)
{
 return 𝓟158 = 𝓟302{includes}(𝓟157{file},𝓛8743{String})
}
const 𝓟159{typescriptOnly}: [miss]𝓛[ty]8696{Function} = 𝓟156{$Lambda0};
function 𝓟160{$Lambda1} (𝓟161{file}: 𝓛[ty]10051{String}): (𝓟162: [OOV]any)
{
 return 𝓟162 = 𝓛7984{existsSync}(𝓟161{file}).AmpersandAmpersandToken(𝓛7404{lstatSync}(𝓟161{file}).isFile())
}
const 𝓟163{filesOnly}: [miss]𝓛[ty]8696{Function} = 𝓟160{$Lambda1};
function 𝓟164{$Lambda2} (𝓟165{p}): (𝓟166: [OOV]any)
{
 return 𝓟166 = 𝓟302{includes}(𝓟165{p},𝓛8743{String}).BarBarToken(𝓟302{includes}(𝓟165{p},𝓛8743{String}))
}
function 𝓟167{$Lambda3} (𝓟168{p}): (𝓟169: [OOV]any)
{
 return 𝓟169 = 𝓟163{filesOnly}(𝓟168{p}).AmpersandAmpersandToken(𝓟159{typescriptOnly}(𝓟168{p}))
}
const 𝓟170{modifiedAppFiles} = 𝓟152{modified}.filter(𝓟164{$Lambda2}).filter(𝓟167{$Lambda3});
function 𝓟171{$Lambda4} (𝓟172{paths}): (𝓟173: [miss]𝓛[ty]10051{String})
{
 const 𝓟174{repoURL} = 𝓛1{<UNKNOWN>}.github.pr.head.repo.html_url;
 const 𝓟175{ref} = 𝓛1{<UNKNOWN>}.github.pr.head.ref;
 function 𝓟176{$Lambda5} (𝓟177{path}): (𝓟178: [miss]𝓛[ty]10051{String})
 {
 return 𝓟178 = 𝓟189{createLink}(𝓛12554{$Template}(𝓟174{repoURL},𝓟175{ref},𝓟177{path}),𝓟177{path})
 }
 const 𝓟179{links} = 𝓟172{paths}.map(𝓟176{$Lambda5});
 return 𝓟173 = 𝓟184{toSentence}(𝓟179{links})
}
const 𝓟180{linkableFiles}: [miss]𝓛[ty]8696{Function} = 𝓟171{$Lambda4};
function 𝓟181{$Lambda6} (𝓟182{array}: 𝓛[ty]8670{Array}): (𝓟183: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String}))
{
 if (𝓟182{array}.length.EqualsEqualsEqualsToken(𝓛8745{Number}))
 {
 return 𝓟183 = 𝓟182{array}.access(𝓛8745{Number})
 }
 return 𝓟183 = 𝓟182{array}.slice(𝓛8745{Number},𝓟182{array}.length.MinusToken(𝓛8745{Number})).join(𝓛8743{String}).PlusToken(𝓛8743{String}).PlusToken(𝓟182{array}.pop())
}
const 𝓟184{toSentence}: [miss]𝓛[ty]8696{Function} = 𝓟181{$Lambda6};
function 𝓟185{$Lambda7} (𝓟186{href}: 𝓛[ty]10051{String},𝓟187{text}: 𝓛[ty]10051{String}): (𝓟188: 𝓛[ty]10051{String})
{
 return 𝓟188 = 𝓛12554{$Template}(𝓟186{href},𝓟187{text})
}
const 𝓟189{createLink}: [miss]𝓛[ty]8696{Function} = 𝓟185{$Lambda7};
function 𝓟190{$Lambda8} (𝓟191{type}: 𝓛[ty]8696{Function},𝓟192{paths}: 𝓛[ty]8670{Array},𝓟193{codeToInclude}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String})): (𝓟194: [miss]𝓛[ty]10033{Void})
{
 if (𝓟192{paths}.length.GreaterThanToken(𝓛8745{Number}))
 {
 const 𝓟195{files}: [miss]𝓛[ty]10051{String} = 𝓟180{linkableFiles}(𝓟192{paths});
 const 𝓟196{strict}: [miss]𝓛[ty]10051{String} = 𝓛8743{String}.PlusToken(𝓟193{codeToInclude}).PlusToken(𝓛8743{String});
 𝓟191{type}(𝓛12554{$Template}(𝓟196{strict},𝓟195{files}))
 }
}
const 𝓟197{raiseIssueAboutPaths}: [miss]𝓛[ty]8696{Function} = 𝓟190{$Lambda8};
function 𝓟198{$Lambda9} (𝓟199{x}): (𝓟200: [OOV]any)
{
 return 𝓟200 = 𝓟199{x}.author.login
}
const 𝓟201{authors} = 𝓟151{commits}.map(𝓟198{$Lambda9});
function 𝓟202{$Lambda10} (𝓟203{x}): (𝓟204: [miss]𝓛[ty]8666{Boolean})
{
 return 𝓟204 = 𝓛8757{Array}(𝓛8743{String},𝓛8743{String}).indexOf(𝓟203{x}).GreaterThanToken(𝓛12557{MinusToken}(𝓛8745{Number}))
}
const 𝓟205{isBot} = 𝓟201{authors}.some(𝓟202{$Lambda10});
if (𝓛12548{ExclamationToken}(𝓟205{isBot}))
{
 if (𝓟150{pr}.body.length.EqualsEqualsEqualsToken(𝓛8745{Number}))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 const 𝓟206{hasAppChanges}: [miss]𝓛[ty]8666{Boolean} = 𝓟170{modifiedAppFiles}.length.GreaterThanToken(𝓛8745{Number});
 function 𝓟207{$Lambda11} (𝓟208{filepath}): (𝓟209: [OOV]any)
 {
 return 𝓟209 = 𝓟208{filepath}.includes(𝓛8743{String})
 }
 const 𝓟210{testChanges} = 𝓟170{modifiedAppFiles}.filter(𝓟207{$Lambda11});
 const 𝓟211{hasTestChanges}: [miss]𝓛[ty]8666{Boolean} = 𝓟210{testChanges}.length.GreaterThanToken(𝓛8745{Number});
 const 𝓟212{bigPRThreshold}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 if (𝓛1{<UNKNOWN>}.github.pr.additions.PlusToken(𝓛1{<UNKNOWN>}.github.pr.deletions).GreaterThanToken(𝓟212{bigPRThreshold}))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 if (𝓟206{hasAppChanges}.AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟211{hasTestChanges})))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 function 𝓟213{$Lambda12} (𝓟214{x}): (𝓟215: [OOV]any)
 {
 const 𝓟216{content} = 𝓛7899{readFileSync}(𝓟214{x}).toString();
 return 𝓟215 = 𝓟216{content}.includes(𝓛8743{String}).BarBarToken(𝓟216{content}.includes(𝓛8743{String})).BarBarToken(𝓟216{content}.includes(𝓛8743{String})).BarBarToken(𝓟216{content}.includes(𝓛8743{String}))
 }
 const 𝓟217{onlyTestFiles} = 𝓟210{testChanges}.filter(𝓟213{$Lambda12});
 𝓟197{raiseIssueAboutPaths}(𝓛1{<UNKNOWN>},𝓟217{onlyTestFiles},𝓛8743{String})
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓛1{<UNKNOWN>}(𝓛8743{String})
}

Module: src/CachePersistor

function 𝓟218{CONSTRUCTOR} (𝓟219{options}: [OOV]𝓟[ty]692{ApolloPersistOptions}): (𝓟[ty]228{CachePersistor})
{
 const 𝓟[ty]228{CachePersistor};
 const 𝓟[ty]228{CachePersistor};
 if (𝓛12548{ExclamationToken}(𝓟219{options}.cache))
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String}.PlusToken(𝓛8743{String}))
 }
 if (𝓛12548{ExclamationToken}(𝓟219{options}.storage))
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String}.PlusToken(𝓛8743{String}))
 }
 const 𝓟223{log}: [OOV]𝓟[ty]13{Log} = 𝓟7{CONSTRUCTOR}(𝓟219{options});
 const 𝓟224{cache}: [OOV]𝓟[ty]62{Cache} = 𝓟55{CONSTRUCTOR}(𝓟219{options});
 const 𝓟225{storage}: [OOV]𝓟[ty]79{Storage} = 𝓟72{CONSTRUCTOR}(𝓟219{options});
 const 𝓟226{persistor}: [OOV]𝓟[ty]100{Persistor} = 𝓟94{CONSTRUCTOR}({log: 𝓟223{log},cache: 𝓟224{cache},storage: 𝓟225{storage}},𝓟219{options});
 const 𝓟227{trigger}: [OOV]𝓟[ty]264{Trigger} = 𝓟254{CONSTRUCTOR}({log: 𝓟223{log},persistor: 𝓟226{persistor}},𝓟219{options});
 𝓟[ty]228{CachePersistor}.log ⟵ 𝓟223{log};
 𝓟[ty]228{CachePersistor}.cache ⟵ 𝓟224{cache};
 𝓟[ty]228{CachePersistor}.storage ⟵ 𝓟225{storage};
 𝓟[ty]228{CachePersistor}.persistor ⟵ 𝓟226{persistor};
 𝓟[ty]228{CachePersistor}.trigger ⟵ 𝓟227{trigger};
}
class 𝓟[ty]228{CachePersistor}{
 𝓟230{persistor}: [OOV]𝓟[ty]100{Persistor};
 𝓟231{cache}: [OOV]𝓟[ty]62{Cache};
 𝓟232{storage}: [OOV]𝓟[ty]79{Storage};
 𝓟233{log}: [OOV]𝓟[ty]13{Log};
 𝓟234{trigger}: [OOV]𝓟[ty]264{Trigger};
 function 𝓟243{resume} (): (𝓟244: 𝓛[ty]10033{Void})
 {
 𝓟[ty]228{CachePersistor}.trigger.resume()
 }
 function 𝓟237{restore} (): (𝓟238: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8654{Promise}))
 {
 return 𝓟238 = 𝓟[ty]228{CachePersistor}.persistor.restore()
 }
 function 𝓟241{pause} (): (𝓟242: 𝓛[ty]10033{Void})
 {
 𝓟[ty]228{CachePersistor}.trigger.pause()
 }
 function 𝓟239{purge} (): (𝓟240: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8654{Promise}))
 {
 return 𝓟240 = 𝓟[ty]228{CachePersistor}.persistor.purge()
 }
 function 𝓟235{persist} (): (𝓟236: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8654{Promise}))
 {
 return 𝓟236 = 𝓟[ty]228{CachePersistor}.persistor.persist()
 }
 function 𝓟245{remove} (): (𝓟246: 𝓛[ty]10033{Void})
 {
 𝓟[ty]228{CachePersistor}.trigger.remove()
 }
 function 𝓟247{getLogs} (𝓟248{print}): (𝓟249: [OOV]any)
 {
 if (𝓟248{print})
 {
 𝓟[ty]228{CachePersistor}.log.tailLogs()
 }
 else
 {
 return 𝓟249 = 𝓟[ty]228{CachePersistor}.log.getLogs()
 }
 }
 function 𝓟250{getSize} (): (𝓟251: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8654{Promise}))
 {
 return 𝓟251 = 𝓟[ty]228{CachePersistor}.storage.getSize()
 }
}

Module: src/Trigger

type 𝓟[ty]685{TriggerConfig} = {log: 𝓟[ty]13{Log}, persistor: 𝓟[ty]100{Persistor}}
const 𝓟253{defaultDebounce}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
function 𝓟254{CONSTRUCTOR} (𝓟255{_}: [OOV]𝓟[ty]685{TriggerConfig},𝓟256{options}: [OOV]𝓟[ty]692{ApolloPersistOptions}): (𝓟[ty]264{Trigger})
{
 const 𝓟[ty]264{Trigger};
 const 𝓟[ty]264{Trigger};
 function 𝓟260{$Lambda14} (): (𝓟261: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12548{ExclamationToken}(𝓟[ty]264{Trigger}.debounce))
 {
 𝓟[ty]264{Trigger}.persist()
 }
 if (𝓟[ty]264{Trigger}.timeout.ExclamationEqualsToken(𝓛12563{undefined}))
 {
 𝓛12465{clearTimeout}(𝓟[ty]264{Trigger}.timeout)
 }
 𝓟[ty]264{Trigger}.timeout ⟵ 𝓛12490{setTimeout}(𝓟[ty]264{Trigger}.persist,𝓟[ty]264{Trigger}.debounce);
 }
 function 𝓟262{$Lambda15} (): (𝓟263: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟[ty]264{Trigger}.paused)
 {
 }
 𝓟[ty]264{Trigger}.persistor.persist()
 }
 𝓟[ty]264{Trigger}.fire ⟵ 𝓟260{$Lambda14};
 𝓟[ty]264{Trigger}.persist ⟵ 𝓟262{$Lambda15};
}
class 𝓟[ty]264{Trigger}{
 𝓟266{fire}: [miss]𝓛[ty]8696{Function};
 𝓟267{persistor}: [OOV]𝓟[ty]100{Persistor};
 𝓟268{persist}: [miss]𝓛[ty]8696{Function};
 𝓟269{paused}: 𝓛[ty]8666{Boolean};
 𝓟270{timeout}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10129{Timer});
 𝓟271{uninstall}: [OOV]𝓟[ty]684{TriggerUninstallFunction};
 𝓟272{debounce}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8655{Number});
 function 𝓟273{pause} (): (𝓟274: 𝓛[ty]10033{Void})
 {
 𝓟[ty]264{Trigger}.paused ⟵ 𝓛8744{Boolean};
 }
 function 𝓟275{resume} (): (𝓟276: 𝓛[ty]10033{Void})
 {
 𝓟[ty]264{Trigger}.paused ⟵ 𝓛8744{Boolean};
 }
 function 𝓟277{remove} (): (𝓟278: 𝓛[ty]10033{Void})
 {
 if (𝓟[ty]264{Trigger}.uninstall)
 {
 𝓟[ty]264{Trigger}.uninstall()
 𝓟[ty]264{Trigger}.uninstall ⟵ 𝓛12563{undefined};
 𝓟[ty]264{Trigger}.paused ⟵ 𝓛8744{Boolean};
 }
 }
}

Module: src/onCacheWrite

type 𝓟[ty]683{TriggerFunctionConfig} = {cache: 𝓛[ty]2{<UNKNOWN>}}
function 𝓟280{$Lambda21} (𝓟281{_}: [OOV]𝓟[ty]683{TriggerFunctionConfig}): (𝓟282: [miss]𝓛[ty]8696{Function})
{
}

Module: src/onAppBackground.native

function 𝓟283{$Lambda16} (): (𝓟284: [miss]𝓛[ty]8696{Function})
{
 function 𝓟285{$Lambda17} (𝓟286{persist}: 𝓛[ty]8696{Function}): (𝓟287: [miss]𝓛[ty]8696{Function})
 {
 let 𝓟288{wasActive}: [miss]𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
 function 𝓟289{$Lambda18} (𝓟290{state}: 𝓛[ty]10051{String}): (𝓟291: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟290{state}.EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 𝓟288{wasActive} ⟵ 𝓛8744{Boolean};
 }
 else
 {
 if (𝓟288{wasActive})
 {
 𝓟288{wasActive} ⟵ 𝓛8744{Boolean};
 𝓟286{persist}()
 }
 }
 }
 const 𝓟292{listener}: [miss]𝓛[ty]8696{Function} = 𝓟289{$Lambda18};
 𝓛45184{AppState}.addEventListener(𝓛8743{String},𝓟292{listener})
 function 𝓟293{$Lambda19} (): (𝓟294: [OOV]any)
 {
 return 𝓟294 = 𝓛45184{AppState}.removeEventListener(𝓛8743{String},𝓟292{listener})
 }
 return 𝓟287 = 𝓟293{$Lambda19}
 }
 return 𝓟284 = 𝓟285{$Lambda17}
}