lib/ctr-nodes/index.js
function (_data, _target, type = 'style') {
    const self = this;

    //config data
    const configData = function(data, target) {
      //Keys which we will exclude from the dataMap
      const excludeKeys = self.initRun ? [] : ['option', 'query', 'shorthand', 'mixin'];
      self.initRun = false;
      //data map struc to be popultated
      const emptyDataMap = Immutable.Map({
        static: Immutable.OrderedMap(),
        obj: Immutable.OrderedMap()
      });

      //check for use keywork, if false we don't use the data
      data = self.doNotUse(data);
      if (!data) {
        return {
          emptyDataMap,
          target
        };
      }

      //we need to map out the raw objects into two maps, obj and staic
      const dataMap = _.reduce(data, function (map, val, key) {
        const addTo = _.isPlainObject(val) ? 'obj' : 'static';
        if (!_.includes(excludeKeys, key)) {
          return map.update(addTo, function (m) {
            return m.set(key, val);
          });
        }
        return map;
      }, emptyDataMap);

      return {
        dataMap,
        target
      };
    };

    //config target
    const configTarget = function(dataMap, target) {
      //set defualt is not present
      if (!target) {
        //set init selector values.

        target = Immutable.fromJS({
          selector: self.selector,
          selectorCar: '',
          selectorCdr: '',
          selectorMedia: ''
        });

        const indexId = _H.util._id.gen('index');
        self.initIndex = indexId;
        const data = dataMap.get('static');
        //pick up local option
        const option = dataMap.getIn(['obj', 'option']) || {};
        if (option) {
          dataMap = dataMap.deleteIn(['obj', 'option']);
        }

        target = _T.util.set(Immutable.fromJS({
          key: '',
          data: data,
          option: option,
          type: 'index',
          id: indexId
        }), target);
      }

      return {
        dataMap,
        target
      };
    };


    /**
     * The plan for this fn is to cycle through the various
     * components, and then merge and res of said comps
     */
    const composeData = function(dataMap, target) {
      //dataMap
      let staticArgs = dataMap.get('static');
      let objectArgs = dataMap.get('obj');

      //transform/matrix helpers are objs so we need to check and processes
      //them before seting static to keep source order
      if (objectArgs.size) {
        if (objectArgs.has('transform')) {
          ({staticArgs, objectArgs} = _H.helperKeys.transform(objectArgs, staticArgs));
        }else if (objectArgs.has('matrix')) {
          ({staticArgs, objectArgs} = _H.helperKeys.matrix(objectArgs, staticArgs));
        }
      }
      //check for filter, can be string/array/obj
      const filter = staticArgs.has('filter') || objectArgs.has('filter');
      if (filter) {
        ({staticArgs, objectArgs} = _H.helperKeys.filter(staticArgs, objectArgs));
      }

      //add static, as in non-obj key pairs
      if (staticArgs.size) {
        //check and process helpers if present
        staticArgs = _H.helperKeys.processHelperArgs(staticArgs, target);

        //hardcoded helper, kinds hacker tied to #396
        if (staticArgs.has('__inheritProps__')) {
          //remove
          staticArgs = staticArgs.delete('__inheritProps__');
        }

        if (type !== 'style' || self.processStyle) {
          //apply static args
          self.indexMgr.set(staticArgs, target);
        }
      }
      //deflate check due to helpers like font-size: responsive
      if (_M._queue.deflateQueue.size) {
        _M._queue.deflateNext();
      }

      /*
      If gate for the real fun;
       */
      if (objectArgs.size) {

        //infinite loop saftey catch set
        self.processedHash = objectArgs.hashCode();

        /**
         * So the gist of this funk is its a wrapper funk for the passed in args.
         * I would take a look at whats happening below in the loop to get a better
         * idea of whats going on but we are just passing the keyArgs into this funk
         * @param  {str}  key     -> Key from the objectArgs
         * @param  {str}  keyList -> the regex ref in the _H.util
         * @param  {str}  plural  -> The plural name which will then cycle through
         *                           the cylceCallFn
         * @param  {fn}  funk     -> The funk which we will invoke if it passes the
         *                           if gate
         * @param  {bln} passKey  -> If we need to pass the key to the funk
         * @return {---}          -> A whole shit load could happen but nothing
         *                           is returned directly
         */
        const keyCheck = function (key, keyType, funk, passKey = true) {
          //test from list, check out the util
          if (_H.util.regularExp.keyTest(key, keyType)) {
            //checks for use key
            const data = self.doNotUse(objectArgs.get(key), keyType);
            if (!data) { return true; }
            //send off to be processed
            if (passKey) {
              funk(key, data, target, keyType);
            }else {
              funk(data, target, keyType, key);
            }
            return true;
          }
        };

        // The gist here is to cycle though all the object keys
        // and then sub cycle the above key funks to see if
        // we have a regex match. If we have a match processes said match
        // and return true so we can bust the loop and move on
        const keyArgs = [
          //single, plural, function
          ['grid',       processGrid, false],
          ['transition', processTrans],
          ['animation',  processAnim],
          ['media',      processMedia, false],
          ['state',      processState],
          ['non',        processElm],
          ['element',    processElm],
          ['attribute',  processAttr],
          ['component',  processComp]
        ];

        const keyList = objectArgs.keys();
        //cycle through keys and inkove fns to match regex
        for (let key of keyList) {
          for (let f = 0; f < keyArgs.length; f++) {
            const keyArg = keyArgs[f];
            //add key to the front of the line
            keyArg.unshift(key);
            const fnRes = keyCheck.apply(null, keyArg);
            //remove the key from the front of the line
            keyArg.shift();
            if (fnRes) {
              //remove key
              objectArgs = objectArgs.delete(key);
              //bust loop
              f += keyArgs.length;
            }
          }
        }
      }

      /**
       * Deflate and tmpl features before moving onto the next cycle
       */
      if (_M._queue.deflateQueue.size) {
        _M._queue.deflateNext();
      }

      return {
        objectArgs,
        target
      };
    };

    //process data
    const processData = function(objectArgs, target) {
      //run till nothing left to process
      if (objectArgs.size) {
        //infinite loop saftey catch
        if (objectArgs.hashCode() !== self.processedHash) {
          //first check; so we try to extract style one more time
          //just to make sure before we throw an error
          self.extractStyle(objectArgs.toJS(), target);
        }else {
          _H.throwErr({
            type: 'Infinite Loop',
            code: JSON.stringify(objectArgs.toJS()),
            msg: ['Something does not belong and I can not process',
                  'the above object so rather than throwing a nasty',
                  'stylus error I will just remove it and tell you',
                  'to take care of it. So take care of it and fix it.'].join(' ')
          });
        }
      }


      /**
       * Processes, formats, and renders our CSS styles in the stack
       */
      if (target.get('stack').size === 1) {
        let queueDone = false;
        //while river
        while (queueDone !== true) {
          queueDone = _M._queue.next();
        }
        //formats and renders our styles via stylus
        if (self.indexMgr.stack.size) {
          renderStyle(self.indexMgr, false, target);
        }
      }

      //Final return for the whole show
      return;
    };

    /*-----------------------------*/
    /// Main Call
    /*-----------------------------*/
    return teFlow.call({
      args: {
        data: _data,
        target: _target
      }},
      configData,
      configTarget,
      composeData,
      processData
    );
  }
