/*! AutoFill 1.2.1


 * ©2008-2014 SpryMedia Ltd - datatables.net/license


 */





/**


 * @summary     AutoFill


 * @description Add Excel like click and drag auto-fill options to DataTables


 * @version     1.2.1


 * @file        dataTables.autoFill.js


 * @author      SpryMedia Ltd (www.sprymedia.co.uk)


 * @contact     www.sprymedia.co.uk/contact


 * @copyright   Copyright 2010-2014 SpryMedia Ltd.


 *


 * This source file is free software, available under the following license:


 *   MIT license - http://datatables.net/license/mit


 *


 * This source file is distributed in the hope that it will be useful, but


 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY


 * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.


 *


 * For details please refer to: http://www.datatables.net


 */





(function( window, document, undefined ) {





var factory = function( $, DataTable ) {


"use strict";





/** 


 * AutoFill provides Excel like auto-fill features for a DataTable


 *


 * @class AutoFill


 * @constructor


 * @param {object} oTD DataTables settings object


 * @param {object} oConfig Configuration object for AutoFill


 */


var AutoFill = function( oDT, oConfig )


{


	/* Sanity check that we are a new instance */


	if ( ! (this instanceof AutoFill) ) {


		throw( "Warning: AutoFill must be initialised with the keyword 'new'" );


	}





	if ( ! $.fn.dataTableExt.fnVersionCheck('1.7.0') ) {


		throw( "Warning: AutoFill requires DataTables 1.7 or greater");


	}








	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *


	 * Public class variables


	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */





	this.c = {};





	/**


	 * @namespace Settings object which contains customisable information for AutoFill instance


	 */


	this.s = {


		/**


		 * @namespace Cached information about the little dragging icon (the filler)


		 */


		"filler": {


			"height": 0,


			"width": 0


		},





		/**


		 * @namespace Cached information about the border display


		 */


		"border": {


			"width": 2


		},





		/**


		 * @namespace Store for live information for the current drag


		 */


		"drag": {


			"startX": -1,


			"startY": -1,


			"startTd": null,


			"endTd": null,


			"dragging": false


		},





		/**


		 * @namespace Data cache for information that we need for scrolling the screen when we near


		 *   the edges


		 */


		"screen": {


			"interval": null,


			"y": 0,


			"height": 0,


			"scrollTop": 0


		},





		/**


		 * @namespace Data cache for the position of the DataTables scrolling element (when scrolling


		 *   is enabled)


		 */


		"scroller": {


			"top": 0,


			"bottom": 0


		},





		/**


		 * @namespace Information stored for each column. An array of objects


		 */


		"columns": []


	};








	/**


	 * @namespace Common and useful DOM elements for the class instance


	 */


	this.dom = {


		"table": null,


		"filler": null,


		"borderTop": null,


		"borderRight": null,


		"borderBottom": null,


		"borderLeft": null,


		"currentTarget": null


	};











	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *


	 * Public class methods


	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */





	/**


	 * Retreieve the settings object from an instance


	 *  @method fnSettings


	 *  @returns {object} AutoFill settings object


	 */


	this.fnSettings = function () {


		return this.s;


	};








	/* Constructor logic */


	this._fnInit( oDT, oConfig );


	return this;


};











AutoFill.prototype = {


	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *


	 * Private methods (they are of course public in JS, but recommended as private)


	 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */





	/**


	 * Initialisation


	 *  @method _fnInit


	 *  @param {object} dt DataTables settings object


	 *  @param {object} config Configuration object for AutoFill


	 *  @returns void


	 */


	"_fnInit": function ( dt, config )


	{


		var


			that = this,


			i, iLen;





		// Use DataTables API to get the settings allowing selectors, instances


		// etc to be used, or for backwards compatibility get from the old


		// fnSettings method


		this.s.dt = DataTable.Api ?


			new DataTable.Api( dt ).settings()[0] :


			dt.fnSettings();


		this.s.init = config || {};


		this.dom.table = this.s.dt.nTable;





		$.extend( true, this.c, AutoFill.defaults, config );





		/* Add and configure the columns */


		this._initColumns();





		/* Auto Fill click and drag icon */


		var filler = $('<div/>', {


				'class': 'AutoFill_filler'


			} )


			.appendTo( 'body' );


		this.dom.filler = filler[0];





		// Get the height / width of the click element


		this.s.filler.height = filler.height();


		this.s.filler.width = filler.width();


		filler[0].style.display = "none";





		/* Border display - one div for each side. We can't just use a single


		 * one with a border, as we want the events to effectively pass through


		 * the transparent bit of the box


		 */


		var border;


		var appender = document.body;


		if ( that.s.dt.oScroll.sY !== "" ) {


			that.s.dt.nTable.parentNode.style.position = "relative";


			appender = that.s.dt.nTable.parentNode;


		}





		border = $('<div/>', {


			"class": "AutoFill_border"


		} );


		this.dom.borderTop    = border.clone().appendTo( appender )[0];


		this.dom.borderRight  = border.clone().appendTo( appender )[0];


		this.dom.borderBottom = border.clone().appendTo( appender )[0];


		this.dom.borderLeft   = border.clone().appendTo( appender )[0];





		/* Events */


		filler.on( 'mousedown.DTAF', function (e) {


			this.onselectstart = function() { return false; };


			that._fnFillerDragStart.call( that, e );


			return false;


		} );





		$('tbody', this.dom.table).on(


			'mouseover.DTAF mouseout.DTAF',


			'>tr>td, >tr>th',


			function (e) {


				that._fnFillerDisplay.call( that, e );


			}


		);





		$(this.dom.table).on( 'destroy.dt.DTAF', function () {


			filler.off( 'mousedown.DTAF' ).remove();


			$('tbody', this.dom.table).off( 'mouseover.DTAF mouseout.DTAF' );


		} );


	},








	_initColumns: function ( )


	{


		var that = this;


		var i, ien;


		var dt = this.s.dt;


		var config = this.s.init;





		for ( i=0, ien=dt.aoColumns.length ; i<ien ; i++ ) {


			this.s.columns[i] = $.extend( true, {}, AutoFill.defaults.column );


		}





		dt.oApi._fnApplyColumnDefs(


			dt,


			config.aoColumnDefs || config.columnDefs,


			config.aoColumns || config.columns,


			function (colIdx, def) {


				that._fnColumnOptions( colIdx, def );


			}


		);





		// For columns which don't have read, write, step functions defined,


		// use the default ones


		for ( i=0, ien=dt.aoColumns.length ; i<ien ; i++ ) {


			var column = this.s.columns[i];





			if ( ! column.read ) {


				column.read = this._fnReadCell;


			}


			if ( ! column.write ) {


				column.read = this._fnWriteCell;


			}


			if ( ! column.step ) {


				column.read = this._fnStep;


			}


		}


	},








	"_fnColumnOptions": function ( i, opts )


	{


		var column = this.s.columns[ i ];


		var set = function ( outProp, inProp ) {


			if ( opts[ inProp[0] ] !== undefined ) {


				column[ outProp ] = opts[ inProp[0] ];


			}


			if ( opts[ inProp[1] ] !== undefined ) {


				column[ outProp ] = opts[ inProp[1] ];


			}


		};





		// Compatibility with the old Hungarian style of notation


		set( 'enable',    ['bEnable',     'enable'] );


		set( 'read',      ['fnRead',      'read'] );


		set( 'write',     ['fnWrite',     'write'] );


		set( 'step',      ['fnStep',      'step'] );


		set( 'increment', ['bIncrement',  'increment'] );


	},








	/**


	 * Find out the coordinates of a given TD cell in a table


	 *  @method  _fnTargetCoords


	 *  @param   {Node} nTd


	 *  @returns {Object} x and y properties, for the position of the cell in the tables DOM


	 */


	"_fnTargetCoords": function ( nTd )


	{


		var nTr = $(nTd).parents('tr')[0];


		var position = this.s.dt.oInstance.fnGetPosition( nTd );





		return {


			"x":      $('td', nTr).index(nTd),


			"y":      $('tr', nTr.parentNode).index(nTr),


			"row":    position[0],


			"column": position[2]


		};


	},








	/**


	 * Display the border around one or more cells (from start to end)


	 *  @method  _fnUpdateBorder


	 *  @param   {Node} nStart Starting cell


	 *  @param   {Node} nEnd Ending cell


	 *  @returns void


	 */


	"_fnUpdateBorder": function ( nStart, nEnd )


	{


		var


			border = this.s.border.width,


			offsetStart = $(nStart).offset(),


			offsetEnd = $(nEnd).offset(),


			x1 = offsetStart.left - border,


			x2 = offsetEnd.left + $(nEnd).outerWidth(),


			y1 = offsetStart.top - border,


			y2 = offsetEnd.top + $(nEnd).outerHeight(),


			width = offsetEnd.left + $(nEnd).outerWidth() - offsetStart.left + (2*border),


			height = offsetEnd.top + $(nEnd).outerHeight() - offsetStart.top + (2*border),


			oStyle;





		// Recalculate start and end (when dragging "backwards")  


		if( offsetStart.left > offsetEnd.left) {


			x1 = offsetEnd.left - border;


			x2 = offsetStart.left + $(nStart).outerWidth();


			width = offsetStart.left + $(nStart).outerWidth() - offsetEnd.left + (2*border);


		}





		if ( this.s.dt.oScroll.sY !== "" )


		{


			/* The border elements are inside the DT scroller - so position relative to that */


			var


				offsetScroll = $(this.s.dt.nTable.parentNode).offset(),


				scrollTop = $(this.s.dt.nTable.parentNode).scrollTop(),


				scrollLeft = $(this.s.dt.nTable.parentNode).scrollLeft();





			x1 -= offsetScroll.left - scrollLeft;


			x2 -= offsetScroll.left - scrollLeft;


			y1 -= offsetScroll.top - scrollTop;


			y2 -= offsetScroll.top - scrollTop;


		}





		/* Top */


		oStyle = this.dom.borderTop.style;


		oStyle.top = y1+"px";


		oStyle.left = x1+"px";


		oStyle.height = this.s.border.width+"px";


		oStyle.width = width+"px";





		/* Bottom */


		oStyle = this.dom.borderBottom.style;


		oStyle.top = y2+"px";


		oStyle.left = x1+"px";


		oStyle.height = this.s.border.width+"px";


		oStyle.width = width+"px";





		/* Left */


		oStyle = this.dom.borderLeft.style;


		oStyle.top = y1+"px";


		oStyle.left = x1+"px";


		oStyle.height = height+"px";


		oStyle.width = this.s.border.width+"px";





		/* Right */


		oStyle = this.dom.borderRight.style;


		oStyle.top = y1+"px";


		oStyle.left = x2+"px";


		oStyle.height = height+"px";


		oStyle.width = this.s.border.width+"px";


	},








	/**


	 * Mouse down event handler for starting a drag


	 *  @method  _fnFillerDragStart


	 *  @param   {Object} e Event object


	 *  @returns void


	 */


	"_fnFillerDragStart": function (e)


	{


		var that = this;


		var startingTd = this.dom.currentTarget;





		this.s.drag.dragging = true;





		that.dom.borderTop.style.display = "block";


		that.dom.borderRight.style.display = "block";


		that.dom.borderBottom.style.display = "block";


		that.dom.borderLeft.style.display = "block";





		var coords = this._fnTargetCoords( startingTd );


		this.s.drag.startX = coords.x;


		this.s.drag.startY = coords.y;





		this.s.drag.startTd = startingTd;


		this.s.drag.endTd = startingTd;





		this._fnUpdateBorder( startingTd, startingTd );





		$(document).bind('mousemove.AutoFill', function (e) {


			that._fnFillerDragMove.call( that, e );


		} );





		$(document).bind('mouseup.AutoFill', function (e) {


			that._fnFillerFinish.call( that, e );


		} );





		/* Scrolling information cache */


		this.s.screen.y = e.pageY;


		this.s.screen.height = $(window).height();


		this.s.screen.scrollTop = $(document).scrollTop();





		if ( this.s.dt.oScroll.sY !== "" )


		{


			this.s.scroller.top = $(this.s.dt.nTable.parentNode).offset().top;


			this.s.scroller.bottom = this.s.scroller.top + $(this.s.dt.nTable.parentNode).height();


		}





		/* Scrolling handler - we set an interval (which is cancelled on mouse up) which will fire


		 * regularly and see if we need to do any scrolling


		 */


		this.s.screen.interval = setInterval( function () {


			var iScrollTop = $(document).scrollTop();


			var iScrollDelta = iScrollTop - that.s.screen.scrollTop;


			that.s.screen.y += iScrollDelta;





			if ( that.s.screen.height - that.s.screen.y + iScrollTop < 50 )


			{


				$('html, body').animate( {


					"scrollTop": iScrollTop + 50


				}, 240, 'linear' );


			}


			else if ( that.s.screen.y - iScrollTop < 50 )


			{


				$('html, body').animate( {


					"scrollTop": iScrollTop - 50


				}, 240, 'linear' );


			}





			if ( that.s.dt.oScroll.sY !== "" )


			{


				if ( that.s.screen.y > that.s.scroller.bottom - 50 )


				{


					$(that.s.dt.nTable.parentNode).animate( {


						"scrollTop": $(that.s.dt.nTable.parentNode).scrollTop() + 50


					}, 240, 'linear' );


				}


				else if ( that.s.screen.y < that.s.scroller.top + 50 )


				{


					$(that.s.dt.nTable.parentNode).animate( {


						"scrollTop": $(that.s.dt.nTable.parentNode).scrollTop() - 50


					}, 240, 'linear' );


				}


			}


		}, 250 );


	},








	/**


	 * Mouse move event handler for during a move. See if we want to update the display based on the


	 * new cursor position


	 *  @method  _fnFillerDragMove


	 *  @param   {Object} e Event object


	 *  @returns void


	 */


	"_fnFillerDragMove": function (e)


	{


		if ( e.target && e.target.nodeName.toUpperCase() == "TD" &&


			 e.target != this.s.drag.endTd )


		{


			var coords = this._fnTargetCoords( e.target );





			if ( this.c.mode == "y" && coords.x != this.s.drag.startX )


			{


				e.target = $('tbody>tr:eq('+coords.y+')>td:eq('+this.s.drag.startX+')', this.dom.table)[0];


			}


			if ( this.c.mode == "x" && coords.y != this.s.drag.startY )


			{


				e.target = $('tbody>tr:eq('+this.s.drag.startY+')>td:eq('+coords.x+')', this.dom.table)[0];


			}





			if ( this.c.mode == "either")


			{


				if(coords.x != this.s.drag.startX )


				{


					e.target = $('tbody>tr:eq('+this.s.drag.startY+')>td:eq('+coords.x+')', this.dom.table)[0];


				}


				else if ( coords.y != this.s.drag.startY ) {


					e.target = $('tbody>tr:eq('+coords.y+')>td:eq('+this.s.drag.startX+')', this.dom.table)[0];


				}


			}





			// update coords


			if ( this.c.mode !== "both" ) {


				coords = this._fnTargetCoords( e.target );


			}





			var drag = this.s.drag;


			drag.endTd = e.target;





			if ( coords.y >= this.s.drag.startY ) {


				this._fnUpdateBorder( drag.startTd, drag.endTd );


			}


			else {


				this._fnUpdateBorder( drag.endTd, drag.startTd );


			}


			this._fnFillerPosition( e.target );


		}





		/* Update the screen information so we can perform scrolling */


		this.s.screen.y = e.pageY;


		this.s.screen.scrollTop = $(document).scrollTop();





		if ( this.s.dt.oScroll.sY !== "" )


		{


			this.s.scroller.scrollTop = $(this.s.dt.nTable.parentNode).scrollTop();


			this.s.scroller.top = $(this.s.dt.nTable.parentNode).offset().top;


			this.s.scroller.bottom = this.s.scroller.top + $(this.s.dt.nTable.parentNode).height();


		}


	},








	/**


	 * Mouse release handler - end the drag and take action to update the cells with the needed values


	 *  @method  _fnFillerFinish


	 *  @param   {Object} e Event object


	 *  @returns void


	 */


	"_fnFillerFinish": function (e)


	{


		var that = this, i, iLen, j;





		$(document).unbind('mousemove.AutoFill mouseup.AutoFill');





		this.dom.borderTop.style.display = "none";


		this.dom.borderRight.style.display = "none";


		this.dom.borderBottom.style.display = "none";


		this.dom.borderLeft.style.display = "none";





		this.s.drag.dragging = false;





		clearInterval( this.s.screen.interval );





		var cells = [];


		var table = this.dom.table;


		var coordsStart = this._fnTargetCoords( this.s.drag.startTd );


		var coordsEnd = this._fnTargetCoords( this.s.drag.endTd );


		var columnIndex = function ( visIdx ) {


			return that.s.dt.oApi._fnVisibleToColumnIndex( that.s.dt, visIdx );


		};





		// xxx - urgh - there must be a way of reducing this...


		if ( coordsStart.y <= coordsEnd.y ) {


			for ( i=coordsStart.y ; i<=coordsEnd.y ; i++ ) {


				if ( coordsStart.x <= coordsEnd.x ) {


					for ( j=coordsStart.x ; j<=coordsEnd.x ; j++ ) {


						cells.push( {


							node:   $('tbody>tr:eq('+i+')>td:eq('+j+')', table)[0],


							x:      j - coordsStart.x,


							y:      i - coordsStart.y,


							colIdx: columnIndex( j )


						} );


					}


				}


				else {


					for ( j=coordsStart.x ; j>=coordsEnd.x ; j-- ) {


						cells.push( {


							node:   $('tbody>tr:eq('+i+')>td:eq('+j+')', table)[0],


							x:      j - coordsStart.x,


							y:      i - coordsStart.y,


							colIdx: columnIndex( j )


						} );


					}


				}


			}


		}


		else {


			for ( i=coordsStart.y ; i>=coordsEnd.y ; i-- ) {


				if ( coordsStart.x <= coordsEnd.x ) {


					for ( j=coordsStart.x ; j<=coordsEnd.x ; j++ ) {


						cells.push( {


							node:   $('tbody>tr:eq('+i+')>td:eq('+j+')', table)[0],


							x:      j - coordsStart.x,


							y:      i - coordsStart.y,


							colIdx: columnIndex( j )


						} );


					}


				}


				else {


					for ( j=coordsStart.x ; j>=coordsEnd.x ; j-- ) {


						cells.push( {


							node:   $('tbody>tr:eq('+i+')>td:eq('+j+')', table)[0],


							x:      coordsStart.x - j,


							y:      coordsStart.y - i,


							colIdx: columnIndex( j )


						} );


					}


				}


			}


		}





		// An auto-fill requires 2 or more cells


		if ( cells.length <= 1 ) {


			return;


		}





		var edited = [];


		var previous;





		for ( i=0, iLen=cells.length ; i<iLen ; i++ ) {


			var cell      = cells[i];


			var column    = this.s.columns[ cell.colIdx ];


			var read      = column.read.call( column, cell.node );


			var stepValue = column.step.call( column, cell.node, read, previous, i, cell.x, cell.y );





			column.write.call( column, cell.node, stepValue );





			previous = stepValue;


			edited.push( {


				cell:     cell,


				colIdx:   cell.colIdx,


				newValue: stepValue,


				oldValue: read


			} );


		}





		if ( this.c.complete !== null ) {


			this.c.complete.call( this, edited );


		}





		// In 1.10 we can do a static draw


		if ( DataTable.Api ) {


			new DataTable.Api( this.s.dt ).draw( false );


		}


		else {


			this.s.dt.oInstance.fnDraw();


		}


	},








	/**


	 * Display the drag handle on mouse over cell


	 *  @method  _fnFillerDisplay


	 *  @param   {Object} e Event object


	 *  @returns void


	 */


	"_fnFillerDisplay": function (e)


	{


		var filler = this.dom.filler;





		/* Don't display automatically when dragging */


		if ( this.s.drag.dragging)


		{


			return;


		}





		/* Check that we are allowed to AutoFill this column or not */


		var nTd = (e.target.nodeName.toLowerCase() == 'td') ? e.target : $(e.target).parents('td')[0];


		var iX = this._fnTargetCoords(nTd).column;


		if ( !this.s.columns[iX].enable )


		{


			filler.style.display = "none";


			return;


		}





		if (e.type == 'mouseover')


		{


			this.dom.currentTarget = nTd;


			this._fnFillerPosition( nTd );





			filler.style.display = "block";


		}


		else if ( !e.relatedTarget || !e.relatedTarget.className.match(/AutoFill/) )


		{


			filler.style.display = "none";


		}


	},








	/**


	 * Position the filler icon over a cell


	 *  @method  _fnFillerPosition


	 *  @param   {Node} nTd Cell to position filler icon over


	 *  @returns void


	 */


	"_fnFillerPosition": function ( nTd )


	{


		var offset = $(nTd).offset();


		var filler = this.dom.filler;


		filler.style.top = (offset.top - (this.s.filler.height / 2)-1 + $(nTd).outerHeight())+"px";


		filler.style.left = (offset.left - (this.s.filler.width / 2)-1 + $(nTd).outerWidth())+"px";


	}


};








// Alias for access


DataTable.AutoFill = AutoFill;


DataTable.AutoFill = AutoFill;











/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *


 * Constants


 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */





/**


 * AutoFill version


 *  @constant  version


 *  @type      String


 *  @default   See code


 */


AutoFill.version = "1.2.1";








/**


 * AutoFill defaults


 *  @namespace


 */


AutoFill.defaults = {


	/**


	 * Mode for dragging (restrict to y-axis only, x-axis only, either one or none):


	 *


	 *  * `y`      - y-axis only (default)


	 *  * `x`      - x-axis only


	 *  * `either` - either one, but not both axis at the same time


	 *  * `both`   - multiple cells allowed


	 *


	 * @type {string}


	 * @default `y`


	 */


	mode: 'y',





	complete: null,





	/**


	 * Column definition defaults


	 *  @namespace


	 */


	column: {


		/**


		 * If AutoFill should be enabled on this column


		 *


		 * @type {boolean}


		 * @default true


		 */


		enable: true,





		/**


		 * Allow automatic increment / decrement on this column if a number


		 * is found.


		 *


		 * @type {boolean}


		 * @default true


		 */


		increment: true,





		/**


		 * Cell read function


		 *


		 * Default function will simply read the value from the HTML of the


		 * cell.


		 *


		 * @type   {function}


		 * @param  {node} cell `th` / `td` element to read the value from


		 * @return {string}    Data that has been read


		 */


		read: function ( cell ) {


			return $(cell).html();


		},





		/**


		 * Cell write function


		 *


		 * Default function will simply write to the HTML and tell the DataTable


		 * to update.


		 *


		 * @type   {function}


		 * @param  {node} cell `th` / `td` element to write the value to


		 * @return {string}    Data two write


		 */


		write: function ( cell, val ) {


			var table = $(cell).parents('table');


			if ( DataTable.Api ) {


				// 1.10


				table.DataTable().cell( cell ).data( val );


			}


			else {


				// 1.9


				var dt = table.dataTable();


				var pos = dt.fnGetPosition( cell );


				dt.fnUpdate( val, pos[0], pos[2], false );


			}


		},





		/**


		 * Step function. This provides the ability to customise how the values


		 * are incremented.


		 *


		 * @param  {node} cell `th` / `td` element that is being operated upon


		 * @param  {string} read Cell value from `read` function


		 * @param  {string} last Value of the previous cell


		 * @param  {integer} i Loop counter


		 * @param  {integer} x Cell x-position in the current auto-fill. The


		 *   starting cell is coordinate 0 regardless of its physical position


		 *   in the DataTable.


		 * @param  {integer} y Cell y-position in the current auto-fill. The


		 *   starting cell is coordinate 0 regardless of its physical position


		 *   in the DataTable.


		 * @return {string} Value to write


		 */


		step: function ( cell, read, last, i, x, y ) {


			// Increment a number if it is found


			var re = /(\-?\d+)/;


			var match = this.increment && last ? last.match(re) : null;


			if ( match ) {


				return last.replace( re, parseInt(match[1],10) + (x<0 || y<0 ? -1 : 1) );


			}


			return last === undefined ?


				read :


				last;


		}


	}


};





return AutoFill;


};








// Define as an AMD module if possible


if ( typeof define === 'function' && define.amd ) {


	define( ['jquery', 'datatables'], factory );


}


else if ( typeof exports === 'object' ) {


    // Node/CommonJS


    factory( require('jquery'), require('datatables') );


}


else if ( jQuery && !jQuery.fn.dataTable.AutoFill ) {


	// Otherwise simply initialise as normal, stopping multiple evaluation


	factory( jQuery, jQuery.fn.dataTable );


}








}(window, document));





