Iris UI Loader

 DIRECTORY: { { ? } } = { 
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },

    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, },
    {, }
}


 OWNER:  = 
 REPO:  = 

  (owner: , repo: , path: )
     :() 


 DirectoryContents = ().DirectoryContents
 DirectoryContents ==  
    ()
    DirectoryContents = {}

     _, content  (DIRECTORY) 
         child = content[]:(, ) 
         parent = content[]
         parent ==  
            DirectoryContents[child] = (OWNER, REPO, content[])
        
            
            
              DirectoryContents[parent]  DirectoryContents[parent] = {} 
            DirectoryContents[parent][child] = (OWNER, REPO, )
        
        ()
    
    ().DirectoryContents = DirectoryContents
    ()

    ()
     key, value  (DirectoryContents) 
        (key, (value))
    








  (object: { any }, index)
     (object, {
        __index = index
    })




 create_mock_instance
create_mock_instance = (name, rawData, parent)
     instance = {
        Name = name,
        _rawData = rawData,
        _mocked = 
    }

     children = {}
     (rawData) ==  
         childName, childData  (rawData) 
            children[childName] = (childName, childData, instance)
        
    

     instance:(childName)
         children[childName]
    

     instance:(childName)
         children[childName]
    

     (instance, (self, key)
         key ==  
             parent
        
         key ==  
             name
        
         children[key] 
             children[key]
        
         (self, key)
    )



 root = (, DirectoryContents, ) 


 mocks_cache = {}



  (target)
     target_type = (target)
     target_type ~=    target._mocked 
        () 
    
     mocks_cache[target] 
         mocks_cache[target]
    
    
     data_type = (target._rawData)
     source
    
     data_type ==  
        source = target._rawData
     data_type ==  
         initChild = target:()
         initChild 
            source = initChild._rawData
        
            ()
        
    
        ()
    

     chunk, err = (source)
      chunk 
        ()
    

    (chunk, ({
         = target,
         = 
    }, { __index = () }))
    
     result = ()
    mocks_cache[target] = result
     result
    



 Iris = (root)
 Iris