function (_data, _target, type = 'style') {
    const self = this;

    //config data
    const configData = function(data, target) {
      //Keys which we will exclude from the dataMap
      const excludeKeys = self.initRun ? [] : ['option', 'query', 'shorthand', 'mixin'];
      self.initRun = false;
      //data map struc to be popultated
      const emptyDataMap = Immutable.Map({
        static: Immutable.OrderedMap(),
        obj: Immutable.OrderedMap()
      });

      //check for use keywork, if false we don't use the data
      data = self.doNotUse(data);
      if (!data) {
        return {
          emptyDataMap,
          target
        };
      }

      //we need to map out the raw objects into two maps, obj and staic
      const dataMap = _.reduce(data, function (map, val, key) {
        const addTo = _.isPlainObject(val) ? 'obj' : 'static';
        if (!_.includes(excludeKeys, key)) {
          return map.update(addTo, function (m) {
            return m.set(key, val);
          });
        }
        return map;
      }, emptyDataMap);

      return {
        dataMap,
        target
      };
    };

    //config target
    const configTarget = function(dataMap, target) {
      //set defualt is not present
      if (!target) {
        //set init selector values.

        target = Immutable.fromJS({
          selector: self.selector,
          selectorCar: '',
          selectorCdr: '',
          selectorMedia: ''
        });

        const indexId = _H.util._id.gen('index');
        self.initIndex = indexId;
        const data = dataMap.get('static');
        //pick up local option
        const option = dataMap.getIn(['obj', 'option']) || {};
        if (option) {
          dataMap = dataMap.deleteIn(['obj', 'option']);
        }

        target = _T.util.set(Immutable.fromJS({
          key: '',
          data: data,
          option: option,
          type: 'index',
          id: indexId
        }), target);
      }

      return {
        dataMap,
        target
      };
    };


    /**
     * The plan for this fn is to cycle through the various
     * components, and then merge and res of said comps
     */
    const composeData = function(dataMap, target) {
      //dataMap
      let staticArgs = dataMap.get('static');
      let objectArgs = dataMap.get('obj');

      //transform/matrix helpers are objs so we need to check and processes
      //them before seting static to keep source order
      if (objectArgs.size) {
        if (objectArgs.has('transform')) {
          ({staticArgs, objectArgs} = _H.helperKeys.transform(objectArgs, staticArgs));
        }else if (objectArgs.has('matrix')) {
          ({staticArgs, objectArgs} = _H.helperKeys.matrix(objectArgs, staticArgs));
        }
      }
      //check for filter, can be string/array/obj
      const filter = staticArgs.has('filter') || objectArgs.has('filter');
      if (filter) {
        ({staticArgs, objectArgs} = _H.helperKeys.filter(staticArgs, objectArgs));
      }

      //add static, as in non-obj key pairs
      if (staticArgs.size) {
        //check and process helpers if present
        staticArgs = _H.helperKeys.processHelperArgs(staticArgs, target);

        //hardcoded helper, kinds hacker tied to #396
        if (staticArgs.has('__inheritProps__')) {
          //remove
          staticArgs = staticArgs.delete('__inheritProps__');
        }

        if (type !== 'style' || self.processStyle) {
          //apply static args
          self.indexMgr.set(staticArgs, target);
        }
      }
      //deflate check due to helpers like font-size: responsive
      if (_M._queue.deflateQueue.size) {
        _M._queue.deflateNext();
      }

      /*
      If gate for the real fun;
       */
      if (objectArgs.size) {

        //infinite loop saftey catch set
        self.processedHash = objectArgs.hashCode();

        /**
         * So the gist of this funk is its a wrapper funk for the passed in args.
         * I would take a look at whats happening below in the loop to get a better
         * idea of whats going on but we are just passing the keyArgs into this funk
         * @param  {str}  key     -> Key from the objectArgs
         * @param  {str}  keyList -> the regex ref in the _H.util
         * @param  {str}  plural  -> The plural name which will then cycle through
         *                           the cylceCallFn
         * @param  {fn}  funk     -> The funk which we will invoke if it passes the
         *                           if gate
         * @param  {bln} passKey  -> If we need to pass the key to the funk
         * @return {---}          -> A whole shit load could happen but nothing
         *                           is returned directly
         */
        const keyCheck = function (key, keyType, funk, passKey = true) {
          //test from list, check out the util
          if (_H.util.regularExp.keyTest(key, keyType)) {
            //checks for use key
            const data = self.doNotUse(objectArgs.get(key), keyType);
            if (!data) { return true; }
            //send off to be processed
            if (passKey) {
              funk(key, data, target, keyType);
            }else {
              funk(data, target, keyType, key);
            }
            return true;
          }
        };

        // The gist here is to cycle though all the object keys
        // and then sub cycle the above key funks to see if
        // we have a regex match. If we have a match processes said match
        // and return true so we can bust the loop and move on
        const keyArgs = [
          //single, plural, function
          ['grid',       processGrid, false],
          ['transition', processTrans],
          ['animation',  processAnim],
          ['media',      processMedia, false],
          ['state',      processState],
          ['non',        processElm],
          ['element',    processElm],
          ['attribute',  processAttr],
          ['component',  processComp]
        ];

        const keyList = objectArgs.keys();
        //cycle through keys and inkove fns to match regex
        for (let key of keyList) {
          for (let f = 0; f < keyArgs.length; f++) {
            const keyArg = keyArgs[f];
            //add key to the front of the line
            keyArg.unshift(key);
            const fnRes = keyCheck.apply(null, keyArg);
            //remove the key from the front of the line
            keyArg.shift();
            if (fnRes) {
              //remove key
              objectArgs = objectArgs.delete(key);
              //bust loop
              f += keyArgs.length;
            }
          }
        }
      }

      /**
       * Deflate and tmpl features before moving onto the next cycle
       */
      if (_M._queue.deflateQueue.size) {
        _M._queue.deflateNext();
      }

      return {
        objectArgs,
        target
      };
    };

    //process data
    const processData = function(objectArgs, target) {
      //run till nothing left to process
      if (objectArgs.size) {
        //infinite loop saftey catch
        if (objectArgs.hashCode() !== self.processedHash) {
          //first check; so we try to extract style one more time
          //just to make sure before we throw an error
          self.extractStyle(objectArgs.toJS(), target);
        }else {
          _H.throwErr({
            type: 'Infinite Loop',
            code: JSON.stringify(objectArgs.toJS()),
            msg: ['Something does not belong and I can not process',
                  'the above object so rather than throwing a nasty',
                  'stylus error I will just remove it and tell you',
                  'to take care of it. So take care of it and fix it.'].join(' ')
          });
        }
      }


      /**
       * Processes, formats, and renders our CSS styles in the stack
       */
      if (target.get('stack').size === 1) {
        let queueDone = false;
        //while river
        while (queueDone !== true) {
          queueDone = _M._queue.next();
        }
        //formats and renders our styles via stylus
        if (self.indexMgr.stack.size) {
          renderStyle(self.indexMgr, false, target);
        }
      }

      //Final return for the whole show
      return;
    };

    /*-----------------------------*/
    /// Main Call
    /*-----------------------------*/
    return teFlow.call({
      args: {
        data: _data,
        target: _target
      }},
      configData,
      configTarget,
      composeData,
      processData
    );
  }
The heart of CTR, throbbing you.
Dispatches, composes, and manages -> it's our main man (or woman)
@param  {obj}  _data       -> raw data context
@param  {map}  _target     -> current target context
@return {---}              -> inkoves `renderStyle`