text: var LayerExpressionInterface = (function (){
      function toWorld(arr, time){
          var toWorldMat = new Matrix();
          toWorldMat.reset();
          var transformMat;
          if(time) {
              //Todo implement value at time on transform properties
              //transformMat = this._elem.finalTransform.mProp.getValueAtTime(time);
              transformMat = this._elem.finalTransform.mProp;
          } else {
              transformMat = this._elem.finalTransform.mProp;
          }
          transformMat.applyToMatrix(toWorldMat);
          if(this._elem.hierarchy && this._elem.hierarchy.length){
              var i, len = this._elem.hierarchy.length;
              for(i=0;i<len;i+=1){
                  this._elem.hierarchy[i].finalTransform.mProp.applyToMatrix(toWorldMat);
              }
              return toWorldMat.applyToPointArray(arr[0],arr[1],arr[2]||0);
          }
          return toWorldMat.applyToPointArray(arr[0],arr[1],arr[2]||0);
      }
      function fromWorld(arr, time){
          var toWorldMat = new Matrix();
          toWorldMat.reset();
          var transformMat;
          if(time) {
              //Todo implement value at time on transform properties
              //transformMat = this._elem.finalTransform.mProp.getValueAtTime(time);
              transformMat = this._elem.finalTransform.mProp;
          } else {
              transformMat = this._elem.finalTransform.mProp;
          }
          transformMat.applyToMatrix(toWorldMat);
          if(this._elem.hierarchy && this._elem.hierarchy.length){
              var i, len = this._elem.hierarchy.length;
              for(i=0;i<len;i+=1){
                  this._elem.hierarchy[i].finalTransform.mProp.applyToMatrix(toWorldMat);
              }
              return toWorldMat.inversePoint(arr);
          }
          return toWorldMat.inversePoint(arr);
      }
      function fromComp(arr){
          var toWorldMat = new Matrix();
          toWorldMat.reset();
          this._elem.finalTransform.mProp.applyToMatrix(toWorldMat);
          if(this._elem.hierarchy && this._elem.hierarchy.length){
              var i, len = this._elem.hierarchy.length;
              for(i=0;i<len;i+=1){
                  this._elem.hierarchy[i].finalTransform.mProp.applyToMatrix(toWorldMat);
              }
              return toWorldMat.inversePoint(arr);
          }
          return toWorldMat.inversePoint(arr);
      }
  
      function sampleImage() {
          return [1,1,1,1];
      }
  
  
      return function(elem){
  
          var transformInterface;
  
          function _registerMaskInterface(maskManager){
              _thisLayerFunction.mask = new MaskManagerInterface(maskManager, elem);
          }
          function _registerEffectsInterface(effects){
              _thisLayerFunction.effect = effects;
          }
  
          function _thisLayerFunction(name){
              switch(name){
                  case "ADBE Root Vectors Group":
                  case "Contents":
                  case 2:
                      return _thisLayerFunction.shapeInterface;
                  case 1:
                  case 6:
                  case "Transform":
                  case "transform":
                  case "ADBE Transform Group":
                      return transformInterface;
                  case 4:
                  case "ADBE Effect Parade":
                      return _thisLayerFunction.effect;
              }
          }
          _thisLayerFunction.toWorld = toWorld;
          _thisLayerFunction.fromWorld = fromWorld;
          _thisLayerFunction.toComp = toWorld;
          _thisLayerFunction.fromComp = fromComp;
          _thisLayerFunction.sampleImage = sampleImage;
          _thisLayerFunction.sourceRectAtTime = elem.sourceRectAtTime.bind(elem);
          _thisLayerFunction._elem = elem;
          transformInterface = TransformExpressionInterface(elem.finalTransform.mProp);
          var anchorPointDescriptor = getDescriptor(transformInterface, 'anchorPoint');
          Object.defineProperties(_thisLayerFunction,{
              hasParent: {
                  get: function(){
                      return elem.hierarchy.length;
                  }
              },
              parent: {
                  get: function(){
                      return elem.hierarchy[0].layerInterface;
                  }
              },
              rotation: getDescriptor(transformInterface, 'rotation'),
              scale: getDescriptor(transformInterface, 'scale'),
              position: getDescriptor(transformInterface, 'position'),
              opacity: getDescriptor(transformInterface, 'opacity'),
              anchorPoint: anchorPointDescriptor,
              anchor_point: anchorPointDescriptor,
              transform: {
                  get: function () {
                      return transformInterface;
                  }
              },
              active: {
                  get: function(){
                      return elem.isInRange;
                  }
              }
          });
  
          _thisLayerFunction.startTime = elem.data.st;
          _thisLayerFunction.index = elem.data.ind;
          _thisLayerFunction.source = elem.data.refId;
          _thisLayerFunction.height = elem.data.ty === 0 ? elem.data.h : 100;
          _thisLayerFunction.width = elem.data.ty === 0 ? elem.data.w : 100;
          _thisLayerFunction.inPoint = elem.data.ip/elem.comp.globalData.frameRate;
          _thisLayerFunction.outPoint = elem.data.op/elem.comp.globalData.frameRate;
          _thisLayerFunction._name = elem.data.nm;
  
          _thisLayerFunction.registerMaskInterface = _registerMaskInterface;
          _thisLayerFunction.registerEffectsInterface = _registerEffectsInterface;
          return _thisLayerFunction;
      };
  }());
  