if ('undefined' == typeof TyreSelector) TyreSelector = {};
(function (ns, $) {

ns.startTyreSelectorForDimensions = function start (opts) {
	var dimension_form = $('#' + opts.selector_id + '_dimension_form');
	var montes_decalees = false;
	var done = { "front": false, "rear": false };
	// Ce verrou est nécessaire car le même formulaire porte les deux sélecteurs
	// ainsi quand l'évènement "selector:finish" est envoyé au formulaire, c'est "finish()"
	// qui est appelée pour front et rear à la fois!
	// On lock donc une des deux méthodes en fonction du contexte
	var lock = { "front": false, "rear": false };

	// Enchaînement des formulaires
	var behaviorsFor = function (type) {
		var other_type = (type == 'front') ? 'rear' : 'front';
		var other_suffix = (type == 'front') ? '_rear' : '';
		return {
			"finish": function finish () {
				if (lock[type]) {
					lock[type] = false;
					return;
				}
				done[type] = true;
				// Fini: activation autre monte, ou activation validation
				if (montes_decalees && !done[other_type]) {
					$('#' + opts.selector_id + '_width' + other_suffix).trigger('field:activate');
				} else {
					dimension_form.trigger('form:enable');
				}
			},
			"unfinish": function unfinish () {
				if (lock[type]) {
					lock[type] = false;
					return;
				}
				done[type] = false;
				// Pas fini: désactivation validation, et potentiellement désactivation autre monte
				dimension_form.trigger('form:disable');
				if (montes_decalees && !done[other_type]) {
					$('#' + opts.selector_id + '_width' + other_suffix).trigger('field:deactivate');
				}
			}
		};
	};
	// En cas d'avancement d'un formulaire (sur le choix de la largeur), on désactive l'autre
	$('#' + opts.selector_id + '_width').bind('field:set', function () {
		if (done.rear) return;
		$('#' + opts.selector_id + '_width_rear').trigger('field:deactivate');
		// Sur annulation, on réactive
		$(this).one('field:enable', function () {
			$('#' + opts.selector_id + '_width_rear').trigger('field:activate');
		});
	});
	$('#' + opts.selector_id + '_width_rear').bind('field:set', function (event) {
		if (done.front) return;
		$('#' + opts.selector_id + '_width').trigger('field:deactivate');
		// Sur annulation, on réactive
		$(this).one('field:enable', function () {
			$('#' + opts.selector_id + '_width').trigger('field:activate');
		});
	});

	// Gestion du verrou
	dimension_form.bind('selector:finish', function (event, fields, field_index) {
		lock.front = !!fields[field_index].attr('id').match(/_rear$/);
		lock.rear = !lock.front;
	});
	dimension_form.bind('selector:unfinish', function (event, fields, field_index) {
		lock.front = !!fields[field_index].attr('id').match(/_rear$/);
		lock.rear = !lock.front;
	});

	// Formulaire de sélection de dimension monte avant
	var behaviorsForFront = behaviorsFor('front');
	ns.fillDimensionForm(opts.fields_config, {
		"data":     "dimensions",
		"dataUrl":  opts.data_url,
		"form":     dimension_form,
		"enable":   true,
		"finish":   behaviorsForFront.finish,
		"unfinish": behaviorsForFront.unfinish,
		"iciv_opt": opts.indices_optional
	});

	// Formulaire de sélection de dimension monte arrière
	var behaviorsForRear = behaviorsFor('rear');
	ns.fillDimensionForm(opts.fields_config_rear, {
		"data":     "dimensions",
		"dataUrl":  opts.data_url,
		"form":     dimension_form,
		"enable":   !opts.value, // Le formulaire de sélection de monte arrière n'est dispo que si on n'a pas de valeur par défaut fournie
		"finish":   behaviorsForRear.finish,
		"unfinish": behaviorsForRear.unfinish,
		"iciv_opt": opts.indices_optional
	});

	// Gestion du lien "plus/moins d'options"
	ns.UI.handleSearchFilters({
		"basic":    '#' + opts.selector_id + ' .tyre-selector-search-filters-basic-fields',
		"advanced": '#' + opts.selector_id + ' .tyre-selector-search-filters-advanced-fields',
		"switcher": {
			"enabled":        true,
			"append":         true,
			"label_basic":    '<span class="sprite-filter-switcher sprite-filter-switcher-down"></span>&nbsp;' + (opts.label_basic || 'Afficher plus d\'options'),
			"label_advanced": '<span class="sprite-filter-switcher sprite-filter-switcher-up"></span>&nbsp;' + (opts.label_advanced || 'Masquer les options'),
			"link_class":     "filter-switcher"
		}
	}).bind('click', function () { // Marquage Webtrekk
		wtTrack(wtContextInfo.locale + "/" + wtContextInfo.module + "/" + wtContextInfo.action + "/TS=dimensions/more_option");
	});

	// Gestion des popups d'aide
	opts.tooltips.context = '#' + opts.selector_id;
	ns.UI.handleTooltips(opts.tooltips);

	// Activation/Désactivation du formulaire (évènements custom)
	dimension_form.bind('form:enable', function () {
		$('#' + opts.selector_id + '_submit').removeClass('disabled').addClass('enabled');
	});
	dimension_form.bind('form:disable', function () {
		$('#' + opts.selector_id + '_submit').addClass('disabled').removeClass('enabled');
	});

	// Bouton de soumission du formulaire
	$('#' + opts.selector_id + '_submit').bind('click', function (e) {
		e.preventDefault();
		var self = $(this);
		if (self.hasClass('enabled') && !self.hasClass('disabled')) {
			dimension_form.submit();
			e.stopPropagation();
		}
	});

	// Définition des styles d'affichage en fonction de l'étape du formulaire
	$('#' + opts.selector_id + ' .selector-fields select')
	.bind('field:enable', function () {
		$(this).removeClass('ts-selected').addClass('ts-current');
		if (this.id) $('label[for=' + this.id + ']').removeClass('ts-selected').addClass('ts-current');
		$(this).parents('.tyre-selector-body').addClass('tyre-selector-bg-' + $(this).attr('name').replace(/_rear$/, ''));
	})
	.bind('field:disable', function () {
		$(this).removeClass('ts-selected').removeClass('ts-current');
		if (this.id) $('label[for=' + this.id + ']').removeClass('ts-selected').removeClass('ts-current');
		$(this).parents('.tyre-selector-body').removeClass('tyre-selector-bg-' + $(this).attr('name').replace(/_rear$/, ''));
	})
	.bind('field:set', function () {
		$(this).removeClass('ts-current').addClass('ts-selected');
		if (this.id) $('label[for=' + this.id + ']').removeClass('ts-current').addClass('ts-selected');
		$(this).parents('.tyre-selector-body').removeClass('tyre-selector-bg-' + $(this).attr('name').replace(/_rear$/, ''));
		if ($(this).attr('name') == 'speed') {
			$(this).parents('.tyre-selector-body').addClass('tyre-selector-bg-final');
		}
	});
	// Rajouter le "R" au champ ratio
	$('#' + opts.selector_id + '_diameter, #' + opts.selector_id + '_diameter_rear').bind('field:enable', function () {
		$('option', this).each(function (index) {
			if (index > 0) { // Skip first
				var self = $(this), label = self.html();
				if (!label.match(/^R/)) self.html('R' + label);
			}
		});
	});

	// Afficher/Cacher le formulaire de sélection de monte arrière
	var cached_labels = {
		"load":       $('#' + opts.selector_id + '_load_empty').html(),
		"speed":      $('#' + opts.selector_id + '_speed_empty').html(),
		"load_rear":  $('#' + opts.selector_id + '_load_rear_empty').html(),
		"speed_rear": $('#' + opts.selector_id + '_speed_rear_empty').html()
	};

  var threePoints = '...';

	$('#' + opts.selector_id + '-filter-mount').bind('change', function() {
		montes_decalees = this.checked;

		if (montes_decalees) {
			// Afficher le formulaire monte arrière
			dimension_form.addClass('rear-mount-visible');
			$('#' + opts.selector_id + ' .rear-mount').show();
			$('#' + opts.selector_id + ' .rear-mount-label').css({"visibility": "visible"});
			$('#' + opts.selector_id + ' .front-mount-label').css({"visibility": "visible"});

			// Activer le formulaire monte arrière
			$('#' + opts.selector_id + '_width_rear').trigger('field:activate');

			// Si la monte avant était correctement sélectionnée au moment du changement, alors on désactive la validation
			if (done.front) {
				dimension_form.trigger('form:disable');
			}
      // on sauvegarde le libellé actuel pour le réafficher si on décoche la case montes décalées

			// en cas de montes décalées, il faut changer le libellé de la valeur par "..." quelque soit les options de configuration
      $('#' + opts.selector_id + '_load').setSelectEmptyOption(threePoints);
      $('#' + opts.selector_id + '_load_rear').setSelectEmptyOption(threePoints);
      $('#' + opts.selector_id + '_speed').setSelectEmptyOption(threePoints);
      $('#' + opts.selector_id + '_speed_rear').setSelectEmptyOption(threePoints);
		} else {
			// Cacher et désactiver le formulaire monte arrière
			dimension_form.removeClass('rear-mount-visible');
			$('#' + opts.selector_id + ' .rear-mount').hide();
			$('#' + opts.selector_id + ' .rear-mount-label').css({"visibility": "hidden"});
			$('#' + opts.selector_id + ' .front-mount-label').css({"visibility": "hidden"});
			$('#' + opts.selector_id + '_width_rear').trigger('field:deactivate');

			// Si la monte avant est correctement sélectionnée, alors on active la validation
			if (done.front) {
				dimension_form.trigger('form:enable');
			}
			// Si les IC/IV sont facultatifs, on a précédemment changé le libellé, il faut le rétablir
			if (opts.indices_optional) {
        $('#' + opts.selector_id + '_load').setSelectEmptyOption(cached_labels.load);
        $('#' + opts.selector_id + '_load_rear').setSelectEmptyOption(cached_labels.load_rear);
        $('#' + opts.selector_id + '_speed').setSelectEmptyOption(cached_labels.speed);
        $('#' + opts.selector_id + '_speed_rear').setSelectEmptyOption(cached_labels.speed_rear);
			}
      console.log('ic/iv: ' + opts.indices_optional);
		}
	}).trigger('change'); // Appel à trigger maintenant, pour gérer la valeur actuelle

	// Valeur par défaut
	if (opts.value && opts.value.length) {
		var front = opts.value[0];
		var rear = opts.value[1];
		// Sélectionner les valeurs
		if (front[0]) $('#' + opts.selector_id + '_width'   ).one('field:enable', function () { $(this).val(front[0]); });
		if (front[1]) $('#' + opts.selector_id + '_ratio'   ).one('field:enable', function () { $(this).val(front[1]); });
		if (front[2]) $('#' + opts.selector_id + '_diameter').one('field:enable', function () { $(this).val(front[2]); });
		if (front[3]) $('#' + opts.selector_id + '_load'    ).one('field:enable', function () { $(this).val(front[3]); });
		if (front[4]) $('#' + opts.selector_id + '_speed'   ).one('field:enable', function () { $(this).val(front[4]); });
		if (rear) {
			// Montes décalées
			$('#' + opts.selector_id + '-filter-mount').attr('checked', true).trigger('change');
			$('a.filter-switcher', '#' + opts.selector_id).trigger('click');
			if (rear[0]) $('#' + opts.selector_id + '_width_rear'   ).one('field:enable', function () { $(this).val(rear[0]); });
			if (rear[1]) $('#' + opts.selector_id + '_ratio_rear'   ).one('field:enable', function () { $(this).val(rear[1]); });
			if (rear[2]) $('#' + opts.selector_id + '_diameter_rear').one('field:enable', function () { $(this).val(rear[2]); });
			if (rear[3]) $('#' + opts.selector_id + '_load_rear'    ).one('field:enable', function () { $(this).val(rear[3]); });
			if (rear[4]) $('#' + opts.selector_id + '_speed_rear'   ).one('field:enable', function () { $(this).val(rear[4]); });
		}
	}
};

/**
 * Traitement du formulaire de sélection de dimension
 * @param Object f La configuration des champs du sélecteur de dimension
 * @Param Object opts Les options du formulaire
 */
ns.fillDimensionForm = function (f, opts) {
	ns.loadData(opts.data, opts.dataUrl, function () {
		ns.fillSelectorForm(opts, function (callback) {
			// Champs à traiter
			var fields = [
				$("[name=" + f.width.field + "]",    opts.form).data("key", f.width.key),
				$("[name=" + f.ratio.field + "]",    opts.form).data("key", f.ratio.key),
				$("[name=" + f.diameter.field + "]", opts.form).data("key", f.diameter.key),
				$("[name=" + f.load.field + "]",     opts.form).data("key", f.load.key).data("optional",  function () {
					return opts.iciv_opt ? (!$("[name=mount]", opts.form).is(':checked') && $("[name=" + f.speed.field + "]", opts.form).val() == '') : false }),
				$("[name=" + f.speed.field + "]",    opts.form).data("key", f.speed.key).data("optional", function () {
					return opts.iciv_opt ? (!$("[name=mount]", opts.form).is(':checked') && $("[name=" + f.load.field + "]", opts.form).val() == '') : false })
			];
			// Comparaisons
			var comparator = function (a, b) { return parseFloat(a) - parseFloat(b); };
			var comparators = {
				"values": [
					ns.sorter('ascending', f.width.priorities    || [], comparator),
					ns.sorter('ascending', f.ratio.priorities    || [], comparator),
					ns.sorter('ascending', f.diameter.priorities || [], comparator),
					ns.sorter('ascending', f.load.priorities     || [], comparator),
					ns.sorter('ascending', f.speed.priorities    || [])
				],
				"groups": []
			};
			// Démarrage
			callback(fields, comparators);
		});
	});
};

})(TyreSelector, jQuery);


