text: /*
  * FooTable v3 - FooTable is a jQuery plugin that aims to make HTML tables on smaller devices look awesome.
  * @version 3.1.6
  * @link http://fooplugins.com
  * @copyright Steven Usher & Brad Vincent 2015
  * @license Released under the GPLv3 license.
  */
  (function($, F){
  
  	F.Export = F.Component.extend(/** @lends FooTable.Export */{
  		/**
  		 * @summary This component provides some basic export functionality.
  		 * @memberof FooTable
  		 * @constructs Export
  		 * @param {FooTable.Table} table - The current instance of the plugin.
  		 */
  		construct: function(table){
  			// call the constructor of the base class
  			this._super(table, true);
  			/**
  			 * @summary A snapshot of the working set of rows prior to being trimmed by the paging component.
  			 * @memberof FooTable.Export#
  			 * @name snapshot
  			 * @type {FooTable.Row[]}
  			 */
  			this.snapshot = [];
  		},
  		/**
  		 * @summary Hooks into the predraw pipeline after sorting and filtering have taken place but prior to paging.
  		 * @memberof FooTable.Export#
  		 * @function predraw
  		 * @description This method allows us to take a snapshot of the working set of rows before they are trimmed by the paging component and is called by the plugin instance.
  		 */
  		predraw: function(){
  			this.snapshot = this.ft.rows.array.slice(0);
  		},
  		/**
  		 * @summary Return the columns as simple JavaScript objects in an array.
  		 * @memberof FooTable.Export#
  		 * @function columns
  		 * @returns {Object[]}
  		 */
  		columns: function(){
  			var result = [];
  			F.arr.each(this.ft.columns.array, function(column){
  				if (!column.internal){
  					result.push({
  						type: column.type,
  						name: column.name,
  						title: column.title,
  						visible: column.visible,
  						hidden: column.hidden,
  						classes: column.classes,
  						style: column.style
  					});
  				}
  			});
  			return result;
  		},
  		/**
  		 * @summary Return the rows as simple JavaScript objects in an array.
  		 * @memberof FooTable.Export#
  		 * @function rows
  		 * @param {boolean} [filtered=false] - Whether or not to exclude filtered rows from the result.
  		 * @returns {Object[]}
  		 */
  		rows: function(filtered){
  			filtered = F.is.boolean(filtered) ? filtered : false;
  			var rows = filtered ? this.ft.rows.all : this.snapshot, result = [];
  			F.arr.each(rows, function(row){
  				result.push(row.val());
  			});
  			return result;
  		},
  		/**
  		 * @summary Return the columns and rows as a properly formatted JSON object.
  		 * @memberof FooTable.Export#
  		 * @function json
  		 * @param {boolean} [filtered=false] - Whether or not to exclude filtered rows from the result.
  		 * @returns {Object}
  		 */
  		json: function(filtered){
  			return JSON.parse(JSON.stringify({columns: this.columns(),rows: this.rows(filtered)}));
  		},
  		/**
  		 * @summary Return the columns and rows as a properly formatted CSV value.
  		 * @memberof FooTable.Export#
  		 * @function csv
  		 * @param {boolean} [filtered=false] - Whether or not to exclude filtered rows from the result.
  		 * @returns {string}
  		 */
  		csv: function(filtered){
  			var csv = "", columns = this.columns(), value, escaped;
  			F.arr.each(columns, function(column, i){
  				escaped = '"' + column.title.replace(/"/g, '""') + '"';
  				csv += (i === 0 ? escaped : "," + escaped);
  			});
  			csv += "\n";
  
  			var rows = filtered ? this.ft.rows.all : this.snapshot;
  			F.arr.each(rows, function(row){
  				F.arr.each(row.cells, function(cell, i){
  					if (!cell.column.internal){
  						value = cell.column.stringify.call(cell.column, cell.value, cell.ft.o, cell.row.value);
  						escaped = '"' + value.replace(/"/g, '""') + '"';
  						csv += (i === 0 ? escaped : "," + escaped);
  					}
  				});
  				csv += "\n";
  			});
  			return csv;
  		}
  	});
  
  	// register the component using a priority of 490 which falls just after filtering (500) and before paging (400).
  	F.components.register("export", F.Export, 490);
  
  })(jQuery, FooTable);
  (function(F){
  	// this is used to define the filtering specific properties on column creation
  	F.Column.prototype.__export_define__ = function(definition){
  		this.stringify = F.checkFnValue(this, definition.stringify, this.stringify);
  	};
  
  	// overrides the public define method and replaces it with our own
  	F.Column.extend('define', function(definition){
  		this._super(definition); // call the base so we don't have to redefine any previously set properties
  		this.__export_define__(definition); // then call our own
  	});
  
  	/**
  	 * @summary Return the supplied value as a string.
  	 * @memberof FooTable.Column#
  	 * @function stringify
  	 * @returns {string}
  	 */
  	F.Column.prototype.stringify = function(value, options, rowData){
  		return value + "";
  	};
  
  	if (F.is.defined(F.DateColumn)){
  		// override the base method for DateColumns
  		F.DateColumn.prototype.stringify = function(value, options, rowData){
  			return F.is.object(value) && F.is.boolean(value._isAMomentObject) && value.isValid() ? value.format(this.formatString) : '';
  		};
  	}
  
  	// override the base method for ObjectColumns
  	F.ObjectColumn.prototype.stringify = function(value, options, rowData){
  		return F.is.object(value) ? JSON.stringify(value) : "";
  	};
  
  	// override the base method for ArrayColumns
  	F.ArrayColumn.prototype.stringify = function(value, options, rowData){
  		return F.is.array(value) ? JSON.stringify(value) : "";
  	};
  
  })(FooTable);
  (function(F){
  	/**
  	 * @summary Return the columns and rows as a properly formatted JSON object.
  	 * @memberof FooTable.Table#
  	 * @function toJSON
  	 * @param {boolean} [filtered=false] - Whether or not to exclude filtered rows from the result.
  	 * @returns {Object}
  	 */
  	F.Table.prototype.toJSON = function(filtered){
  		return this.use(F.Export).json(filtered);
  	};
  
  	/**
  	 * @summary Return the columns and rows as a properly formatted CSV value.
  	 * @memberof FooTable.Table#
  	 * @function toCSV
  	 * @param {boolean} [filtered=false] - Whether or not to exclude filtered rows from the result.
  	 * @returns {string}
  	 */
  	F.Table.prototype.toCSV = function(filtered){
  		return this.use(F.Export).csv(filtered);
  	};
  
  })(FooTable);