1 /*

     2  * Autocomplete - jQuery plugin 1.0.2

     3  *

     4  * Copyright (c) 2007 Dylan Verheul, Dan G. Switzer, Anjesh Tuladhar, Jörn Zaefferer

     5  *

     6  * Dual licensed under the MIT and GPL licenses:

     7  *   http://www.opensource.org/licenses/mit-license.php

     8  *   http://www.gnu.org/licenses/gpl.html

     9  *

    10  * Revision: $Id: jquery.autocomplete.js 5747 2008-06-25 18:30:55Z joern.zaefferer $

    11  *

    12  */

    13 

    14 ;(function($) {

    15 

    16 $.fn.extend({

    17 	autocomplete: function(urlOrData, options) {

    18 		var isUrl = typeof urlOrData == "string";

    19 		options = $.extend({}, $.Autocompleter.defaults, {

    20 			url: isUrl ? urlOrData : null,

    21 			data: isUrl ? null : urlOrData,

    22 			delay: isUrl ? $.Autocompleter.defaults.delay : 10,

    23 			max: options && !options.scroll ? 10 : 150

    24 		}, options);

    25 

    26 		// if highlight is set to false, replace it with a do-nothing function

    27 		options.highlight = options.highlight || function(value) { return value; };

    28 

    29 		// if the formatMatch option is not specified, then use formatItem for backwards compatibility

    30 		options.formatMatch = options.formatMatch || options.formatItem;

    31 

    32 		return this.each(function() {

    33 			new $.Autocompleter(this, options);

    34 		});

    35 	},

    36 	result: function(handler) {

    37 		return this.bind("result", handler);

    38 	},

    39 	search: function(handler) {

    40 		return this.trigger("search", [handler]);

    41 	},

    42 	flushCache: function() {

    43 		return this.trigger("flushCache");

    44 	},

    45 	setOptions: function(options){

    46 		return this.trigger("setOptions", [options]);

    47 	},

    48 	unautocomplete: function() {

    49 		return this.trigger("unautocomplete");

    50 	}

    51 });

    52 

    53 $.Autocompleter = function(input, options) {

    54 

    55 	var KEY = {

    56 		UP: 38,

    57 		DOWN: 40,

    58 		DEL: 46,

    59 		TAB: 9,

    60 		RETURN: 13,

    61 		ESC: 27,

    62 		COMMA: 188,

    63 		PAGEUP: 33,

    64 		PAGEDOWN: 34,

    65 		BACKSPACE: 8

    66 	};

    67 

    68 	// Create $ object for input element

    69 	var $input = $(input).attr("autocomplete", "off").addClass(options.inputClass);

    70 

    71 	var timeout;

    72 	var previousValue = "";

    73 	var cache = $.Autocompleter.Cache(options);

    74 	var hasFocus = 0;

    75 	var lastKeyPressCode;

    76 	var config = {

    77 		mouseDownOnSelect: false

    78 	};

    79 	var select = $.Autocompleter.Select(options, input, selectCurrent, config);

    80 

    81 	var blockSubmit;

    82 

    83 	// prevent form submit in opera when selecting with return key

    84 	$.browser.opera && $(input.form).bind("submit.autocomplete", function() {

    85 		if (blockSubmit) {

    86 			blockSubmit = false;

    87 			return false;

    88 		}

    89 	});

    90 

    91 	// only opera doesn't trigger keydown multiple times while pressed, others don't work with keypress at all

    92 	$input.bind(($.browser.opera ? "keypress" : "keydown") + ".autocomplete", function(event) {

    93 		// track last key pressed

    94 		lastKeyPressCode = event.keyCode;

    95 		switch(event.keyCode) {

    96 

    97 			case KEY.UP:

    98 				event.preventDefault();

    99 				if ( select.visible() ) {

   100 					select.prev();

   101 				} else {

   102 					onChange(0, true);

   103 				}

   104 				break;

   105 

   106 			case KEY.DOWN:

   107 				event.preventDefault();

   108 				if ( select.visible() ) {

   109 					select.next();

   110 				} else {

   111 					onChange(0, true);

   112 				}

   113 				break;

   114 

   115 			case KEY.PAGEUP:

   116 				event.preventDefault();

   117 				if ( select.visible() ) {

   118 					select.pageUp();

   119 				} else {

   120 					onChange(0, true);

   121 				}

   122 				break;

   123 

   124 			case KEY.PAGEDOWN:

   125 				event.preventDefault();

   126 				if ( select.visible() ) {

   127 					select.pageDown();

   128 				} else {

   129 					onChange(0, true);

   130 				}

   131 				break;

   132 

   133 			// matches also semicolon

   134 			case options.multiple && $.trim(options.multipleSeparator) == "," && KEY.COMMA:

   135 			case KEY.TAB:

   136 			case KEY.RETURN:

   137 				if( selectCurrent() ) {

   138 					// stop default to prevent a form submit, Opera needs special handling

   139 					event.preventDefault();

   140 					blockSubmit = true;

   141 					return false;

   142 				}

   143 				break;

   144 

   145 			case KEY.ESC:

   146 				select.hide();

   147 				break;

   148 

   149 			default:

   150 				clearTimeout(timeout);

   151 				timeout = setTimeout(onChange, options.delay);

   152 				break;

   153 		}

   154 	}).focus(function(){

   155 		// track whether the field has focus, we shouldn't process any

   156 		// results if the field no longer has focus

   157 		hasFocus++;

   158 	}).blur(function() {

   159 		hasFocus = 0;

   160 		if (!config.mouseDownOnSelect) {

   161 			hideResults();

   162 		}

   163 	}).click(function() {

   164 		// show select when clicking in a focused field

   165 		if ( hasFocus++ > 1 && !select.visible() ) {

   166 			onChange(0, true);

   167 		}

   168 	}).bind("search", function() {

   169 		// TODO why not just specifying both arguments?

   170 		var fn = (arguments.length > 1) ? arguments[1] : null;

   171 		function findValueCallback(q, data) {

   172 			var result;

   173 			if( data && data.length ) {

   174 				for (var i=0; i < data.length; i++) {

   175 					if( data[i].result.toLowerCase() == q.toLowerCase() ) {

   176 						result = data[i];

   177 						break;

   178 					}

   179 				}

   180 			}

   181 			if( typeof fn == "function" ) fn(result);

   182 			else $input.trigger("result", result && [result.data, result.value]);

   183 		}

   184 		$.each(trimWords($input.val()), function(i, value) {

   185 			request(value, findValueCallback, findValueCallback);

   186 		});

   187 	}).bind("flushCache", function() {

   188 		cache.flush();

   189 	}).bind("setOptions", function() {

   190 		$.extend(options, arguments[1]);

   191 		// if we've updated the data, repopulate

   192 		if ( "data" in arguments[1] )

   193 			cache.populate();

   194 	}).bind("unautocomplete", function() {

   195 		select.unbind();

   196 		$input.unbind();

   197 		$(input.form).unbind(".autocomplete");

   198 	});

   199 

   200 

   201 	function selectCurrent() {

   202 		var selected = select.selected();

   203 		if( !selected )

   204 			return false;

   205 

   206 		var v = selected.result;

   207 		previousValue = v;

   208 

   209 		if ( options.multiple ) {

   210 			var words = trimWords($input.val());

   211 			if ( words.length > 1 ) {

   212 				v = words.slice(0, words.length - 1).join( options.multipleSeparator ) + options.multipleSeparator + v;

   213 			}

   214 			v += options.multipleSeparator;

   215 		}

   216 

   217 		$input.val(v);

   218 		hideResultsNow();

   219 		$input.trigger("result", [selected.data, selected.value]);

   220 		return true;

   221 	}

   222 

   223 	function onChange(crap, skipPrevCheck) {

   224 		if( lastKeyPressCode == KEY.DEL ) {

   225 			select.hide();

   226 			return;

   227 		}

   228 

   229 		var currentValue = $input.val();

   230 

   231 		if ( !skipPrevCheck && currentValue == previousValue )

   232 			return;

   233 

   234 		previousValue = currentValue;

   235 

   236 		currentValue = lastWord(currentValue);

   237 		if ( currentValue.length >= options.minChars) {

   238 			$input.addClass(options.loadingClass);

   239 			if (!options.matchCase)

   240 				currentValue = currentValue.toLowerCase();

   241 			request(currentValue, receiveData, hideResultsNow);

   242 		} else {

   243 			stopLoading();

   244 			select.hide();

   245 		}

   246 	};

   247 

   248 	function trimWords(value) {

   249 		if ( !value ) {

   250 			return [""];

   251 		}

   252 		var words = value.split( options.multipleSeparator );

   253 		var result = [];

   254 		$.each(words, function(i, value) {

   255 			if ( $.trim(value) )

   256 				result[i] = $.trim(value);

   257 		});

   258 		return result;

   259 	}

   260 

   261 	function lastWord(value) {

   262 		if ( !options.multiple )

   263 			return value;

   264 		var words = trimWords(value);

   265 		return words[words.length - 1];

   266 	}

   267 

   268 	// fills in the input box w/the first match (assumed to be the best match)

   269 	// q: the term entered

   270 	// sValue: the first matching result

   271 	function autoFill(q, sValue){

   272 		// autofill in the complete box w/the first match as long as the user hasn't entered in more data

   273 		// if the last user key pressed was backspace, don't autofill

   274 		if( options.autoFill && (lastWord($input.val()).toLowerCase() == q.toLowerCase()) && lastKeyPressCode != KEY.BACKSPACE ) {

   275 			// fill in the value (keep the case the user has typed)

   276 			$input.val($input.val() + sValue.substring(lastWord(previousValue).length));

   277 			// select the portion of the value not typed by the user (so the next character will erase)

   278 			$.Autocompleter.Selection(input, previousValue.length, previousValue.length + sValue.length);

   279 		}

   280 	};

   281 

   282 	function hideResults() {

   283 		clearTimeout(timeout);

   284 		timeout = setTimeout(hideResultsNow, 200);

   285 	};

   286 

   287 	function hideResultsNow() {

   288 		var wasVisible = select.visible();

   289 		select.hide();

   290 		clearTimeout(timeout);

   291 		stopLoading();

   292 		if (options.mustMatch) {

   293 			// call search and run callback

   294 			$input.search(

   295 				function (result){

   296 					// if no value found, clear the input box

   297 					if( !result ) {

   298 						if (options.multiple) {

   299 							var words = trimWords($input.val()).slice(0, -1);

   300 							$input.val( words.join(options.multipleSeparator) + (words.length ? options.multipleSeparator : "") );

   301 						}

   302 						else

   303 							$input.val( "" );

   304 					}

   305 				}

   306 			);

   307 		}

   308 		if (wasVisible)

   309 			// position cursor at end of input field

   310 			$.Autocompleter.Selection(input, input.value.length, input.value.length);

   311 	};

   312 

   313 	function receiveData(q, data) {

   314 		if ( data && data.length && hasFocus ) {

   315 			stopLoading();

   316 			select.display(data, q);

   317 			autoFill(q, data[0].value);

   318 			select.show();

   319 		} else {

   320 			hideResultsNow();

   321 		}

   322 	};

   323 

   324 	function request(term, success, failure) {

   325 		if (!options.matchCase)

   326 			term = term.toLowerCase();

   327 		var data = cache.load(term);

   328 		// recieve the cached data

   329 		if (data && data.length) {

   330 			success(term, data);

   331 		// if an AJAX url has been supplied, try loading the data now

   332 		} else if( (typeof options.url == "string") && (options.url.length > 0) ){

   333 

   334 			var extraParams = {

   335 				timestamp: +new Date()

   336 			};

   337 			$.each(options.extraParams, function(key, param) {

   338 				extraParams[key] = typeof param == "function" ? param() : param;

   339 			});

   340 

   341 			$.ajax({

   342 				// try to leverage ajaxQueue plugin to abort previous requests

   343 				mode: "abort",

   344 				// limit abortion to this input

   345 				port: "autocomplete" + input.name,

   346 				dataType: options.dataType,

   347 				url: options.url,

   348 				data: $.extend({

   349 					q: lastWord(term),

   350 					limit: options.max

   351 				}, extraParams),

   352 				success: function(data) {

   353 					var parsed = options.parse && options.parse(data) || parse(data);

   354 					cache.add(term, parsed);

   355 					success(term, parsed);

   356 				}

   357 			});

   358 		} else {

   359 			// if we have a failure, we need to empty the list -- this prevents the the [TAB] key from selecting the last successful match

   360 			select.emptyList();

   361 			failure(term);

   362 		}

   363 	};

   364 

   365 	function parse(data) {

   366 		var parsed = [];

   367 		var rows = data.split("\n");

   368 		for (var i=0; i < rows.length; i++) {

   369 			var row = $.trim(rows[i]);

   370 			if (row) {

   371 				row = row.split("|");

   372 				parsed[parsed.length] = {

   373 					data: row,

   374 					value: row[0],

   375 					result: options.formatResult && options.formatResult(row, row[0]) || row[0]

   376 				};

   377 			}

   378 		}

   379 		return parsed;

   380 	};

   381 

   382 	function stopLoading() {

   383 		$input.removeClass(options.loadingClass);

   384 	};

   385 

   386 };

   387 

   388 $.Autocompleter.defaults = {

   389 	inputClass: "ac_input",

   390 	resultsClass: "ac_results",

   391 	loadingClass: "ac_loading",

   392 	minChars: 1,

   393 	delay: 400,

   394 	matchCase: false,

   395 	matchSubset: true,

   396 	matchContains: false,

   397 	cacheLength: 10,

   398 	max: 100,

   399 	mustMatch: false,

   400 	extraParams: {},

   401 	selectFirst: true,

   402 	formatItem: function(row) { return row[0]; },

   403 	formatMatch: null,

   404 	autoFill: false,

   405 	width: 0,

   406 	multiple: false,

   407 	multipleSeparator: ", ",

   408 	highlight: function(value, term) {

   409 		return value.replace(new RegExp("(?![^&;]+;)(?!<[^<>]*)(" + term.replace(/([\^\$\(\)\[\]\{\}\*\.\+\?\|\\])/gi, "\\$1") + ")(?![^<>]*>)(?![^&;]+;)", "gi"), "<strong>$1</strong>");

   410 	},

   411     scroll: true,

   412     scrollHeight: 180

   413 };

   414 

   415 $.Autocompleter.Cache = function(options) {

   416 

   417 	var data = {};

   418 	var length = 0;

   419 

   420 	function matchSubset(s, sub) {

   421 		if (!options.matchCase)

   422 			s = s.toLowerCase();

   423 		var i = s.indexOf(sub);

   424 		if (i == -1) return false;

   425 		return i == 0 || options.matchContains;

   426 	};

   427 

   428 	function add(q, value) {

   429 		if (length > options.cacheLength){

   430 			flush();

   431 		}

   432 		if (!data[q]){

   433 			length++;

   434 		}

   435 		data[q] = value;

   436 	}

   437 

   438 	function populate(){

   439 		if( !options.data ) return false;

   440 		// track the matches

   441 		var stMatchSets = {},

   442 			nullData = 0;

   443 

   444 		// no url was specified, we need to adjust the cache length to make sure it fits the local data store

   445 		if( !options.url ) options.cacheLength = 1;

   446 

   447 		// track all options for minChars = 0

   448 		stMatchSets[""] = [];

   449 

   450 		// loop through the array and create a lookup structure

   451 		for ( var i = 0, ol = options.data.length; i < ol; i++ ) {

   452 			var rawValue = options.data[i];

   453 			// if rawValue is a string, make an array otherwise just reference the array

   454 			rawValue = (typeof rawValue == "string") ? [rawValue] : rawValue;

   455 

   456 			var value = options.formatMatch(rawValue, i+1, options.data.length);

   457 			if ( value === false )

   458 				continue;

   459 

   460 			var firstChar = value.charAt(0).toLowerCase();

   461 			// if no lookup array for this character exists, look it up now

   462 			if( !stMatchSets[firstChar] )

   463 				stMatchSets[firstChar] = [];

   464 

   465 			// if the match is a string

   466 			var row = {

   467 				value: value,

   468 				data: rawValue,

   469 				result: options.formatResult && options.formatResult(rawValue) || value

   470 			};

   471 

   472 			// push the current match into the set list

   473 			stMatchSets[firstChar].push(row);

   474 

   475 			// keep track of minChars zero items

   476 			if ( nullData++ < options.max ) {

   477 				stMatchSets[""].push(row);

   478 			}

   479 		};

   480 

   481 		// add the data items to the cache

   482 		$.each(stMatchSets, function(i, value) {

   483 			// increase the cache size

   484 			options.cacheLength++;

   485 			// add to the cache

   486 			add(i, value);

   487 		});

   488 	}

   489 

   490 	// populate any existing data

   491 	setTimeout(populate, 25);

   492 

   493 	function flush(){

   494 		data = {};

   495 		length = 0;

   496 	}

   497 

   498 	return {

   499 		flush: flush,

   500 		add: add,

   501 		populate: populate,

   502 		load: function(q) {

   503 			if (!options.cacheLength || !length)

   504 				return null;

   505 			/*

   506 			 * if dealing w/local data and matchContains than we must make sure

   507 			 * to loop through all the data collections looking for matches

   508 			 */

   509 			if( !options.url && options.matchContains ){

   510 				// track all matches

   511 				var csub = [];

   512 				// loop through all the data grids for matches

   513 				for( var k in data ){

   514 					// don't search through the stMatchSets[""] (minChars: 0) cache

   515 					// this prevents duplicates

   516 					if( k.length > 0 ){

   517 						var c = data[k];

   518 						$.each(c, function(i, x) {

   519 							// if we've got a match, add it to the array

   520 							if (matchSubset(x.value, q)) {

   521 								csub.push(x);

   522 							}

   523 						});

   524 					}

   525 				}

   526 				return csub;

   527 			} else

   528 			// if the exact item exists, use it

   529 			if (data[q]){

   530 				return data[q];

   531 			} else

   532 			if (options.matchSubset) {

   533 				for (var i = q.length - 1; i >= options.minChars; i--) {

   534 					var c = data[q.substr(0, i)];

   535 					if (c) {

   536 						var csub = [];

   537 						$.each(c, function(i, x) {

   538 							if (matchSubset(x.value, q)) {

   539 								csub[csub.length] = x;

   540 							}

   541 						});

   542 						return csub;

   543 					}

   544 				}

   545 			}

   546 			return null;

   547 		}

   548 	};

   549 };

   550 

   551 $.Autocompleter.Select = function (options, input, select, config) {

   552 	var CLASSES = {

   553 		ACTIVE: "ac_over"

   554 	};

   555 

   556 	var listItems,

   557 		active = -1,

   558 		data,

   559 		term = "",

   560 		needsInit = true,

   561 		element,

   562 		list;

   563 

   564 	// Create results

   565 	function init() {

   566 		if (!needsInit)

   567 			return;

   568 		element = $("<div/>")

   569 		.hide()

   570 		.addClass(options.resultsClass)

   571 		.css("position", "absolute")

   572 		.appendTo(document.body);

   573 

   574 		list = $("<ul/>").appendTo(element).mouseover( function(event) {

   575 			if(target(event).nodeName && target(event).nodeName.toUpperCase() == 'LI') {

   576 	            active = $("li", list).removeClass(CLASSES.ACTIVE).index(target(event));

   577 			    $(target(event)).addClass(CLASSES.ACTIVE);

   578 	        }

   579 		}).click(function(event) {

   580 			$(target(event)).addClass(CLASSES.ACTIVE);

   581 			select();

   582 			// TODO provide option to avoid setting focus again after selection? useful for cleanup-on-focus

   583 			input.focus();

   584 			return false;

   585 		}).mousedown(function() {

   586 			config.mouseDownOnSelect = true;

   587 		}).mouseup(function() {

   588 			config.mouseDownOnSelect = false;

   589 		});

   590 

   591 		if( options.width > 0 )

   592 			element.css("width", options.width);

   593 

   594 		needsInit = false;

   595 	}

   596 

   597 	function target(event) {

   598 		var element = event.target;

   599 		while(element && element.tagName != "LI")

   600 			element = element.parentNode;

   601 		// more fun with IE, sometimes event.target is empty, just ignore it then

   602 		if(!element)

   603 			return [];

   604 		return element;

   605 	}

   606 

   607 	function moveSelect(step) {

   608 		listItems.slice(active, active + 1).removeClass(CLASSES.ACTIVE);

   609 		movePosition(step);

   610         var activeItem = listItems.slice(active, active + 1).addClass(CLASSES.ACTIVE);

   611         if(options.scroll) {

   612             var offset = 0;

   613             listItems.slice(0, active).each(function() {

   614 				offset += this.offsetHeight;

   615 			});

   616             if((offset + activeItem[0].offsetHeight - list.scrollTop()) > list[0].clientHeight) {

   617                 list.scrollTop(offset + activeItem[0].offsetHeight - list.innerHeight());

   618             } else if(offset < list.scrollTop()) {

   619                 list.scrollTop(offset);

   620             }

   621         }

   622 	};

   623 

   624 	function movePosition(step) {

   625 		active += step;

   626 		if (active < 0) {

   627 			active = listItems.size() - 1;

   628 		} else if (active >= listItems.size()) {

   629 			active = 0;

   630 		}

   631 	}

   632 

   633 	function limitNumberOfItems(available) {

   634 		return options.max && options.max < available

   635 			? options.max

   636 			: available;

   637 	}

   638 

   639 	function fillList() {

   640 		list.empty();

   641 		var max = limitNumberOfItems(data.length);

   642 		for (var i=0; i < max; i++) {

   643 			if (!data[i])

   644 				continue;

   645 			var formatted = options.formatItem(data[i].data, i+1, max, data[i].value, term);

   646 			if ( formatted === false )

   647 				continue;

   648 			var li = $("<li/>").html( options.highlight(formatted, term) ).addClass(i%2 == 0 ? "ac_even" : "ac_odd").appendTo(list)[0];

   649 			$.data(li, "ac_data", data[i]);

   650 		}

   651 		listItems = list.find("li");

   652 		if ( options.selectFirst ) {

   653 			listItems.slice(0, 1).addClass(CLASSES.ACTIVE);

   654 			active = 0;

   655 		}

   656 		// apply bgiframe if available

   657 		if ( $.fn.bgiframe )

   658 			list.bgiframe();

   659 	}

   660 

   661 	return {

   662 		display: function(d, q) {

   663 			init();

   664 			data = d;

   665 			term = q;

   666 			fillList();

   667 		},

   668 		next: function() {

   669 			moveSelect(1);

   670 		},

   671 		prev: function() {

   672 			moveSelect(-1);

   673 		},

   674 		pageUp: function() {

   675 			if (active != 0 && active - 8 < 0) {

   676 				moveSelect( -active );

   677 			} else {

   678 				moveSelect(-8);

   679 			}

   680 		},

   681 		pageDown: function() {

   682 			if (active != listItems.size() - 1 && active + 8 > listItems.size()) {

   683 				moveSelect( listItems.size() - 1 - active );

   684 			} else {

   685 				moveSelect(8);

   686 			}

   687 		},

   688 		hide: function() {

   689 			element && element.hide();

   690 			listItems && listItems.removeClass(CLASSES.ACTIVE);

   691 			active = -1;

   692 		},

   693 		visible : function() {

   694 			return element && element.is(":visible");

   695 		},

   696 		current: function() {

   697 			return this.visible() && (listItems.filter("." + CLASSES.ACTIVE)[0] || options.selectFirst && listItems[0]);

   698 		},

   699 		show: function() {

   700 			var offset = $(input).offset();

   701 			element.css({

   702 				width: typeof options.width == "string" || options.width > 0 ? options.width : $(input).width(),

   703 				top: offset.top + input.offsetHeight,

   704 				left: offset.left

   705 			}).show();

   706             if(options.scroll) {

   707                 list.scrollTop(0);

   708                 list.css({

   709 					maxHeight: options.scrollHeight,

   710 					overflow: 'auto'

   711 				});

   712 

   713                 if($.browser.msie && typeof document.body.style.maxHeight === "undefined") {

   714 					var listHeight = 0;

   715 					listItems.each(function() {

   716 						listHeight += this.offsetHeight;

   717 					});

   718 					var scrollbarsVisible = listHeight > options.scrollHeight;

   719                     list.css('height', scrollbarsVisible ? options.scrollHeight : listHeight );

   720 					if (!scrollbarsVisible) {

   721 						// IE doesn't recalculate width when scrollbar disappears

   722 						listItems.width( list.width() - parseInt(listItems.css("padding-left")) - parseInt(listItems.css("padding-right")) );

   723 					}

   724                 }

   725 

   726             }

   727 		},

   728 		selected: function() {

   729 			var selected = listItems && listItems.filter("." + CLASSES.ACTIVE).removeClass(CLASSES.ACTIVE);

   730 			return selected && selected.length && $.data(selected[0], "ac_data");

   731 		},

   732 		emptyList: function (){

   733 			list && list.empty();

   734 		},

   735 		unbind: function() {

   736 			element && element.remove();

   737 		}

   738 	};

   739 };

   740 

   741 $.Autocompleter.Selection = function(field, start, end) {

   742 	if( field.createTextRange ){

   743 		var selRange = field.createTextRange();

   744 		selRange.collapse(true);

   745 		selRange.moveStart("character", start);

   746 		selRange.moveEnd("character", end);

   747 		selRange.select();

   748 	} else if( field.setSelectionRange ){

   749 		field.setSelectionRange(start, end);

   750 	} else {

   751 		if( field.selectionStart ){

   752 			field.selectionStart = start;

   753 			field.selectionEnd = end;

   754 		}

   755 	}

   756 	field.focus();

   757 };

   758 

   759 })(jQuery);