             name: name
             ignoreName: true
         ###
-    
+
     # Inject result into defined namespace
     if Object.hasOwnProperty.call udefine.inject.modules, name
       injectObject = udefine.inject.modules[name]
       {root: injectRoot, name: injectName, ignoreName} = injectObject
-      
+
       udefine.inject(injectRoot, injectName, ignoreName)(result)
-        
+
     result
-  
+
   # Allow auto injection of modules in a browser environment
   udefine.autoInject = true
-  
+
   # Helper function to inject function/object into any object
   # TODO: Reflect if helper function should be exposed
   udefine.inject = (obj, name, ignoreName) -> (res) ->
     return unless obj? and name?
-    
+
     if ignoreName then obj or= res else obj[name] or= res
-  
+
   udefine.inject.modules = {}
-  
+
   udefine.inject.add = (name, value) ->
     return unless name?
     value = {} unless value?
     value.root = root unless value.root?
     value.name = name unless value.name?
-    
+
     udefine.inject.modules[name] = value
     @
 
   udefine.inject.remove = (name) ->
     delete udefine.inject.modules[name]
     @
-    
+
   udefine.inject.clear = ->
     udefine.inject.modules = {}
     @
-  
+
   # Dependencies
   udefine.modules =
     globals: {}
     commonjs: {}
-  
+
     # TODO: Reflect if previously defined modules should be overwritten
     add: (name, value) ->
       if typeof name is 'object'

      else
        udefine.modules[platform][name] = value
      @
      
    clear: ->
      udefine.modules[p] = {} for p in platforms
      @
  
  # Default settings for udefine environment
  udefine.env or=
    amd: do -> !!(define? and (define.amd or define.umd))
    commonjs: hasModule
    browser: not hasModule
    globals: not hasModule and not udefine.amd
  
  # Paths
  udefine.paths =
    commonjs:
      base: undefined
  
  # Require modules
  udefine.require = (name, callback) ->
    name = [name] unless Array.isArray name
    
    reqDeps = (udefine.modules.get n for n in name)
    callback.apply @, reqDeps
  
  # Default configuration definition
  udefine.defaultConfig = ->
    udefine.modules.commonjs.root = root
    udefine.modules.globals.root = root
  
    define('root', -> root) if root.define?
  
  # Call default configuration
  udefine.defaultConfig()
  
  # Configuration helper function
  udefine.configure = (configFunc) ->
    context = {}
    for own e of udefine.env
      context[e] = (platformDef) =>
        if udefine.env[e] then platformDef.call @
  
    configFunc.apply context, [root, udefine]
  
  # Export udefine function on CommonJS environments
  if hasModule then module.exports = udefine else root.udefine = udefine

        else
          udefine.modules[platform][name] = undefined
      @

    remove: (name) ->
      for p in platforms
        if Object.hasOwnProperty.call udefine.modules[p], name
          delete udefine.modules[p][name]
      @

    get: (name) -> udefine.modules[platform][name]
    set: (name, value) ->
      if typeof value is 'object'
