3  * version: 3.37.0-2013.07.11

     3  * version: 4.2.1

     4  * @requires jQuery v1.5 or later

     4  * Requires jQuery v1.7 or later

     5  * Copyright (c) 2013 M. Alsup

     5  * Copyright 2017 Kevin Morris

     6  * Examples and documentation at: http://malsup.com/jquery/form/

     6  * Copyright 2006 M. Alsup

     7  * Project repository: https://github.com/malsup/form

     7  * Project repository: https://github.com/jquery-form/form

     8  * Dual licensed under the MIT and GPL licenses.

     8  * Dual licensed under the MIT and LGPLv3 licenses.

     9  * https://github.com/malsup/form#copyright-and-license

     9  * https://github.com/jquery-form/form#license

    11 /*global ActiveXObject */

    11 /* global ActiveXObject */

    12 ;(function($) {

    12 

    13 "use strict";

    13 /* eslint-disable */

    14 

    14 (function (factory) {

    15 /*

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

    16     Usage Note:

    16 		// AMD. Register as an anonymous module.

    17     -----------

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

    18     Do not use both ajaxSubmit and ajaxForm on the same form.  These

    18 	} else if (typeof module === 'object' && module.exports) {

    19     functions are mutually exclusive.  Use ajaxSubmit if you want

    19 		// Node/CommonJS

    20     to bind your own submit handler to the form.  For example,

    20 		module.exports = function( root, jQuery ) {

    21 

    21 			if (typeof jQuery === 'undefined') {

    22     $(document).ready(function() {

    22 				// require('jQuery') returns a factory that requires window to build a jQuery instance, we normalize how we use modules

    23         $('#myForm').on('submit', function(e) {

    23 				// that require this pattern but the window provided is a noop if it's defined (how jquery works)

    24             e.preventDefault(); // <-- important

    24 				if (typeof window !== 'undefined') {

    25             $(this).ajaxSubmit({

    25 					jQuery = require('jquery');

    26                 target: '#output'

    26 				}

    27             });

    27 				else {

    28         });

    28 					jQuery = require('jquery')(root);

    29     });

    29 				}

    30 

    30 			}

    31     Use ajaxForm when you want the plugin to manage all the event binding

    31 			factory(jQuery);

    32     for you.  For example,

    32 			return jQuery;

    33 

    33 		};

    34     $(document).ready(function() {

    34 	} else {

    35         $('#myForm').ajaxForm({

    35 		// Browser globals

    36             target: '#output'

    36 		factory(jQuery);

    37         });

    37 	}

    38     });

    38 

    39 

    39 }(function ($) {

    40     You can also use ajaxForm with delegation (requires jQuery v1.7+), so the

    40 /* eslint-enable */

    41     form does not have to exist when you invoke ajaxForm:

    41 	'use strict';

    42 

    42 

    43     $('#myForm').ajaxForm({

    43 	/*

    44         delegation: true,

    44 		Usage Note:

    45         target: '#output'

    45 		-----------

    46     });

    46 		Do not use both ajaxSubmit and ajaxForm on the same form. These

    47 

    47 		functions are mutually exclusive. Use ajaxSubmit if you want

    48     When using ajaxForm, the ajaxSubmit function will be invoked for you

    48 		to bind your own submit handler to the form. For example,

    49     at the appropriate time.

    49 

    50 */

    50 		$(document).ready(function() {

    51 

    51 			$('#myForm').on('submit', function(e) {

    52 /**

    52 				e.preventDefault(); // <-- important

    53  * Feature detection

    53 				$(this).ajaxSubmit({

    54  */

    54 					target: '#output'

    55 var feature = {};

    55 				});

    56 feature.fileapi = $("<input type='file'/>").get(0).files !== undefined;

    56 			});

    57 feature.formdata = window.FormData !== undefined;

    57 		});

    58 

    58 

    59 var hasProp = !!$.fn.prop;

    59 		Use ajaxForm when you want the plugin to manage all the event binding

    60 

    60 		for you. For example,

    61 // attr2 uses prop when it can but checks the return type for

    61 

    62 // an expected string.  this accounts for the case where a form 

    62 		$(document).ready(function() {

    63 // contains inputs with names like "action" or "method"; in those

    63 			$('#myForm').ajaxForm({

    64 // cases "prop" returns the element

    64 				target: '#output'

    65 $.fn.attr2 = function() {

    65 			});

    66     if ( ! hasProp )

    66 		});

    67         return this.attr.apply(this, arguments);

    67 

    68     var val = this.prop.apply(this, arguments);

    68 		You can also use ajaxForm with delegation (requires jQuery v1.7+), so the

    69     if ( ( val && val.jquery ) || typeof val === 'string' )

    69 		form does not have to exist when you invoke ajaxForm:

    70         return val;

    70 

    71     return this.attr.apply(this, arguments);

    71 		$('#myForm').ajaxForm({

    72 };

    72 			delegation: true,

    73 

    73 			target: '#output'

    74 /**

    74 		});

    75  * ajaxSubmit() provides a mechanism for immediately submitting

    75 

    76  * an HTML form using AJAX.

    76 		When using ajaxForm, the ajaxSubmit function will be invoked for you

    77  */

    77 		at the appropriate time.

    78 $.fn.ajaxSubmit = function(options) {

    78 	*/

    79     /*jshint scripturl:true */

    79 

    80 

    80 	var rCRLF = /\r?\n/g;

    81     // fast fail if nothing selected (http://dev.jquery.com/ticket/2752)

    81 

    82     if (!this.length) {

    82 	/**

    83         log('ajaxSubmit: skipping submit process - no element selected');

    83 	 * Feature detection

    84         return this;

    84 	 */

    85     }

    85 	var feature = {};

    86 

    86 

    87     var method, action, url, $form = this;

    87 	feature.fileapi = $('<input type="file">').get(0).files !== undefined;

    88 

    88 	feature.formdata = (typeof window.FormData !== 'undefined');

    89     if (typeof options == 'function') {

    89 

    90         options = { success: options };

    90 	var hasProp = !!$.fn.prop;

    91     }

    91 

    92     else if ( options === undefined ) {

    92 	// attr2 uses prop when it can but checks the return type for

    93         options = {};

    93 	// an expected string. This accounts for the case where a form

    94     }

    94 	// contains inputs with names like "action" or "method"; in those

    95 

    95 	// cases "prop" returns the element

    96     method = options.type || this.attr2('method');

    96 	$.fn.attr2 = function() {

    97     action = options.url  || this.attr2('action');

    97 		if (!hasProp) {

    98 

    98 			return this.attr.apply(this, arguments);

    99     url = (typeof action === 'string') ? $.trim(action) : '';

    99 		}

   100     url = url || window.location.href || '';

   100 

   101     if (url) {

   101 		var val = this.prop.apply(this, arguments);

   102         // clean url (don't include hash vaue)

   102 

   103         url = (url.match(/^([^#]+)/)||[])[1];

   103 		if ((val && val.jquery) || typeof val === 'string') {

   104     }

   104 			return val;

   105 

   105 		}

   106     options = $.extend(true, {

   106 

   107         url:  url,

   107 		return this.attr.apply(this, arguments);

   108         success: $.ajaxSettings.success,

   108 	};

   109         type: method || 'GET',

   109 

   110         iframeSrc: /^https/i.test(window.location.href || '') ? 'javascript:false' : 'about:blank'

   110 	/**

   111     }, options);

   111 	 * ajaxSubmit() provides a mechanism for immediately submitting

   112 

   112 	 * an HTML form using AJAX.

   113     // hook for manipulating the form data before it is extracted;

   113 	 *

   114     // convenient for use with rich editors like tinyMCE or FCKEditor

   114 	 * @param	{object|string}	options		jquery.form.js parameters or custom url for submission

   115     var veto = {};

   115 	 * @param	{object}		data		extraData

   116     this.trigger('form-pre-serialize', [this, options, veto]);

   116 	 * @param	{string}		dataType	ajax dataType

   117     if (veto.veto) {

   117 	 * @param	{function}		onSuccess	ajax success callback function

   118         log('ajaxSubmit: submit vetoed via form-pre-serialize trigger');

   118 	 */

   119         return this;

   119 	$.fn.ajaxSubmit = function(options, data, dataType, onSuccess) {

   120     }

   120 		// fast fail if nothing selected (http://dev.jquery.com/ticket/2752)

   121 

   121 		if (!this.length) {

   122     // provide opportunity to alter form data before it is serialized

   122 			log('ajaxSubmit: skipping submit process - no element selected');

   123     if (options.beforeSerialize && options.beforeSerialize(this, options) === false) {

   123 

   124         log('ajaxSubmit: submit aborted via beforeSerialize callback');

   124 			return this;

   125         return this;

   125 		}

   126     }

   126 

   127 

   127 		/* eslint consistent-this: ["error", "$form"] */

   128     var traditional = options.traditional;

   128 		var method, action, url, $form = this;

   129     if ( traditional === undefined ) {

   129 

   130         traditional = $.ajaxSettings.traditional;

   130 		if (typeof options === 'function') {

   131     }

   131 			options = {success: options};

   132 

   132 

   133     var elements = [];

   133 		} else if (typeof options === 'string' || (options === false && arguments.length > 0)) {

   134     var qx, a = this.formToArray(options.semantic, elements);

   134 			options = {

   135     if (options.data) {

   135 				'url'      : options,

   136         options.extraData = options.data;

   136 				'data'     : data,

   137         qx = $.param(options.data, traditional);

   137 				'dataType' : dataType

   138     }

   138 			};

   139 

   139 

   140     // give pre-submit callback an opportunity to abort the submit

   140 			if (typeof onSuccess === 'function') {

   141     if (options.beforeSubmit && options.beforeSubmit(a, this, options) === false) {

   141 				options.success = onSuccess;

   142         log('ajaxSubmit: submit aborted via beforeSubmit callback');

   142 			}

   143         return this;

   143 

   144     }

   144 		} else if (typeof options === 'undefined') {

   145 

   145 			options = {};

   146     // fire vetoable 'validate' event

   146 		}

   147     this.trigger('form-submit-validate', [a, this, options, veto]);

   147 

   148     if (veto.veto) {

   148 		method = options.method || options.type || this.attr2('method');

   149         log('ajaxSubmit: submit vetoed via form-submit-validate trigger');

   149 		action = options.url || this.attr2('action');

   150         return this;

   150 

   151     }

   151 		url = (typeof action === 'string') ? $.trim(action) : '';

   152 

   152 		url = url || window.location.href || '';

   153     var q = $.param(a, traditional);

   153 		if (url) {

   154     if (qx) {

   154 			// clean url (don't include hash vaue)

   155         q = ( q ? (q + '&' + qx) : qx );

   155 			url = (url.match(/^([^#]+)/) || [])[1];

   156     }

   156 		}

   157     if (options.type.toUpperCase() == 'GET') {

   157 

   158         options.url += (options.url.indexOf('?') >= 0 ? '&' : '?') + q;

   158 		options = $.extend(true, {

   159         options.data = null;  // data is null for 'get'

   159 			url       : url,

   160     }

   160 			success   : $.ajaxSettings.success,

   161     else {

   161 			type      : method || $.ajaxSettings.type,

   162         options.data = q; // data is the query string for 'post'

   162 			iframeSrc : /^https/i.test(window.location.href || '') ? 'javascript:false' : 'about:blank'		// eslint-disable-line no-script-url

   163     }

   163 		}, options);

   164 

   164 

   165     var callbacks = [];

   165 		// hook for manipulating the form data before it is extracted;

   166     if (options.resetForm) {

   166 		// convenient for use with rich editors like tinyMCE or FCKEditor

   167         callbacks.push(function() { $form.resetForm(); });

   167 		var veto = {};

   168     }

   168 

   169     if (options.clearForm) {

   169 		this.trigger('form-pre-serialize', [this, options, veto]);

   170         callbacks.push(function() { $form.clearForm(options.includeHidden); });

   170 

   171     }

   171 		if (veto.veto) {

   172 

   172 			log('ajaxSubmit: submit vetoed via form-pre-serialize trigger');

   173     // perform a load on the target only if dataType is not provided

   173 

   174     if (!options.dataType && options.target) {

   174 			return this;

   175         var oldSuccess = options.success || function(){};

   175 		}

   176         callbacks.push(function(data) {

   176 

   177             var fn = options.replaceTarget ? 'replaceWith' : 'html';

   177 		// provide opportunity to alter form data before it is serialized

   178             $(options.target)[fn](data).each(oldSuccess, arguments);

   178 		if (options.beforeSerialize && options.beforeSerialize(this, options) === false) {

   179         });

   179 			log('ajaxSubmit: submit aborted via beforeSerialize callback');

   180     }

   180 

   181     else if (options.success) {

   181 			return this;

   182         callbacks.push(options.success);

   182 		}

   183     }

   183 

   184 

   184 		var traditional = options.traditional;

   185     options.success = function(data, status, xhr) { // jQuery 1.4+ passes xhr as 3rd arg

   185 

   186         var context = options.context || this ;    // jQuery 1.4+ supports scope context

   186 		if (typeof traditional === 'undefined') {

   187         for (var i=0, max=callbacks.length; i < max; i++) {

   187 			traditional = $.ajaxSettings.traditional;

   188             callbacks[i].apply(context, [data, status, xhr || $form, $form]);

   188 		}

   189         }

   189 

   190     };

   190 		var elements = [];

   191 

   191 		var qx, a = this.formToArray(options.semantic, elements, options.filtering);

   192     if (options.error) {

   192 

   193         var oldError = options.error;

   193 		if (options.data) {

   194         options.error = function(xhr, status, error) {

   194 			var optionsData = $.isFunction(options.data) ? options.data(a) : options.data;

   195             var context = options.context || this;

   195 

   196             oldError.apply(context, [xhr, status, error, $form]);

   196 			options.extraData = optionsData;

   197         };

   197 			qx = $.param(optionsData, traditional);

   198     }

   198 		}

   199 

   199 

   200      if (options.complete) {

   200 		// give pre-submit callback an opportunity to abort the submit

   201         var oldComplete = options.complete;

   201 		if (options.beforeSubmit && options.beforeSubmit(a, this, options) === false) {

   202         options.complete = function(xhr, status) {

   202 			log('ajaxSubmit: submit aborted via beforeSubmit callback');

   203             var context = options.context || this;

   203 

   204             oldComplete.apply(context, [xhr, status, $form]);

   204 			return this;

   205         };

   205 		}

   206     }

   206 

   207 

   207 		// fire vetoable 'validate' event

   208     // are there files to upload?

   208 		this.trigger('form-submit-validate', [a, this, options, veto]);

   209 

   209 		if (veto.veto) {

   210     // [value] (issue #113), also see comment:

   210 			log('ajaxSubmit: submit vetoed via form-submit-validate trigger');

   211     // https://github.com/malsup/form/commit/588306aedba1de01388032d5f42a60159eea9228#commitcomment-2180219

   211 

   212     var fileInputs = $('input[type=file]:enabled[value!=""]', this);

   212 			return this;

   213 

   213 		}

   214     var hasFileInputs = fileInputs.length > 0;

   214 

   215     var mp = 'multipart/form-data';

   215 		var q = $.param(a, traditional);

   216     var multipart = ($form.attr('enctype') == mp || $form.attr('encoding') == mp);

   216 

   217 

   217 		if (qx) {

   218     var fileAPI = feature.fileapi && feature.formdata;

   218 			q = (q ? (q + '&' + qx) : qx);

   219     log("fileAPI :" + fileAPI);

   219 		}

   220     var shouldUseFrame = (hasFileInputs || multipart) && !fileAPI;

   220 

   221 

   221 		if (options.type.toUpperCase() === 'GET') {

   222     var jqxhr;

   222 			options.url += (options.url.indexOf('?') >= 0 ? '&' : '?') + q;

   223 

   223 			options.data = null;	// data is null for 'get'

   224     // options.iframe allows user to force iframe mode

   224 		} else {

   225     // 06-NOV-09: now defaulting to iframe mode if file input is detected

   225 			options.data = q;		// data is the query string for 'post'

   226     if (options.iframe !== false && (options.iframe || shouldUseFrame)) {

   226 		}

   227         // hack to fix Safari hang (thanks to Tim Molendijk for this)

   227 

   228         // see:  http://groups.google.com/group/jquery-dev/browse_thread/thread/36395b7ab510dd5d

   228 		var callbacks = [];

   229         if (options.closeKeepAlive) {

   229 

   230             $.get(options.closeKeepAlive, function() {

   230 		if (options.resetForm) {

   231                 jqxhr = fileUploadIframe(a);

   231 			callbacks.push(function() {

   232             });

   232 				$form.resetForm();

   233         }

   233 			});

   234         else {

   234 		}

   235             jqxhr = fileUploadIframe(a);

   235 

   236         }

   236 		if (options.clearForm) {

   237     }

   237 			callbacks.push(function() {

   238     else if ((hasFileInputs || multipart) && fileAPI) {

   238 				$form.clearForm(options.includeHidden);

   239         jqxhr = fileUploadXhr(a);

   239 			});

   240     }

   240 		}

   241     else {

   241 

   242         jqxhr = $.ajax(options);

   242 		// perform a load on the target only if dataType is not provided

   243     }

   243 		if (!options.dataType && options.target) {

   244 

   244 			var oldSuccess = options.success || function(){};

   245     $form.removeData('jqxhr').data('jqxhr', jqxhr);

   245 

   246 

   246 			callbacks.push(function(data, textStatus, jqXHR) {

   247     // clear element array

   247 				var successArguments = arguments,

   248     for (var k=0; k < elements.length; k++)

   248 					fn = options.replaceTarget ? 'replaceWith' : 'html';

   249         elements[k] = null;

   249 

   250 

   250 				$(options.target)[fn](data).each(function(){

   251     // fire 'notify' event

   251 					oldSuccess.apply(this, successArguments);

   252     this.trigger('form-submit-notify', [this, options]);

   252 				});

   253     return this;

   253 			});

   254 

   254 

   255     // utility fn for deep serialization

   255 		} else if (options.success) {

   256     function deepSerialize(extraData){

   256 			if ($.isArray(options.success)) {

   257         var serialized = $.param(extraData, options.traditional).split('&');

   257 				$.merge(callbacks, options.success);

   258         var len = serialized.length;

   259         var result = [];

   260         var i, part;

   261         for (i=0; i < len; i++) {

   262             // #252; undo param space replacement

   263             serialized[i] = serialized[i].replace(/\+/g,' ');

   264             part = serialized[i].split('=');

   265             // #278; use array instead of object storage, favoring array serializations

   266             result.push([decodeURIComponent(part[0]), decodeURIComponent(part[1])]);

   267         }

   268         return result;

   269     }

   270 

   271      // XMLHttpRequest Level 2 file uploads (big hat tip to francois2metz)

   272     function fileUploadXhr(a) {

   273         var formdata = new FormData();

   274 

   275         for (var i=0; i < a.length; i++) {

   276             formdata.append(a[i].name, a[i].value);

   277         }

   278 

   279         if (options.extraData) {

   280             var serializedData = deepSerialize(options.extraData);

   281             for (i=0; i < serializedData.length; i++)

   282                 if (serializedData[i])

   283                     formdata.append(serializedData[i][0], serializedData[i][1]);

   284         }

   285 

   286         options.data = null;

   287 

   288         var s = $.extend(true, {}, $.ajaxSettings, options, {

   289             contentType: false,

   290             processData: false,

   291             cache: false,

   292             type: method || 'POST'

   293         });

   294 

   295         if (options.uploadProgress) {

   296             // workaround because jqXHR does not expose upload property

   297             s.xhr = function() {

   298                 var xhr = $.ajaxSettings.xhr();

   299                 if (xhr.upload) {

   300                     xhr.upload.addEventListener('progress', function(event) {

   301                         var percent = 0;

   302                         var position = event.loaded || event.position; /*event.position is deprecated*/

   303                         var total = event.total;

   304                         if (event.lengthComputable) {

   305                             percent = Math.ceil(position / total * 100);

   306                         }

   307                         options.uploadProgress(event, position, total, percent);

   308                     }, false);

   309                 }

   310                 return xhr;

   311             };

   312         }

   313 

   314         s.data = null;

   315             var beforeSend = s.beforeSend;

   316             s.beforeSend = function(xhr, o) {

   317                 o.data = formdata;

   318                 if(beforeSend)

   319                     beforeSend.call(this, xhr, o);

   320         };

   321         return $.ajax(s);

   322     }

   323 

   324     // private function for handling file uploads (hat tip to YAHOO!)

   325     function fileUploadIframe(a) {

   326         var form = $form[0], el, i, s, g, id, $io, io, xhr, sub, n, timedOut, timeoutHandle;

   327         var deferred = $.Deferred();

   328 

   329         if (a) {

   330             // ensure that every serialized input is still enabled

   331             for (i=0; i < elements.length; i++) {

   332                 el = $(elements[i]);

   333                 if ( hasProp )

   334                     el.prop('disabled', false);

   335                 else

   336                     el.removeAttr('disabled');

   337             }

   338         }

   339 

   340         s = $.extend(true, {}, $.ajaxSettings, options);

   341         s.context = s.context || s;

   342         id = 'jqFormIO' + (new Date().getTime());

   343         if (s.iframeTarget) {

   344             $io = $(s.iframeTarget);

   345             n = $io.attr2('name');

   346             if (!n)

   347                  $io.attr2('name', id);

   348             else

   349                 id = n;

   350         }

   351         else {

   352             $io = $('<iframe name="' + id + '" src="'+ s.iframeSrc +'" />');

   353             $io.css({ position: 'absolute', top: '-1000px', left: '-1000px' });

   354         }

   355         io = $io[0];

   356 

   357 

   358         xhr = { // mock object

   359             aborted: 0,

   360             responseText: null,

   361             responseXML: null,

   362             status: 0,

   363             statusText: 'n/a',

   364             getAllResponseHeaders: function() {},

   365             getResponseHeader: function() {},

   366             setRequestHeader: function() {},

   367             abort: function(status) {

   368                 var e = (status === 'timeout' ? 'timeout' : 'aborted');

   369                 log('aborting upload... ' + e);

   370                 this.aborted = 1;

   371 

   372                 try { // #214, #257

   373                     if (io.contentWindow.document.execCommand) {

   374                         io.contentWindow.document.execCommand('Stop');

   375                     }

   376                 }

   377                 catch(ignore) {}

   378 

   379                 $io.attr('src', s.iframeSrc); // abort op in progress

   380                 xhr.error = e;

   381                 if (s.error)

   382                     s.error.call(s.context, xhr, e, status);

   383                 if (g)

   384                     $.event.trigger("ajaxError", [xhr, s, e]);

   385                 if (s.complete)

   386                     s.complete.call(s.context, xhr, e);

   387             }

   388         };

   389 

   390         g = s.global;

   391         // trigger ajax global events so that activity/block indicators work like normal

   392         if (g && 0 === $.active++) {

   393             $.event.trigger("ajaxStart");

   394         }

   395         if (g) {

   396             $.event.trigger("ajaxSend", [xhr, s]);

   397         }

   398 

   399         if (s.beforeSend && s.beforeSend.call(s.context, xhr, s) === false) {

   400             if (s.global) {

   401                 $.active--;

   402             }

   403             deferred.reject();

   404             return deferred;

   405         }

   406         if (xhr.aborted) {

   407             deferred.reject();

   408             return deferred;

   409         }

   410 

   411         // add submitting element to data if we know it

   412         sub = form.clk;

   413         if (sub) {

   414             n = sub.name;

   415             if (n && !sub.disabled) {

   416                 s.extraData = s.extraData || {};

   417                 s.extraData[n] = sub.value;

   418                 if (sub.type == "image") {

   419                     s.extraData[n+'.x'] = form.clk_x;

   420                     s.extraData[n+'.y'] = form.clk_y;

   421                 }

   422             }

   423         }

   424 

   425         var CLIENT_TIMEOUT_ABORT = 1;

   426         var SERVER_ABORT = 2;

   427                 

   428         function getDoc(frame) {

   429             /* it looks like contentWindow or contentDocument do not

   430              * carry the protocol property in ie8, when running under ssl

   431              * frame.document is the only valid response document, since

   432              * the protocol is know but not on the other two objects. strange?

   433              * "Same origin policy" http://en.wikipedia.org/wiki/Same_origin_policy

   434              */

   435             

   436             var doc = null;

   437             

   438             // IE8 cascading access check

   439             try {

   440                 if (frame.contentWindow) {

   441                     doc = frame.contentWindow.document;

   442                 }

   443             } catch(err) {

   444                 // IE8 access denied under ssl & missing protocol

   445                 log('cannot get iframe.contentWindow document: ' + err);

   446             }

   447 

   448             if (doc) { // successful getting content

   449                 return doc;

   450             }

   451 

   452             try { // simply checking may throw in ie8 under ssl or mismatched protocol

   453                 doc = frame.contentDocument ? frame.contentDocument : frame.document;

   454             } catch(err) {

   455                 // last attempt

   456                 log('cannot get iframe.contentDocument: ' + err);

   457                 doc = frame.document;

   458             }

   459             return doc;

   460         }

   461 

   462         // Rails CSRF hack (thanks to Yvan Barthelemy)

   463         var csrf_token = $('meta[name=csrf-token]').attr('content');

   464         var csrf_param = $('meta[name=csrf-param]').attr('content');

   465         if (csrf_param && csrf_token) {

   466             s.extraData = s.extraData || {};

   467             s.extraData[csrf_param] = csrf_token;

   468         }

   469 

   470         // take a breath so that pending repaints get some cpu time before the upload starts

   471         function doSubmit() {

   472             // make sure form attrs are set

   473             var t = $form.attr2('target'), a = $form.attr2('action');

   474 

   475             // update form attrs in IE friendly way

   476             form.setAttribute('target',id);

   477             if (!method) {

   478                 form.setAttribute('method', 'POST');

   479             }

   480             if (a != s.url) {

   481                 form.setAttribute('action', s.url);

   482             }

   483 

   484             // ie borks in some cases when setting encoding

   485             if (! s.skipEncodingOverride && (!method || /post/i.test(method))) {

   486                 $form.attr({

   487                     encoding: 'multipart/form-data',

   488                     enctype:  'multipart/form-data'

   489                 });

   490             }

   491 

   492             // support timout

   493             if (s.timeout) {

   494                 timeoutHandle = setTimeout(function() { timedOut = true; cb(CLIENT_TIMEOUT_ABORT); }, s.timeout);

   495             }

   496 

   497             // look for server aborts

   498             function checkState() {

   499                 try {

   500                     var state = getDoc(io).readyState;

   501                     log('state = ' + state);

   502                     if (state && state.toLowerCase() == 'uninitialized')

   503                         setTimeout(checkState,50);

   504                 }

   505                 catch(e) {

   506                     log('Server abort: ' , e, ' (', e.name, ')');

   507                     cb(SERVER_ABORT);

   508                     if (timeoutHandle)

   509                         clearTimeout(timeoutHandle);

   510                     timeoutHandle = undefined;

   511                 }

   512             }

   513 

   514             // add "extra" data to form if provided in options

   515             var extraInputs = [];

   516             try {

   517                 if (s.extraData) {

   518                     for (var n in s.extraData) {

   519                         if (s.extraData.hasOwnProperty(n)) {

   520                            // if using the $.param format that allows for multiple values with the same name

   521                            if($.isPlainObject(s.extraData[n]) && s.extraData[n].hasOwnProperty('name') && s.extraData[n].hasOwnProperty('value')) {

   522                                extraInputs.push(

   523                                $('<input type="hidden" name="'+s.extraData[n].name+'">').val(s.extraData[n].value)

   524                                    .appendTo(form)[0]);

   525                            } else {

   526                                extraInputs.push(

   527                                $('<input type="hidden" name="'+n+'">').val(s.extraData[n])

   528                                    .appendTo(form)[0]);

   529                            }

   530                         }

   531                     }

   532                 }

   533 

   534                 if (!s.iframeTarget) {

   535                     // add iframe to doc and submit the form

   536                     $io.appendTo('body');

   537                     if (io.attachEvent)

   538                         io.attachEvent('onload', cb);

   539                     else

   540                         io.addEventListener('load', cb, false);

   541                 }

   542                 setTimeout(checkState,15);

   543 

   544                 try {

   545                     form.submit();

   546                 } catch(err) {

   547                     // just in case form has element with name/id of 'submit'

   548                     var submitFn = document.createElement('form').submit;

   549                     submitFn.apply(form);

   550                 }

   551             }

   552             finally {

   553                 // reset attrs and remove "extra" input elements

   554                 form.setAttribute('action',a);

   555                 if(t) {

   556                     form.setAttribute('target', t);

   557                 } else {

   558                     $form.removeAttr('target');

   559                 }

   560                 $(extraInputs).remove();

   561             }

   562         }

   563 

   564         if (s.forceSync) {

   565             doSubmit();

   566         }

   567         else {

   568             setTimeout(doSubmit, 10); // this lets dom updates render

   569         }

   570 

   571         var data, doc, domCheckCount = 50, callbackProcessed;

   572 

   573         function cb(e) {

   574             if (xhr.aborted || callbackProcessed) {

   575                 return;

   576             }

   577             

   578             doc = getDoc(io);

   579             if(!doc) {

   580                 log('cannot access response document');

   581                 e = SERVER_ABORT;

   582             }

   583             if (e === CLIENT_TIMEOUT_ABORT && xhr) {

   584                 xhr.abort('timeout');

   585                 deferred.reject(xhr, 'timeout');

   586                 return;

   587             }

   588             else if (e == SERVER_ABORT && xhr) {

   589                 xhr.abort('server abort');

   590                 deferred.reject(xhr, 'error', 'server abort');

   591                 return;

   592             }

   593 

   594             if (!doc || doc.location.href == s.iframeSrc) {

   595                 // response not received yet

   596                 if (!timedOut)

   597                     return;

   598             }

   599             if (io.detachEvent)

   600                 io.detachEvent('onload', cb);

   601             else

   602                 io.removeEventListener('load', cb, false);

   603 

   604             var status = 'success', errMsg;

   605             try {

   606                 if (timedOut) {

   607                     throw 'timeout';

   608                 }

   609 

   610                 var isXml = s.dataType == 'xml' || doc.XMLDocument || $.isXMLDoc(doc);

   611                 log('isXml='+isXml);

   612                 if (!isXml && window.opera && (doc.body === null || !doc.body.innerHTML)) {

   613                     if (--domCheckCount) {

   614                         // in some browsers (Opera) the iframe DOM is not always traversable when

   615                         // the onload callback fires, so we loop a bit to accommodate

   616                         log('requeing onLoad callback, DOM not available');

   617                         setTimeout(cb, 250);

   618                         return;

   619                     }

   620                     // let this fall through because server response could be an empty document

   621                     //log('Could not access iframe DOM after mutiple tries.');

   622                     //throw 'DOMException: not available';

   623                 }

   624 

   625                 //log('response detected');

   626                 var docRoot = doc.body ? doc.body : doc.documentElement;

   627                 xhr.responseText = docRoot ? docRoot.innerHTML : null;

   628                 xhr.responseXML = doc.XMLDocument ? doc.XMLDocument : doc;

   629                 if (isXml)

   630                     s.dataType = 'xml';

   631                 xhr.getResponseHeader = function(header){

   632                     var headers = {'content-type': s.dataType};

   633                     return headers[header];

   634                 };

   635                 // support for XHR 'status' & 'statusText' emulation :

   636                 if (docRoot) {

   637                     xhr.status = Number( docRoot.getAttribute('status') ) || xhr.status;

   638                     xhr.statusText = docRoot.getAttribute('statusText') || xhr.statusText;

   639                 }

   640 

   641                 var dt = (s.dataType || '').toLowerCase();

   642                 var scr = /(json|script|text)/.test(dt);

   643                 if (scr || s.textarea) {

   644                     // see if user embedded response in textarea

   645                     var ta = doc.getElementsByTagName('textarea')[0];

   646                     if (ta) {

   647                         xhr.responseText = ta.value;

   648                         // support for XHR 'status' & 'statusText' emulation :

   649                         xhr.status = Number( ta.getAttribute('status') ) || xhr.status;

   650                         xhr.statusText = ta.getAttribute('statusText') || xhr.statusText;

   651                     }

   652                     else if (scr) {

   653                         // account for browsers injecting pre around json response

   654                         var pre = doc.getElementsByTagName('pre')[0];

   655                         var b = doc.getElementsByTagName('body')[0];

   656                         if (pre) {

   657                             xhr.responseText = pre.textContent ? pre.textContent : pre.innerText;

   658                         }

   659                         else if (b) {

   660                             xhr.responseText = b.textContent ? b.textContent : b.innerText;

   661                         }

   662                     }

   663                 }

   664                 else if (dt == 'xml' && !xhr.responseXML && xhr.responseText) {

   665                     xhr.responseXML = toXml(xhr.responseText);

   666                 }

   667 

   668                 try {

   669                     data = httpData(xhr, dt, s);

   670                 }

   671                 catch (err) {

   672                     status = 'parsererror';

   673                     xhr.error = errMsg = (err || status);

   674                 }

   675             }

   676             catch (err) {

   677                 log('error caught: ',err);

   678                 status = 'error';

   679                 xhr.error = errMsg = (err || status);

   680             }

   681 

   682             if (xhr.aborted) {

   683                 log('upload aborted');

   684                 status = null;

   685             }

   686 

   687             if (xhr.status) { // we've set xhr.status

   688                 status = (xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) ? 'success' : 'error';

   689             }

   690 

   691             // ordering of these callbacks/triggers is odd, but that's how $.ajax does it

   692             if (status === 'success') {

   693                 if (s.success)

   694                     s.success.call(s.context, data, 'success', xhr);

   695                 deferred.resolve(xhr.responseText, 'success', xhr);

   696                 if (g)

   697                     $.event.trigger("ajaxSuccess", [xhr, s]);

   698             }

   699             else if (status) {

   700                 if (errMsg === undefined)

   701                     errMsg = xhr.statusText;

   702                 if (s.error)

   703                     s.error.call(s.context, xhr, status, errMsg);

   704                 deferred.reject(xhr, 'error', errMsg);

   705                 if (g)

   706                     $.event.trigger("ajaxError", [xhr, s, errMsg]);

   707             }

   708 

   709             if (g)

   710                 $.event.trigger("ajaxComplete", [xhr, s]);

   711 

   712             if (g && ! --$.active) {

   713                 $.event.trigger("ajaxStop");

   714             }

   715 

   716             if (s.complete)

   717                 s.complete.call(s.context, xhr, status);

   718 

   719             callbackProcessed = true;

   720             if (s.timeout)

   721                 clearTimeout(timeoutHandle);

   722 

   723             // clean up

   724             setTimeout(function() {

   725                 if (!s.iframeTarget)

   726                     $io.remove();

   727                 xhr.responseXML = null;

   728             }, 100);

   729         }

   730 

   731         var toXml = $.parseXML || function(s, doc) { // use parseXML if available (jQuery 1.5+)

   732             if (window.ActiveXObject) {

   733                 doc = new ActiveXObject('Microsoft.XMLDOM');

   734                 doc.async = 'false';

   735                 doc.loadXML(s);

   736             }

   737             else {

   738                 doc = (new DOMParser()).parseFromString(s, 'text/xml');

   739             }

   740             return (doc && doc.documentElement && doc.documentElement.nodeName != 'parsererror') ? doc : null;

   741         };

   742         var parseJSON = $.parseJSON || function(s) {

   743             /*jslint evil:true */

   744             return window['eval']('(' + s + ')');

   745         };

   746 

   747         var httpData = function( xhr, type, s ) { // mostly lifted from jq1.4.4

   748 

   749             var ct = xhr.getResponseHeader('content-type') || '',

   750                 xml = type === 'xml' || !type && ct.indexOf('xml') >= 0,

   751                 data = xml ? xhr.responseXML : xhr.responseText;

   752 

   753             if (xml && data.documentElement.nodeName === 'parsererror') {

   754                 if ($.error)

   755                     $.error('parsererror');

   756             }

   757             if (s && s.dataFilter) {

   758                 data = s.dataFilter(data, type);

   759             }

   760             if (typeof data === 'string') {

   761                 if (type === 'json' || !type && ct.indexOf('json') >= 0) {

   762                     data = parseJSON(data);

   763                 } else if (type === "script" || !type && ct.indexOf("javascript") >= 0) {

   764                     $.globalEval(data);

   765                 }

   766             }

   767             return data;

   768         };

   769 

   770         return deferred;

   771     }

   772 };

   773 

   774 /**

   775  * ajaxForm() provides a mechanism for fully automating form submission.

   776  *

   777  * The advantages of using this method instead of ajaxSubmit() are:

   778  *

   779  * 1: This method will include coordinates for <input type="image" /> elements (if the element

   780  *    is used to submit the form).

   781  * 2. This method will include the submit element's name/value data (for the element that was

   782  *    used to submit the form).

   783  * 3. This method binds the submit() method to the form for you.

   784  *

   785  * The options argument for ajaxForm works exactly as it does for ajaxSubmit.  ajaxForm merely

   786  * passes the options argument along after properly binding events for submit elements and

   787  * the form itself.

   788  */

   789 $.fn.ajaxForm = function(options) {

   790     options = options || {};

   791     options.delegation = options.delegation && $.isFunction($.fn.on);

   792 

   793     // in jQuery 1.3+ we can fix mistakes with the ready state

   794     if (!options.delegation && this.length === 0) {

   795         var o = { s: this.selector, c: this.context };

   796         if (!$.isReady && o.s) {

   797             log('DOM not ready, queuing ajaxForm');

   798             $(function() {

   799                 $(o.s,o.c).ajaxForm(options);

   800             });

   801             return this;

   802         }

   803         // is your DOM ready?  http://docs.jquery.com/Tutorials:Introducing_$(document).ready()

   804         log('terminating; zero elements found by selector' + ($.isReady ? '' : ' (DOM not ready)'));

   805         return this;

   806     }

   807 

   808     if ( options.delegation ) {

   809         $(document)

   810             .off('submit.form-plugin', this.selector, doAjaxSubmit)

   811             .off('click.form-plugin', this.selector, captureSubmittingElement)

   812             .on('submit.form-plugin', this.selector, options, doAjaxSubmit)

   813             .on('click.form-plugin', this.selector, options, captureSubmittingElement);

   814         return this;

   815     }

   816 

   817     return this.ajaxFormUnbind()

   818         .bind('submit.form-plugin', options, doAjaxSubmit)

   819         .bind('click.form-plugin', options, captureSubmittingElement);

   820 };

   821 

   822 // private event handlers

   823 function doAjaxSubmit(e) {

   824     /*jshint validthis:true */

   825     var options = e.data;

   826     if (!e.isDefaultPrevented()) { // if event has been canceled, don't proceed

   827         e.preventDefault();

   828         $(this).ajaxSubmit(options);

   829     }

   830 }

   831 

   832 function captureSubmittingElement(e) {

   833     /*jshint validthis:true */

   834     var target = e.target;

   835     var $el = $(target);

   836     if (!($el.is("[type=submit],[type=image]"))) {

   837         // is this a child element of the submit el?  (ex: a span within a button)

   838         var t = $el.closest('[type=submit]');

   839         if (t.length === 0) {

   840             return;

   841         }

   842         target = t[0];

   843     }

   844     var form = this;

   845     form.clk = target;

   846     if (target.type == 'image') {

   847         if (e.offsetX !== undefined) {

   848             form.clk_x = e.offsetX;

   849             form.clk_y = e.offsetY;

   850         } else if (typeof $.fn.offset == 'function') {

   851             var offset = $el.offset();

   852             form.clk_x = e.pageX - offset.left;

   853             form.clk_y = e.pageY - offset.top;

   854         } else {

   855             form.clk_x = e.pageX - target.offsetLeft;

   856             form.clk_y = e.pageY - target.offsetTop;

   857         }

   858     }

   859     // clear form vars

   860     setTimeout(function() { form.clk = form.clk_x = form.clk_y = null; }, 100);

   861 }

   862 

   863 

   864 // ajaxFormUnbind unbinds the event handlers that were bound by ajaxForm

   865 $.fn.ajaxFormUnbind = function() {

   866     return this.unbind('submit.form-plugin click.form-plugin');

   867 };

   868 

   869 /**

   870  * formToArray() gathers form element data into an array of objects that can

   871  * be passed to any of the following ajax functions: $.get, $.post, or load.

   872  * Each object in the array has both a 'name' and 'value' property.  An example of

   873  * an array for a simple login form might be:

   874  *

   875  * [ { name: 'username', value: 'jresig' }, { name: 'password', value: 'secret' } ]

   876  *

   877  * It is this array that is passed to pre-submit callback functions provided to the

   878  * ajaxSubmit() and ajaxForm() methods.

   879  */

   880 $.fn.formToArray = function(semantic, elements) {

   881     var a = [];

   882     if (this.length === 0) {

   883         return a;

   884     }

   885 

   886     var form = this[0];

   887     var els = semantic ? form.getElementsByTagName('*') : form.elements;

   888     if (!els) {

   889         return a;

   890     }

   891 

   892     var i,j,n,v,el,max,jmax;

   893     for(i=0, max=els.length; i < max; i++) {

   894         el = els[i];

   895         n = el.name;

   896         if (!n || el.disabled) {

   897             continue;

   898         }

   899 

   900         if (semantic && form.clk && el.type == "image") {

   901             // handle image inputs on the fly when semantic == true

   902             if(form.clk == el) {

   903                 a.push({name: n, value: $(el).val(), type: el.type });

   904                 a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y});

   905             }

   906             continue;

   907         }

   908 

   909         v = $.fieldValue(el, true);

   910         if (v && v.constructor == Array) {

   911             if (elements)

   912                 elements.push(el);

   913             for(j=0, jmax=v.length; j < jmax; j++) {

   914                 a.push({name: n, value: v[j]});

   915             }

   916         }

   917         else if (feature.fileapi && el.type == 'file') {

   918             if (elements)

   919                 elements.push(el);

   920             var files = el.files;

   921             if (files.length) {

   922                 for (j=0; j < files.length; j++) {

   923                     a.push({name: n, value: files[j], type: el.type});

   924                 }

   925             }

   926             else {

   927                 // #180

   928                 a.push({ name: n, value: '', type: el.type });

   929             }

   930         }

   931         else if (v !== null && typeof v != 'undefined') {

   932             if (elements)

   933                 elements.push(el);

   934             a.push({name: n, value: v, type: el.type, required: el.required});

   935         }

   936     }

   937 

   938     if (!semantic && form.clk) {

   939         // input type=='image' are not found in elements array! handle it here

   940         var $input = $(form.clk), input = $input[0];

   941         n = input.name;

   942         if (n && !input.disabled && input.type == 'image') {

   943             a.push({name: n, value: $input.val()});

   944             a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y});

   945         }

   946     }

   947     return a;

   948 };

   949 

   950 /**

   951  * Serializes form data into a 'submittable' string. This method will return a string

   952  * in the format: name1=value1&name2=value2

   953  */

   954 $.fn.formSerialize = function(semantic) {

   955     //hand off to jQuery.param for proper encoding

   956     return $.param(this.formToArray(semantic));

   957 };

   958 

   959 /**

   960  * Serializes all field elements in the jQuery object into a query string.

   961  * This method will return a string in the format: name1=value1&name2=value2

   962  */

   963 $.fn.fieldSerialize = function(successful) {

   964     var a = [];

   965     this.each(function() {

   966         var n = this.name;

   967         if (!n) {

   968             return;

   969         }

   970         var v = $.fieldValue(this, successful);

   971         if (v && v.constructor == Array) {

   972             for (var i=0,max=v.length; i < max; i++) {

   973                 a.push({name: n, value: v[i]});

   974             }

   975         }

   976         else if (v !== null && typeof v != 'undefined') {

   977             a.push({name: this.name, value: v});

   978         }

   979     });

   980     //hand off to jQuery.param for proper encoding

   981     return $.param(a);

   982 };

   983 

   984 /**

   985  * Returns the value(s) of the element in the matched set.  For example, consider the following form:

   986  *

   987  *  <form><fieldset>

   988  *      <input name="A" type="text" />

   989  *      <input name="A" type="text" />

   990  *      <input name="B" type="checkbox" value="B1" />

   991  *      <input name="B" type="checkbox" value="B2"/>

   992  *      <input name="C" type="radio" value="C1" />

   993  *      <input name="C" type="radio" value="C2" />

   994  *  </fieldset></form>

   995  *

   996  *  var v = $('input[type=text]').fieldValue();

   997  *  // if no values are entered into the text inputs

   998  *  v == ['','']

   999  *  // if values entered into the text inputs are 'foo' and 'bar'

  1000  *  v == ['foo','bar']

  1001  *

  1002  *  var v = $('input[type=checkbox]').fieldValue();

  1003  *  // if neither checkbox is checked

  1004  *  v === undefined

  1005  *  // if both checkboxes are checked

  1006  *  v == ['B1', 'B2']

  1007  *

  1008  *  var v = $('input[type=radio]').fieldValue();

  1009  *  // if neither radio is checked

  1010  *  v === undefined

  1011  *  // if first radio is checked

  1012  *  v == ['C1']

  1013  *

  1014  * The successful argument controls whether or not the field element must be 'successful'

  1015  * (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).

  1016  * The default value of the successful argument is true.  If this value is false the value(s)

  1017  * for each element is returned.

  1018  *

  1019  * Note: This method *always* returns an array.  If no valid value can be determined the

  1020  *    array will be empty, otherwise it will contain one or more values.

  1021  */

  1022 $.fn.fieldValue = function(successful) {

  1023     for (var val=[], i=0, max=this.length; i < max; i++) {

  1024         var el = this[i];

  1025         var v = $.fieldValue(el, successful);

  1026         if (v === null || typeof v == 'undefined' || (v.constructor == Array && !v.length)) {

  1027             continue;

  1028         }

  1029         if (v.constructor == Array)

  1030             $.merge(val, v);

  1031         else

  1032             val.push(v);

  1033     }

  1034     return val;

  1035 };

  1036 

  1037 /**

  1038  * Returns the value of the field element.

  1039  */

  1040 $.fieldValue = function(el, successful) {

  1041     var n = el.name, t = el.type, tag = el.tagName.toLowerCase();

  1042     if (successful === undefined) {

  1043         successful = true;

  1044     }

  1045 

  1046     if (successful && (!n || el.disabled || t == 'reset' || t == 'button' ||

  1047         (t == 'checkbox' || t == 'radio') && !el.checked ||

  1048         (t == 'submit' || t == 'image') && el.form && el.form.clk != el ||

  1049         tag == 'select' && el.selectedIndex == -1)) {

  1050             return null;

  1051     }

  1052 

  1053     if (tag == 'select') {

  1054         var index = el.selectedIndex;

  1055         if (index < 0) {

  1056             return null;

  1057         }

  1058         var a = [], ops = el.options;

  1059         var one = (t == 'select-one');

  1060         var max = (one ? index+1 : ops.length);

  1061         for(var i=(one ? index : 0); i < max; i++) {

  1062             var op = ops[i];

  1063             if (op.selected) {

  1064                 var v = op.value;

  1065                 if (!v) { // extra pain for IE...

  1066                     v = (op.attributes && op.attributes['value'] && !(op.attributes['value'].specified)) ? op.text : op.value;

  1067                 }

  1068                 if (one) {

  1069                     return v;

  1070                 }

  1071                 a.push(v);

  1072             }

  1073         }

  1074         return a;

  1075     }

  1076     return $(el).val();

  1077 };

  1078 

  1079 /**

  1080  * Clears the form data.  Takes the following actions on the form's input fields:

  1081  *  - input text fields will have their 'value' property set to the empty string

  1082  *  - select elements will have their 'selectedIndex' property set to -1

  1083  *  - checkbox and radio inputs will have their 'checked' property set to false

  1084  *  - inputs of type submit, button, reset, and hidden will *not* be effected

  1085  *  - button elements will *not* be effected

  1086  */

  1087 $.fn.clearForm = function(includeHidden) {

  1088     return this.each(function() {

  1089         $('input,select,textarea', this).clearFields(includeHidden);

  1090     });

  1091 };

  1092 

  1093 /**

  1094  * Clears the selected form elements.

  1095  */

  1096 $.fn.clearFields = $.fn.clearInputs = function(includeHidden) {

  1097     var re = /^(?:color|date|datetime|email|month|number|password|range|search|tel|text|time|url|week)$/i; // 'hidden' is not in this list

  1098     return this.each(function() {

  1099         var t = this.type, tag = this.tagName.toLowerCase();

  1100         if (re.test(t) || tag == 'textarea') {

  1101             this.value = '';

  1102         }

  1103         else if (t == 'checkbox' || t == 'radio') {

  1104             this.checked = false;

  1105         }

  1106         else if (tag == 'select') {

  1107             this.selectedIndex = -1;

  1108         }

  1109 		else if (t == "file") {

  1110 			if (/MSIE/.test(navigator.userAgent)) {

  1111 				$(this).replaceWith($(this).clone(true));

  1113 				$(this).val('');

   259 				callbacks.push(options.success);

  1114 			}

   260 			}

  1115 		}

   261 		}

  1116         else if (includeHidden) {

   262 

  1117             // includeHidden can be the value true, or it can be a selector string

   263 		options.success = function(data, status, xhr) { // jQuery 1.4+ passes xhr as 3rd arg

  1118             // indicating a special test; for example:

   264 			var context = options.context || this;		// jQuery 1.4+ supports scope context

  1119             //  $('#myForm').clearForm('.special:hidden')

   265 

  1120             // the above would clean hidden inputs that have the class of 'special'

   266 			for (var i = 0, max = callbacks.length; i < max; i++) {

  1121             if ( (includeHidden === true && /hidden/.test(t)) ||

   267 				callbacks[i].apply(context, [data, status, xhr || $form, $form]);

  1122                  (typeof includeHidden == 'string' && $(this).is(includeHidden)) )

   268 			}

  1123                 this.value = '';

   269 		};

  1124         }

   270 

  1125     });

   271 		if (options.error) {

  1126 };

   272 			var oldError = options.error;

  1127 

   273 

  1128 /**

   274 			options.error = function(xhr, status, error) {

  1129  * Resets the form data.  Causes all form elements to be reset to their original value.

   275 				var context = options.context || this;

  1130  */

   276 

  1131 $.fn.resetForm = function() {

   277 				oldError.apply(context, [xhr, status, error, $form]);

  1132     return this.each(function() {

   278 			};

  1133         // guard against an input with the name of 'reset'

   279 		}

  1134         // note that IE reports the reset function as an 'object'

   280 

  1135         if (typeof this.reset == 'function' || (typeof this.reset == 'object' && !this.reset.nodeType)) {