Fixed #730, #733: problems with saving
[redakcja.git] / redakcja / static / js / lib / jquery / jquery.autocomplete.js
1 /*
2  * jQuery Autocomplete plugin 1.1
3  *
4  * Copyright (c) 2009 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 15 2009-08-22 10:30:27Z joern.zaefferer $
11  */
12
13 ;(function($) {
14
15 $.fn.extend({
16         autocomplete: function(urlOrData, options) {
17                 var isUrl = typeof urlOrData == "string";
18                 options = $.extend({}, $.Autocompleter.defaults, {
19                         url: isUrl ? urlOrData : null,
20                         data: isUrl ? null : urlOrData,
21                         delay: isUrl ? $.Autocompleter.defaults.delay : 10,
22                         max: options && !options.scroll ? 10 : 150
23                 }, options);
24
25                 // if highlight is set to false, replace it with a do-nothing function
26                 options.highlight = options.highlight || function(value) { return value; };
27
28                 // if the formatMatch option is not specified, then use formatItem for backwards compatibility
29                 options.formatMatch = options.formatMatch || options.formatItem;
30
31                 return this.each(function() {
32                         new $.Autocompleter(this, options);
33                 });
34         },
35         result: function(handler) {
36                 return this.bind("result", handler);
37         },
38         search: function(handler) {
39                 return this.trigger("search", [handler]);
40         },
41         flushCache: function() {
42                 return this.trigger("flushCache");
43         },
44         setOptions: function(options){
45                 return this.trigger("setOptions", [options]);
46         },
47         unautocomplete: function() {
48                 return this.trigger("unautocomplete");
49         }
50 });
51
52 $.Autocompleter = function(input, options) {
53
54         var KEY = {
55                 UP: 38,
56                 DOWN: 40,
57                 DEL: 46,
58                 TAB: 9,
59                 RETURN: 13,
60                 ESC: 27,
61                 COMMA: 188,
62                 PAGEUP: 33,
63                 PAGEDOWN: 34,
64                 BACKSPACE: 8
65         };
66
67         // Create $ object for input element
68         var $input = $(input).attr("autocomplete", "off").addClass(options.inputClass);
69
70         var timeout;
71         var previousValue = "";
72         var cache = $.Autocompleter.Cache(options);
73         var hasFocus = 0;
74         var lastKeyPressCode;
75         var config = {
76                 mouseDownOnSelect: false
77         };
78         var select = $.Autocompleter.Select(options, input, selectCurrent, config);
79
80         var blockSubmit;
81
82         // prevent form submit in opera when selecting with return key
83         $.browser.opera && $(input.form).bind("submit.autocomplete", function() {
84                 if (blockSubmit) {
85                         blockSubmit = false;
86                         return false;
87                 }
88         });
89
90         // only opera doesn't trigger keydown multiple times while pressed, others don't work with keypress at all
91         $input.bind(($.browser.opera ? "keypress" : "keydown") + ".autocomplete", function(event) {
92                 // a keypress means the input has focus
93                 // avoids issue where input had focus before the autocomplete was applied
94                 hasFocus = 1;
95                 // track last key pressed
96                 lastKeyPressCode = event.keyCode;
97                 switch(event.keyCode) {
98
99                         case KEY.UP:
100                                 event.preventDefault();
101                                 if ( select.visible() ) {
102                                         select.prev();
103                                 } else {
104                                         onChange(0, true);
105                                 }
106                                 break;
107
108                         case KEY.DOWN:
109                                 event.preventDefault();
110                                 if ( select.visible() ) {
111                                         select.next();
112                                 } else {
113                                         onChange(0, true);
114                                 }
115                                 break;
116
117                         case KEY.PAGEUP:
118                                 event.preventDefault();
119                                 if ( select.visible() ) {
120                                         select.pageUp();
121                                 } else {
122                                         onChange(0, true);
123                                 }
124                                 break;
125
126                         case KEY.PAGEDOWN:
127                                 event.preventDefault();
128                                 if ( select.visible() ) {
129                                         select.pageDown();
130                                 } else {
131                                         onChange(0, true);
132                                 }
133                                 break;
134
135                         // matches also semicolon
136                         case options.multiple && $.trim(options.multipleSeparator) == "," && KEY.COMMA:
137                         case KEY.TAB:
138                         case KEY.RETURN:
139                                 if( selectCurrent() ) {
140                                         // stop default to prevent a form submit, Opera needs special handling
141                                         event.preventDefault();
142                                         blockSubmit = true;
143                                         return false;
144                                 }
145                                 break;
146
147                         case KEY.ESC:
148                                 select.hide();
149                                 break;
150
151                         default:
152                                 clearTimeout(timeout);
153                                 timeout = setTimeout(onChange, options.delay);
154                                 break;
155                 }
156         }).focus(function(){
157                 // track whether the field has focus, we shouldn't process any
158                 // results if the field no longer has focus
159                 hasFocus++;
160         }).blur(function() {
161                 hasFocus = 0;
162                 if (!config.mouseDownOnSelect) {
163                         hideResults();
164                 }
165         }).click(function() {
166                 // show select when clicking in a focused field
167                 if ( hasFocus++ > 1 && !select.visible() ) {
168                         onChange(0, true);
169                 }
170         }).bind("search", function() {
171                 // TODO why not just specifying both arguments?
172                 var fn = (arguments.length > 1) ? arguments[1] : null;
173                 function findValueCallback(q, data) {
174                         var result;
175                         if( data && data.length ) {
176                                 for (var i=0; i < data.length; i++) {
177                                         if( data[i].result.toLowerCase() == q.toLowerCase() ) {
178                                                 result = data[i];
179                                                 break;
180                                         }
181                                 }
182                         }
183                         if( typeof fn == "function" ) fn(result);
184                         else $input.trigger("result", result && [result.data, result.value]);
185                 }
186                 $.each(trimWords($input.val()), function(i, value) {
187                         request(value, findValueCallback, findValueCallback);
188                 });
189         }).bind("flushCache", function() {
190                 cache.flush();
191         }).bind("setOptions", function() {
192                 $.extend(options, arguments[1]);
193                 // if we've updated the data, repopulate
194                 if ( "data" in arguments[1] )
195                         cache.populate();
196         }).bind("unautocomplete", function() {
197                 select.unbind();
198                 $input.unbind();
199                 $(input.form).unbind(".autocomplete");
200         });
201
202
203         function selectCurrent() {
204                 var selected = select.selected();
205                 if( !selected )
206                         return false;
207
208                 var v = selected.result;
209                 previousValue = v;
210
211                 if ( options.multiple ) {
212                         var words = trimWords($input.val());
213                         if ( words.length > 1 ) {
214                                 var seperator = options.multipleSeparator.length;
215                                 var cursorAt = $(input).selection().start;
216                                 var wordAt, progress = 0;
217                                 $.each(words, function(i, word) {
218                                         progress += word.length;
219                                         if (cursorAt <= progress) {
220                                                 wordAt = i;
221                                                 return false;
222                                         }
223                                         progress += seperator;
224                                 });
225                                 words[wordAt] = v;
226                                 // TODO this should set the cursor to the right position, but it gets overriden somewhere
227                                 //$.Autocompleter.Selection(input, progress + seperator, progress + seperator);
228                                 v = words.join( options.multipleSeparator );
229                         }
230                         v += options.multipleSeparator;
231                 }
232
233                 $input.val(v);
234                 hideResultsNow();
235                 $input.trigger("result", [selected.data, selected.value]);
236                 return true;
237         }
238
239         function onChange(crap, skipPrevCheck) {
240                 if( lastKeyPressCode == KEY.DEL ) {
241                         select.hide();
242                         return;
243                 }
244
245                 var currentValue = $input.val();
246
247                 if ( !skipPrevCheck && currentValue == previousValue )
248                         return;
249
250                 previousValue = currentValue;
251
252                 currentValue = lastWord(currentValue);
253                 if ( currentValue.length >= options.minChars) {
254                         $input.addClass(options.loadingClass);
255                         if (!options.matchCase)
256                                 currentValue = currentValue.toLowerCase();
257                         request(currentValue, receiveData, hideResultsNow);
258                 } else {
259                         stopLoading();
260                         select.hide();
261                 }
262         };
263
264         function trimWords(value) {
265                 if (!value)
266                         return [""];
267                 if (!options.multiple)
268                         return [$.trim(value)];
269                 return $.map(value.split(options.multipleSeparator), function(word) {
270                         return $.trim(value).length ? $.trim(word) : null;
271                 });
272         }
273
274         function lastWord(value) {
275                 if ( !options.multiple )
276                         return value;
277                 var words = trimWords(value);
278                 if (words.length == 1)
279                         return words[0];
280                 var cursorAt = $(input).selection().start;
281                 if (cursorAt == value.length) {
282                         words = trimWords(value)
283                 } else {
284                         words = trimWords(value.replace(value.substring(cursorAt), ""));
285                 }
286                 return words[words.length - 1];
287         }
288
289         // fills in the input box w/the first match (assumed to be the best match)
290         // q: the term entered
291         // sValue: the first matching result
292         function autoFill(q, sValue){
293                 // autofill in the complete box w/the first match as long as the user hasn't entered in more data
294                 // if the last user key pressed was backspace, don't autofill
295                 if( options.autoFill && (lastWord($input.val()).toLowerCase() == q.toLowerCase()) && lastKeyPressCode != KEY.BACKSPACE ) {
296                         // fill in the value (keep the case the user has typed)
297                         $input.val($input.val() + sValue.substring(lastWord(previousValue).length));
298                         // select the portion of the value not typed by the user (so the next character will erase)
299                         $(input).selection(previousValue.length, previousValue.length + sValue.length);
300                 }
301         };
302
303         function hideResults() {
304                 clearTimeout(timeout);
305                 timeout = setTimeout(hideResultsNow, 200);
306         };
307
308         function hideResultsNow() {
309                 var wasVisible = select.visible();
310                 select.hide();
311                 clearTimeout(timeout);
312                 stopLoading();
313                 if (options.mustMatch) {
314                         // call search and run callback
315                         $input.search(
316                                 function (result){
317                                         // if no value found, clear the input box
318                                         if( !result ) {
319                                                 if (options.multiple) {
320                                                         var words = trimWords($input.val()).slice(0, -1);
321                                                         $input.val( words.join(options.multipleSeparator) + (words.length ? options.multipleSeparator : "") );
322                                                 }
323                                                 else {
324                                                         $input.val( "" );
325                                                         $input.trigger("result", null);
326                                                 }
327                                         }
328                                 }
329                         );
330                 }
331         };
332
333         function receiveData(q, data) {
334                 if ( data && data.length && hasFocus ) {
335                         stopLoading();
336                         select.display(data, q);
337                         autoFill(q, data[0].value);
338                         select.show();
339                 } else {
340                         hideResultsNow();
341                 }
342         };
343
344         function request(term, success, failure) {
345                 if (!options.matchCase)
346                         term = term.toLowerCase();
347                 var data = cache.load(term);
348                 // recieve the cached data
349                 if (data && data.length) {
350                         success(term, data);
351                 // if an AJAX url has been supplied, try loading the data now
352                 } else if( (typeof options.url == "string") && (options.url.length > 0) ){
353
354                         var extraParams = {
355                                 timestamp: +new Date()
356                         };
357                         $.each(options.extraParams, function(key, param) {
358                                 extraParams[key] = typeof param == "function" ? param() : param;
359                         });
360
361                         $.ajax({
362                                 // try to leverage ajaxQueue plugin to abort previous requests
363                                 mode: "abort",
364                                 // limit abortion to this input
365                                 port: "autocomplete" + input.name,
366                                 dataType: options.dataType,
367                                 url: options.url,
368                                 data: $.extend({
369                                         q: lastWord(term),
370                                         limit: options.max
371                                 }, extraParams),
372                                 success: function(data) {
373                                         var parsed = options.parse && options.parse(data) || parse(data);
374                                         cache.add(term, parsed);
375                                         success(term, parsed);
376                                 }
377                         });
378                 } else {
379                         // if we have a failure, we need to empty the list -- this prevents the the [TAB] key from selecting the last successful match
380                         select.emptyList();
381                         failure(term);
382                 }
383         };
384
385         function parse(data) {
386                 var parsed = [];
387                 var rows = data.split("\n");
388                 for (var i=0; i < rows.length; i++) {
389                         var row = $.trim(rows[i]);
390                         if (row) {
391                                 row = row.split("|");
392                                 parsed[parsed.length] = {
393                                         data: row,
394                                         value: row[0],
395                                         result: options.formatResult && options.formatResult(row, row[0]) || row[0]
396                                 };
397                         }
398                 }
399                 return parsed;
400         };
401
402         function stopLoading() {
403                 $input.removeClass(options.loadingClass);
404         };
405
406 };
407
408 $.Autocompleter.defaults = {
409         inputClass: "ac_input",
410         resultsClass: "ac_results",
411         loadingClass: "ac_loading",
412         minChars: 1,
413         delay: 400,
414         matchCase: false,
415         matchSubset: true,
416         matchContains: false,
417         cacheLength: 10,
418         max: 100,
419         mustMatch: false,
420         extraParams: {},
421         selectFirst: true,
422         formatItem: function(row) { return row[0]; },
423         formatMatch: null,
424         autoFill: false,
425         width: 0,
426         multiple: false,
427         multipleSeparator: ", ",
428         highlight: function(value, term) {
429                 return value.replace(new RegExp("(?![^&;]+;)(?!<[^<>]*)(" + term.replace(/([\^\$\(\)\[\]\{\}\*\.\+\?\|\\])/gi, "\\$1") + ")(?![^<>]*>)(?![^&;]+;)", "gi"), "<strong>$1</strong>");
430         },
431     scroll: true,
432     scrollHeight: 180
433 };
434
435 $.Autocompleter.Cache = function(options) {
436
437         var data = {};
438         var length = 0;
439
440         function matchSubset(s, sub) {
441                 if (!options.matchCase)
442                         s = s.toLowerCase();
443                 var i = s.indexOf(sub);
444                 if (options.matchContains == "word"){
445                         i = s.toLowerCase().search("\\b" + sub.toLowerCase());
446                 }
447                 if (i == -1) return false;
448                 return i == 0 || options.matchContains;
449         };
450
451         function add(q, value) {
452                 if (length > options.cacheLength){
453                         flush();
454                 }
455                 if (!data[q]){
456                         length++;
457                 }
458                 data[q] = value;
459         }
460
461         function populate(){
462                 if( !options.data ) return false;
463                 // track the matches
464                 var stMatchSets = {},
465                         nullData = 0;
466
467                 // no url was specified, we need to adjust the cache length to make sure it fits the local data store
468                 if( !options.url ) options.cacheLength = 1;
469
470                 // track all options for minChars = 0
471                 stMatchSets[""] = [];
472
473                 // loop through the array and create a lookup structure
474                 for ( var i = 0, ol = options.data.length; i < ol; i++ ) {
475                         var rawValue = options.data[i];
476                         // if rawValue is a string, make an array otherwise just reference the array
477                         rawValue = (typeof rawValue == "string") ? [rawValue] : rawValue;
478
479                         var value = options.formatMatch(rawValue, i+1, options.data.length);
480                         if ( value === false )
481                                 continue;
482
483                         var firstChar = value.charAt(0).toLowerCase();
484                         // if no lookup array for this character exists, look it up now
485                         if( !stMatchSets[firstChar] )
486                                 stMatchSets[firstChar] = [];
487
488                         // if the match is a string
489                         var row = {
490                                 value: value,
491                                 data: rawValue,
492                                 result: options.formatResult && options.formatResult(rawValue) || value
493                         };
494
495                         // push the current match into the set list
496                         stMatchSets[firstChar].push(row);
497
498                         // keep track of minChars zero items
499                         if ( nullData++ < options.max ) {
500                                 stMatchSets[""].push(row);
501                         }
502                 };
503
504                 // add the data items to the cache
505                 $.each(stMatchSets, function(i, value) {
506                         // increase the cache size
507                         options.cacheLength++;
508                         // add to the cache
509                         add(i, value);
510                 });
511         }
512
513         // populate any existing data
514         setTimeout(populate, 25);
515
516         function flush(){
517                 data = {};
518                 length = 0;
519         }
520
521         return {
522                 flush: flush,
523                 add: add,
524                 populate: populate,
525                 load: function(q) {
526                         if (!options.cacheLength || !length)
527                                 return null;
528                         /*
529                          * if dealing w/local data and matchContains than we must make sure
530                          * to loop through all the data collections looking for matches
531                          */
532                         if( !options.url && options.matchContains ){
533                                 // track all matches
534                                 var csub = [];
535                                 // loop through all the data grids for matches
536                                 for( var k in data ){
537                                         // don't search through the stMatchSets[""] (minChars: 0) cache
538                                         // this prevents duplicates
539                                         if( k.length > 0 ){
540                                                 var c = data[k];
541                                                 $.each(c, function(i, x) {
542                                                         // if we've got a match, add it to the array
543                                                         if (matchSubset(x.value, q)) {
544                                                                 csub.push(x);
545                                                         }
546                                                 });
547                                         }
548                                 }
549                                 return csub;
550                         } else
551                         // if the exact item exists, use it
552                         if (data[q]){
553                                 return data[q];
554                         } else
555                         if (options.matchSubset) {
556                                 for (var i = q.length - 1; i >= options.minChars; i--) {
557                                         var c = data[q.substr(0, i)];
558                                         if (c) {
559                                                 var csub = [];
560                                                 $.each(c, function(i, x) {
561                                                         if (matchSubset(x.value, q)) {
562                                                                 csub[csub.length] = x;
563                                                         }
564                                                 });
565                                                 return csub;
566                                         }
567                                 }
568                         }
569                         return null;
570                 }
571         };
572 };
573
574 $.Autocompleter.Select = function (options, input, select, config) {
575         var CLASSES = {
576                 ACTIVE: "ac_over"
577         };
578
579         var listItems,
580                 active = -1,
581                 data,
582                 term = "",
583                 needsInit = true,
584                 element,
585                 list;
586
587         // Create results
588         function init() {
589                 if (!needsInit)
590                         return;
591                 element = $("<div/>")
592                 .hide()
593                 .addClass(options.resultsClass)
594                 .css("position", "absolute")
595                 .appendTo(document.body);
596
597                 list = $("<ul/>").appendTo(element).mouseover( function(event) {
598                         if(target(event).nodeName && target(event).nodeName.toUpperCase() == 'LI') {
599                     active = $("li", list).removeClass(CLASSES.ACTIVE).index(target(event));
600                             $(target(event)).addClass(CLASSES.ACTIVE);
601                 }
602                 }).click(function(event) {
603                         $(target(event)).addClass(CLASSES.ACTIVE);
604                         select();
605                         // TODO provide option to avoid setting focus again after selection? useful for cleanup-on-focus
606                         input.focus();
607                         return false;
608                 }).mousedown(function() {
609                         config.mouseDownOnSelect = true;
610                 }).mouseup(function() {
611                         config.mouseDownOnSelect = false;
612                 });
613
614                 if( options.width > 0 )
615                         element.css("width", options.width);
616
617                 needsInit = false;
618         }
619
620         function target(event) {
621                 var element = event.target;
622                 while(element && element.tagName != "LI")
623                         element = element.parentNode;
624                 // more fun with IE, sometimes event.target is empty, just ignore it then
625                 if(!element)
626                         return [];
627                 return element;
628         }
629
630         function moveSelect(step) {
631                 listItems.slice(active, active + 1).removeClass(CLASSES.ACTIVE);
632                 movePosition(step);
633         var activeItem = listItems.slice(active, active + 1).addClass(CLASSES.ACTIVE);
634         if(options.scroll) {
635             var offset = 0;
636             listItems.slice(0, active).each(function() {
637                                 offset += this.offsetHeight;
638                         });
639             if((offset + activeItem[0].offsetHeight - list.scrollTop()) > list[0].clientHeight) {
640                 list.scrollTop(offset + activeItem[0].offsetHeight - list.innerHeight());
641             } else if(offset < list.scrollTop()) {
642                 list.scrollTop(offset);
643             }
644         }
645         };
646
647         function movePosition(step) {
648                 active += step;
649                 if (active < 0) {
650                         active = listItems.size() - 1;
651                 } else if (active >= listItems.size()) {
652                         active = 0;
653                 }
654         }
655
656         function limitNumberOfItems(available) {
657                 return options.max && options.max < available
658                         ? options.max
659                         : available;
660         }
661
662         function fillList() {
663                 list.empty();
664                 var max = limitNumberOfItems(data.length);
665                 for (var i=0; i < max; i++) {
666                         if (!data[i])
667                                 continue;
668                         var formatted = options.formatItem(data[i].data, i+1, max, data[i].value, term);
669                         if ( formatted === false )
670                                 continue;
671                         var li = $("<li/>").html( options.highlight(formatted, term) ).addClass(i%2 == 0 ? "ac_even" : "ac_odd").appendTo(list)[0];
672                         $.data(li, "ac_data", data[i]);
673                 }
674                 listItems = list.find("li");
675                 if ( options.selectFirst ) {
676                         listItems.slice(0, 1).addClass(CLASSES.ACTIVE);
677                         active = 0;
678                 }
679                 // apply bgiframe if available
680                 if ( $.fn.bgiframe )
681                         list.bgiframe();
682         }
683
684         return {
685                 display: function(d, q) {
686                         init();
687                         data = d;
688                         term = q;
689                         fillList();
690                 },
691                 next: function() {
692                         moveSelect(1);
693                 },
694                 prev: function() {
695                         moveSelect(-1);
696                 },
697                 pageUp: function() {
698                         if (active != 0 && active - 8 < 0) {
699                                 moveSelect( -active );
700                         } else {
701                                 moveSelect(-8);
702                         }
703                 },
704                 pageDown: function() {
705                         if (active != listItems.size() - 1 && active + 8 > listItems.size()) {
706                                 moveSelect( listItems.size() - 1 - active );
707                         } else {
708                                 moveSelect(8);
709                         }
710                 },
711                 hide: function() {
712                         element && element.hide();
713                         listItems && listItems.removeClass(CLASSES.ACTIVE);
714                         active = -1;
715                 },
716                 visible : function() {
717                         return element && element.is(":visible");
718                 },
719                 current: function() {
720                         return this.visible() && (listItems.filter("." + CLASSES.ACTIVE)[0] || options.selectFirst && listItems[0]);
721                 },
722                 show: function() {
723                         var offset = $(input).offset();
724                         element.css({
725                                 width: typeof options.width == "string" || options.width > 0 ? options.width : $(input).width(),
726                                 top: offset.top + input.offsetHeight,
727                                 left: offset.left
728                         }).show();
729             if(options.scroll) {
730                 list.scrollTop(0);
731                 list.css({
732                                         maxHeight: options.scrollHeight,
733                                         overflow: 'auto'
734                                 });
735
736                 if($.browser.msie && typeof document.body.style.maxHeight === "undefined") {
737                                         var listHeight = 0;
738                                         listItems.each(function() {
739                                                 listHeight += this.offsetHeight;
740                                         });
741                                         var scrollbarsVisible = listHeight > options.scrollHeight;
742                     list.css('height', scrollbarsVisible ? options.scrollHeight : listHeight );
743                                         if (!scrollbarsVisible) {
744                                                 // IE doesn't recalculate width when scrollbar disappears
745                                                 listItems.width( list.width() - parseInt(listItems.css("padding-left")) - parseInt(listItems.css("padding-right")) );
746                                         }
747                 }
748
749             }
750                 },
751                 selected: function() {
752                         var selected = listItems && listItems.filter("." + CLASSES.ACTIVE).removeClass(CLASSES.ACTIVE);
753                         return selected && selected.length && $.data(selected[0], "ac_data");
754                 },
755                 emptyList: function (){
756                         list && list.empty();
757                 },
758                 unbind: function() {
759                         element && element.remove();
760                 }
761         };
762 };
763
764 $.fn.selection = function(start, end) {
765         if (start !== undefined) {
766                 return this.each(function() {
767                         if( this.createTextRange ){
768                                 var selRange = this.createTextRange();
769                                 if (end === undefined || start == end) {
770                                         selRange.move("character", start);
771                                         selRange.select();
772                                 } else {
773                                         selRange.collapse(true);
774                                         selRange.moveStart("character", start);
775                                         selRange.moveEnd("character", end);
776                                         selRange.select();
777                                 }
778                         } else if( this.setSelectionRange ){
779                                 this.setSelectionRange(start, end);
780                         } else if( this.selectionStart ){
781                                 this.selectionStart = start;
782                                 this.selectionEnd = end;
783                         }
784                 });
785         }
786         var field = this[0];
787         if ( field.createTextRange ) {
788                 var range = document.selection.createRange(),
789                         orig = field.value,
790                         teststring = "<->",
791                         textLength = range.text.length;
792                 range.text = teststring;
793                 var caretAt = field.value.indexOf(teststring);
794                 field.value = orig;
795                 this.selection(caretAt, caretAt + textLength);
796                 return {
797                         start: caretAt,
798                         end: caretAt + textLength
799                 }
800         } else if( field.selectionStart !== undefined ){
801                 return {
802                         start: field.selectionStart,
803                         end: field.selectionEnd
804                 }
805         }
806 };
807
808 })(jQuery);