docs: function(feature) {
          var sourceSplit = false;
          var targetSplit = false;
          if(!this.sourceFilter ||
             this.sourceFilter.evaluate(feature.attributes)) {
              var features = this.layer && this.layer.features || [];
              var target, results, proceed;
              var additions = [], removals = [];
              var mutual = (this.layer === this.source) && this.mutual;
              var options = {
                  edge: this.edge,
                  tolerance: this.tolerance,
                  mutual: mutual
              };
              var sourceParts = [feature.geometry];
              var targetFeature, targetParts;
              var source, parts;
              for(var i=0, len=features.length; i<len; ++i) {
                  targetFeature = features[i];
                  if(this.isEligible(targetFeature)) {
                      targetParts = [targetFeature.geometry];
                      // work through source geoms - this array may change
                      for(var j=0; j<sourceParts.length; ++j) { 
                          source = sourceParts[j];
                          // work through target parts - this array may change
                          for(var k=0; k<targetParts.length; ++k) {
                              target = targetParts[k];
                              if(source.getBounds().intersectsBounds(target.getBounds())) {
                                  results = source.split(target, options);
                                  if(results) {
                                      proceed = this.events.triggerEvent(
                                          "beforesplit", {source: feature, target: targetFeature}
                                      );
                                      if(proceed !== false) {
                                          if(mutual) {
                                              parts = results[0];
                                              // handle parts that result from source splitting
                                              if(parts.length > 1) {
                                                  // splice in new source parts
                                                  parts.unshift(j, 1); // add args for splice below
                                                  Array.prototype.splice.apply(sourceParts, parts);
                                                  j += parts.length - 3;
                                              }
                                              results = results[1];
                                          }
                                          // handle parts that result from target splitting
                                          if(results.length > 1) {
                                              // splice in new target parts
                                              results.unshift(k, 1); // add args for splice below
                                              Array.prototype.splice.apply(targetParts, results);
                                              k += results.length - 3;
                                          }
                                      }
                                  }
                              }
                          }
                      }
                      if(targetParts && targetParts.length > 1) {
                          this.geomsToFeatures(targetFeature, targetParts);
                          this.events.triggerEvent("split", {
                              original: targetFeature,
                              features: targetParts
                          });
                          Array.prototype.push.apply(additions, targetParts);
                          removals.push(targetFeature);
                          targetSplit = true;
                      }
                  }
              }
              if(sourceParts && sourceParts.length > 1) {
                  this.geomsToFeatures(feature, sourceParts);
                  this.events.triggerEvent("split", {
                      original: feature,
                      features: sourceParts
                  });
                  Array.prototype.push.apply(additions, sourceParts);
                  removals.push(feature);
                  sourceSplit = true;
              }
              if(sourceSplit || targetSplit) {
                  // remove and add feature events are suppressed
                  // listen for split event on this control instead
                  if(this.deferDelete) {
                      // Set state instead of removing.  Take care to avoid
                      // setting delete for features that have not yet been
                      // inserted - those should be destroyed immediately.
                      var feat, destroys = [];
                      for(var i=0, len=removals.length; i<len; ++i) {
                          feat = removals[i];
                          if(feat.state === OpenLayers.State.INSERT) {
                              destroys.push(feat);
                          } else {
                              feat.state = OpenLayers.State.DELETE;
                              this.layer.drawFeature(feat);
                          }
                      }
                      this.layer.destroyFeatures(destroys, {silent: true});
                      for(var i=0, len=additions.length; i<len; ++i) {
                          additions[i].state = OpenLayers.State.INSERT;
                      }
                  } else {
                      this.layer.destroyFeatures(removals, {silent: true});
                  }
                  this.layer.addFeatures(additions, {silent: true});
                  this.events.triggerEvent("aftersplit", {
                      source: feature,
                      features: additions
                  });
              }
          }
          return sourceSplit;
      }