Restricted Enviroment

local clone = (.clone)
  (orig)
	 copy = {}
	 k, v  (orig) 
		 (v) ==  
			copy[k] = (v)
		
			copy[k] = v
		
	
	 (copy)


  (t)
   wrapped = {}
   k,v  (t) 
     (v) ==  
      wrapped[k] = (v)
     (v) ==  
      wrapped[k] = (v)
    
      wrapped[k] = v
    
  
   wrapped


 Copy = (t)
   (t) ==  
     ((t))
   (t) ==  
     (t)
  
    ((t))
  


  (t)
   protected = (t)
   ({}, {
    __index = protected,
    __newindex = () () ,
    __metatable = 
  })


 c = ()

  ()
   env = {
     = (),
     = (),
     = (),
     = (),
     = (),
     = (),
    debug = (debug),
    bit = (bit  {
      IsBit = ()   
    }),
    myAPI = {
      add = (a, b)  a + b ,
      greet = (name)   .. name ,
    },
     = ((...)
      ()
    ),
    detourfunction = ((...)
      ()
    )
  }
   (env, {
    __newindex = () () ,
    __metatable = 
  })


  (code, env)
   keys = {}
   k  (env) 
    .(keys, k)
  
   argList = .(keys, )
   wrapper = .(, argList, code)

   chunk, err = (wrapper)
    chunk 
     ,  .. err
  
   ok, func = (chunk)
    ok 
     ,  .. (func)
  
   args = {}
   _, key  (keys) 
    .(args, env[key])
  
   success, result = (func, .(args))
    success 
     ,  .. result
  
   result



 env = ()

 result, err = (, env)

 result 
  (, result)

  (, err)



 bad, badErr = (, env)

 bad 
  (, bad)

  (, badErr)