$.fn.setSelectEmptyOption = function(value){
  return $(this).find('option[value=""]').empty().append(value);
}



// Domain Public by Eric Wendelin http://eriwen.com/ (2008)
//                  Luke Smith http://lucassmith.name/ (2008)
//                  Loic Dachary <loic@dachary.org> (2008)
//                  Johan Euphrosine <proppy@aminche.com> (2008)
//                  Oyvind Sean Kinsey http://kinsey.no/blog (2010)
//                  Victor Homyakov <victor-homyakov@users.sourceforge.net> (2010)

/**
 * Main function giving a function stack trace with a forced or passed in Error
 *
 * @cfg {Error} e The error to create a stacktrace from (optional)
 * @cfg {Boolean} guess If we should try to resolve the names of anonymous functions
 * @return {Array} of Strings with functions, lines, files, and arguments where possible
 */
function printStackTrace(options) {
    options = options || {guess: true};
    var ex = options.e || null, guess = !!options.guess;
    var p = new printStackTrace.implementation(), result = p.run(ex);
    return (guess) ? p.guessAnonymousFunctions(result) : result;
}

printStackTrace.implementation = function() {
};

printStackTrace.implementation.prototype = {
    /**
     * @param {Error} ex The error to create a stacktrace from (optional)
     * @param {String} mode Forced mode (optional, mostly for unit tests)
     */
    run: function(ex, mode) {
        ex = ex || this.createException();
        // examine exception properties w/o debugger
        //for (var prop in ex) {alert("Ex['" + prop + "']=" + ex[prop]);}
        mode = mode || this.mode(ex);
        if (mode === 'other') {
            return this.other(arguments.callee);
        } else {
            return this[mode](ex);
        }
    },

    createException: function() {
        try {
            this.undef();
        } catch (e) {
            return e;
        }
    },

    /**
     * Mode could differ for different exception, e.g.
     * exceptions in Chrome may or may not have arguments or stack.
     *
     * @return {String} mode of operation for the exception
     */
    mode: function(e) {
        if (e['arguments'] && e.stack) {
            return 'chrome';
        } else if (typeof e.message === 'string' && typeof window !== 'undefined' && window.opera) {
            // e.message.indexOf("Backtrace:") > -1 -> opera
            // !e.stacktrace -> opera
            if (!e.stacktrace) {
                return 'opera9'; // use e.message
            }
            // 'opera#sourceloc' in e -> opera9, opera10a
            if (e.message.indexOf('\n') > -1 && e.message.split('\n').length > e.stacktrace.split('\n').length) {
                return 'opera9'; // use e.message
            }
            // e.stacktrace && !e.stack -> opera10a
            if (!e.stack) {
                return 'opera10a'; // use e.stacktrace
            }
            // e.stacktrace && e.stack -> opera10b
            if (e.stacktrace.indexOf("called from line") < 0) {
                return 'opera10b'; // use e.stacktrace, format differs from 'opera10a'
            }
            // e.stacktrace && e.stack -> opera11
            return 'opera11'; // use e.stacktrace, format differs from 'opera10a', 'opera10b'
        } else if (e.stack) {
            return 'firefox';
        }
        return 'other';
    },

    /**
     * Given a context, function name, and callback function, overwrite it so that it calls
     * printStackTrace() first with a callback and then runs the rest of the body.
     *
     * @param {Object} context of execution (e.g. window)
     * @param {String} functionName to instrument
     * @param {Function} function to call with a stack trace on invocation
     */
    instrumentFunction: function(context, functionName, callback) {
        context = context || window;
        var original = context[functionName];
        context[functionName] = function instrumented() {
            callback.call(this, printStackTrace().slice(4));
            return context[functionName]._instrumented.apply(this, arguments);
        };
        context[functionName]._instrumented = original;
    },

    /**
     * Given a context and function name of a function that has been
     * instrumented, revert the function to it's original (non-instrumented)
     * state.
     *
     * @param {Object} context of execution (e.g. window)
     * @param {String} functionName to de-instrument
     */
    deinstrumentFunction: function(context, functionName) {
        if (context[functionName].constructor === Function &&
                context[functionName]._instrumented &&
                context[functionName]._instrumented.constructor === Function) {
            context[functionName] = context[functionName]._instrumented;
        }
    },

    /**
     * Given an Error object, return a formatted Array based on Chrome's stack string.
     *
     * @param e - Error object to inspect
     * @return Array<String> of function calls, files and line numbers
     */
    chrome: function(e) {
        var stack = (e.stack + '\n').replace(/^\S[^\(]+?[\n$]/gm, '').
          replace(/^\s+at\s+/gm, '').
          replace(/^([^\(]+?)([\n$])/gm, '{anonymous}()@$1$2').
          replace(/^Object.<anonymous>\s*\(([^\)]+)\)/gm, '{anonymous}()@$1').split('\n');
        stack.pop();
        return stack;
    },

    /**
     * Given an Error object, return a formatted Array based on Firefox's stack string.
     *
     * @param e - Error object to inspect
     * @return Array<String> of function calls, files and line numbers
     */
    firefox: function(e) {
        return e.stack.replace(/(?:\n@:0)?\s+$/m, '').replace(/^\(/gm, '{anonymous}(').split('\n');
    },

    opera11: function(e) {
        // "Error thrown at line 42, column 12 in <anonymous function>() in file://localhost/G:/js/stacktrace.js:\n"
        // "Error thrown at line 42, column 12 in <anonymous function: createException>() in file://localhost/G:/js/stacktrace.js:\n"
        // "called from line 7, column 4 in bar(n) in file://localhost/G:/js/test/functional/testcase1.html:\n"
        // "called from line 15, column 3 in file://localhost/G:/js/test/functional/testcase1.html:\n"
        var ANON = '{anonymous}', lineRE = /^.*line (\d+), column (\d+)(?: in (.+))? in (\S+):$/;
        var lines = e.stacktrace.split('\n'), result = [];

        for (var i = 0, len = lines.length; i < len; i += 2) {
            var match = lineRE.exec(lines[i]);
            if (match) {
                var location = match[4] + ':' + match[1] + ':' + match[2];
                var fnName = match[3] || "global code";
                fnName = fnName.replace(/<anonymous function: (\S+)>/, "$1").replace(/<anonymous function>/, ANON);
                result.push(fnName + '@' + location + ' -- ' + lines[i + 1].replace(/^\s+/, ''));
            }
        }

        return result;
    },

    opera10b: function(e) {
        // "<anonymous function: run>([arguments not available])@file://localhost/G:/js/stacktrace.js:27\n" +
        // "printStackTrace([arguments not available])@file://localhost/G:/js/stacktrace.js:18\n" +
        // "@file://localhost/G:/js/test/functional/testcase1.html:15"
        var ANON = '{anonymous}', lineRE = /^(.*)@(.+):(\d+)$/;
        var lines = e.stacktrace.split('\n'), result = [];

        for (var i = 0, len = lines.length; i < len; i++) {
            var match = lineRE.exec(lines[i]);
            if (match) {
                var fnName = match[1]? (match[1] + '()') : "global code";
                result.push(fnName + '@' + match[2] + ':' + match[3]);
            }
        }

        return result;
    },

    /**
     * Given an Error object, return a formatted Array based on Opera 10's stacktrace string.
     *
     * @param e - Error object to inspect
     * @return Array<String> of function calls, files and line numbers
     */
    opera10a: function(e) {
        // "  Line 27 of linked script file://localhost/G:/js/stacktrace.js\n"
        // "  Line 11 of inline#1 script in file://localhost/G:/js/test/functional/testcase1.html: In function foo\n"
        var ANON = '{anonymous}', lineRE = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i;
        var lines = e.stacktrace.split('\n'), result = [];

        for (var i = 0, len = lines.length; i < len; i += 2) {
            var match = lineRE.exec(lines[i]);
            if (match) {
                var fnName = match[3] || ANON;
                result.push(fnName + '()@' + match[2] + ':' + match[1] + ' -- ' + lines[i + 1].replace(/^\s+/, ''));
            }
        }

        return result;
    },

    // Opera 7.x-9.2x only!
    opera9: function(e) {
        // "  Line 43 of linked script file://localhost/G:/js/stacktrace.js\n"
        // "  Line 7 of inline#1 script in file://localhost/G:/js/test/functional/testcase1.html\n"
        var ANON = '{anonymous}', lineRE = /Line (\d+).*script (?:in )?(\S+)/i;
        var lines = e.message.split('\n'), result = [];

        for (var i = 2, len = lines.length; i < len; i += 2) {
            var match = lineRE.exec(lines[i]);
            if (match) {
                result.push(ANON + '()@' + match[2] + ':' + match[1] + ' -- ' + lines[i + 1].replace(/^\s+/, ''));
            }
        }

        return result;
    },

    // Safari, IE, and others
    other: function(curr) {
        var ANON = '{anonymous}', fnRE = /function\s*([\w\-$]+)?\s*\(/i, stack = [], fn, args, maxStackSize = 10;
        while (curr && stack.length < maxStackSize) {
            fn = fnRE.test(curr.toString()) ? RegExp.$1 || ANON : ANON;
            args = Array.prototype.slice.call(curr['arguments'] || []);
            stack[stack.length] = fn + '(' + this.stringifyArguments(args) + ')';
            curr = curr.caller;
        }
        return stack;
    },

    /**
     * Given arguments array as a String, subsituting type names for non-string types.
     *
     * @param {Arguments} object
     * @return {Array} of Strings with stringified arguments
     */
    stringifyArguments: function(args) {
        var result = [];
        var slice = Array.prototype.slice;
        for (var i = 0; i < args.length; ++i) {
            var arg = args[i];
            if (arg === undefined) {
                result[i] = 'undefined';
            } else if (arg === null) {
                result[i] = 'null';
            } else if (arg.constructor) {
                if (arg.constructor === Array) {
                    if (arg.length < 3) {
                        result[i] = '[' + this.stringifyArguments(arg) + ']';
                    } else {
                        result[i] = '[' + this.stringifyArguments(slice.call(arg, 0, 1)) + '...' + this.stringifyArguments(slice.call(arg, -1)) + ']';
                    }
                } else if (arg.constructor === Object) {
                    result[i] = '#object';
                } else if (arg.constructor === Function) {
                    result[i] = '#function';
                } else if (arg.constructor === String) {
                    result[i] = '"' + arg + '"';
                } else if (arg.constructor === Number) {
                    result[i] = arg;
                }
            }
        }
        return result.join(',');
    },

    sourceCache: {},

    /**
     * @return the text from a given URL
     */
    ajax: function(url) {
        var req = this.createXMLHTTPObject();
        if (req) {
            try {
                req.open('GET', url, false);
                req.send(null);
                return req.responseText;
            } catch (e) {
            }
        }
        return '';
    },

    /**
     * Try XHR methods in order and store XHR factory.
     *
     * @return <Function> XHR function or equivalent
     */
    createXMLHTTPObject: function() {
        var xmlhttp, XMLHttpFactories = [
            function() {
                return new XMLHttpRequest();
            }, function() {
                return new ActiveXObject('Msxml2.XMLHTTP');
            }, function() {
                return new ActiveXObject('Msxml3.XMLHTTP');
            }, function() {
                return new ActiveXObject('Microsoft.XMLHTTP');
            }
        ];
        for (var i = 0; i < XMLHttpFactories.length; i++) {
            try {
                xmlhttp = XMLHttpFactories[i]();
                // Use memoization to cache the factory
                this.createXMLHTTPObject = XMLHttpFactories[i];
                return xmlhttp;
            } catch (e) {
            }
        }
    },

    /**
     * Given a URL, check if it is in the same domain (so we can get the source
     * via Ajax).
     *
     * @param url <String> source url
     * @return False if we need a cross-domain request
     */
    isSameDomain: function(url) {
        return url.indexOf(location.hostname) !== -1;
    },

    /**
     * Get source code from given URL if in the same domain.
     *
     * @param url <String> JS source URL
     * @return <Array> Array of source code lines
     */
    getSource: function(url) {
        // TODO reuse source from script tags?
        if (!(url in this.sourceCache)) {
            this.sourceCache[url] = this.ajax(url).split('\n');
        }
        return this.sourceCache[url];
    },

    guessAnonymousFunctions: function(stack) {
        for (var i = 0; i < stack.length; ++i) {
            var reStack = /\{anonymous\}\(.*\)@(.*)/,
                reRef = /^(.*?)(?::(\d+))(?::(\d+))?(?: -- .+)?$/,
                frame = stack[i], ref = reStack.exec(frame);

            if (ref) {
                var m = reRef.exec(ref[1]), file = m[1],
                    lineno = m[2], charno = m[3] || 0;
                if (file && this.isSameDomain(file) && lineno) {
                    var functionName = this.guessAnonymousFunction(file, lineno, charno);
                    stack[i] = frame.replace('{anonymous}', functionName);
                }
            }
        }
        return stack;
    },

    guessAnonymousFunction: function(url, lineNo, charNo) {
        var ret;
        try {
            ret = this.findFunctionName(this.getSource(url), lineNo);
        } catch (e) {
            ret = 'getSource failed with url: ' + url + ', exception: ' + e.toString();
        }
        return ret;
    },

    findFunctionName: function(source, lineNo) {
        // FIXME findFunctionName fails for compressed source
        // (more than one function on the same line)
        // TODO use captured args
        // function {name}({args}) m[1]=name m[2]=args
        var reFunctionDeclaration = /function\s+([^(]*?)\s*\(([^)]*)\)/;
        // {name} = function ({args}) TODO args capture
        // /['"]?([0-9A-Za-z_]+)['"]?\s*[:=]\s*function(?:[^(]*)/
        var reFunctionExpression = /['"]?([0-9A-Za-z_]+)['"]?\s*[:=]\s*function\b/;
        // {name} = eval()
        var reFunctionEvaluation = /['"]?([0-9A-Za-z_]+)['"]?\s*[:=]\s*(?:eval|new Function)\b/;
        // Walk backwards in the source lines until we find
        // the line which matches one of the patterns above
        var code = "", line, maxLines = Math.min(lineNo, 20), m, commentPos;
        for (var i = 0; i < maxLines; ++i) {
            // lineNo is 1-based, source[] is 0-based
            line = source[lineNo - i - 1];
            commentPos = line.indexOf('//');
            if (commentPos >= 0) {
                line = line.substr(0, commentPos);
            }
            // TODO check other types of comments? Commented code may lead to false positive
            if (line) {
                code = line + code;
                m = reFunctionExpression.exec(code);
                if (m && m[1]) {
                    return m[1];
                }
                m = reFunctionDeclaration.exec(code);
                if (m && m[1]) {
                    //return m[1] + "(" + (m[2] || "") + ")";
                    return m[1];
                }
                m = reFunctionEvaluation.exec(code);
                if (m && m[1]) {
                    return m[1];
                }
            }
        }
        return '(?)';
    }
};