PageSourceSearch

https://seaboats.net/public/js/plugins/starrating/js/star-rating.js?9375568

js seaboats.net collected 2026-09-24 22:48:52 UTC 31,141 bytes, 726 lines download raw bytes

1/*!
2 * bootstrap-star-rating v4.1.2
3 * http://plugins.krajee.com/star-rating
4 *
5 * Author: Kartik Visweswaran
6 * Copyright: 2013 - 2021, Kartik Visweswaran, Krajee.com
7 *
8 * Licensed under the BSD 3-Clause
9 * https://github.com/kartik-v/bootstrap-star-rating/blob/master/LICENSE.md
10 */
11(function (factory) {
12    'use strict';
13    if (typeof define === 'function' && define.amd) {
14        define(['jquery'], factory);
15    } else if (typeof module === 'object' && typeof module.exports === 'object') {
16        factory(require('jquery'));
17    } else {
18        factory(window.jQuery);
19    }
20}(function ($) {
21    'use strict';
22
23    $.fn.ratingLocales = {};
24    $.fn.ratingThemes = {};
25
26    var $h, Rating;
27
28    // Global helper methods and constants
29    $h = {
30        NAMESPACE: '.rating',
31        DEFAULT_MIN: 0,
32        DEFAULT_MAX: 5,
33        DEFAULT_STEP: 0.5,
34        isEmpty: function (value, trim) {
35            return value === null || value === undefined || value.length === 0 || (trim && $.trim(value) === '');
36        },
37        getCss: function (condition, css) {
38            return condition ? ' ' + css : '';
39        },
40        addCss: function ($el, css) {
41            $el.removeClass(css).addClass(css);
42        },
43        getDecimalPlaces: function (num) {
44            var m = ('' + num).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
45            return !m ? 0 : Math.max(0, (m[1] ? m[1].length : 0) - (m[2] ? +m[2] : 0));
46        },
47        applyPrecision: function (val, precision) {
48            return parseFloat(val.toFixed(precision));
49        },
50        handler: function ($el, event, callback, skipOff, skipNS) {
51            var ev = skipNS ? event : event.split(' ').join($h.NAMESPACE + ' ') + $h.NAMESPACE;
52            if (!skipOff) {
53                $el.off(ev);
54            }
55            $el.on(ev, function (e) {
56                var cb = $.proxy(callback, self);
57                cb(e);
58            });
59        }
60    };
61
62    // Rating constructor
63    Rating = function (element, options) {
64        var self = this;
65        self.$element = $(element);
66        self._init(options);
67    };
68
69    // Rating prototype
70    Rating.prototype = {
71        constructor: Rating,
72        _parseAttr: function (vattr, options) {
73            var self = this, $el = self.$element, elType = $el.attr('type'), finalVal, val, chk, out;
74            if (elType === 'range' || elType === 'number') {
75                val = options[vattr] || $el.data(vattr) || $el.attr(vattr);
76                switch (vattr) {
77                    case 'min':
78                        chk = $h.DEFAULT_MIN;
79                        break;
80                    case 'max':
81                        chk = $h.DEFAULT_MAX;
82                        break;
83                    default:
84                        chk = $h.DEFAULT_STEP;
85                }
86                finalVal = $h.isEmpty(val) ? chk : val;
87                out = parseFloat(finalVal);
88            } else {
89                out = parseFloat(options[vattr]);
90            }
91            return isNaN(out) ? chk : out;
92        },
93        _parseValue: function (val) {
94            var self = this, v = parseFloat(val);
95            if (isNaN(v)) {
96                v = self.clearValue;
97            }
98            return (self.zeroAsNull && (v === 0 || v === '0') ? null : v);
99        },
100        _setDefault: function (key, val) {
101            var self = this;
102            if ($h.isEmpty(self[key])) {
103                self[key] = val;
104            }
105        },
106        _initSlider: function (options) {
107            var self = this, v = self.$element.val();
108            self.initialValue = $h.isEmpty(v) ? 0 : v;
109            self._setDefault('min', self._parseAttr('min', options));
110            self._setDefault('max', self._parseAttr('max', options));
111            self._setDefault('step', self._parseAttr('step', options));
112            if (isNaN(self.min) || $h.isEmpty(self.min)) {
113                self.min = $h.DEFAULT_MIN;
114            }
115            if (isNaN(self.max) || $h.isEmpty(self.max)) {
116                self.max = $h.DEFAULT_MAX;
117            }
118            if (isNaN(self.step) || $h.isEmpty(self.step) || self.step === 0) {
119                self.step = $h.DEFAULT_STEP;
120            }
121            self.diff = self.max - self.min;
122            self._setDefault('minThreshold', self.min);
123            if (self.minThreshold < self.min) {
124                self.minThreshold = self.min;
125            }
126            if (self.minThreshold > self.max) {
127                self.minThreshold = self.max;
128            }
129        },
130        _initHighlight: function (v) {
131            var self = this, w, cap = self._getCaption();
132            if (!v) {
133                v = self.$element.val();
134            }
135            w = self.getWidthFromValue(v) + '%';
136            self.$filledStars.width(w);
137            self.cache = {caption: cap, width: w, val: v};
138        },
139        _getContainerCss: function () {
140            var self = this;
141            return 'rating-container' +
142                $h.getCss(self.theme, 'theme-' + self.theme) +
143                $h.getCss(self.rtl, 'rating-rtl') +
144                $h.getCss(self.size, 'rating-' + self.size) +
145                $h.getCss(self.animate, 'rating-animate') +
146                $h.getCss(self.disabled || self.readonly, 'rating-disabled') +
147                $h.getCss(self.containerClass, self.containerClass) +
148                (self.displayOnly ? ' is-display-only' : '');
149
150        },
151        _checkDisabled: function () {
152            var self = this, $el = self.$element, opts = self.options;
153            self.disabled = opts.disabled === undefined ? $el.attr('disabled') || false : opts.disabled;
154            self.readonly = opts.readonly === undefined ? $el.attr('readonly') || false : opts.readonly;
155            self.inactive = (self.disabled || self.readonly);
156            $el.attr({disabled: self.disabled, readonly: self.readonly});
157        },
158        _addContent: function (type, content) {
159            var self = this, $container = self.$container, isClear = type === 'clear';
160            if (self.rtl) {
161                return isClear ? $container.append(content) : $container.prepend(content);
162            } else {
163                return isClear ? $container.prepend(content) : $container.append(content);
164            }
165        },
166        _generateRating: function () {
167            var self = this, $el = self.$element, $rating, $container, w;
168            $container = self.$container = $(document.createElement('div')).insertBefore($el);
169            $h.addCss($container, self._getContainerCss());
170            self.$rating = $rating = $(document.createElement('div')).attr('class', 'rating-stars').appendTo($container)
171                .append(self._getStars('empty')).append(self._getStars('filled'));
172            if (self.keyboardEnabled) {
173                self.$rating.attr('tabindex', self.tabindex);
174            }
175            self.$emptyStars = $rating.find('.empty-stars');
176            self.$filledStars = $rating.find('.filled-stars');
177            self._renderCaption();
178            self._renderClear();
179            self._initHighlight();
180            self._initStarTitles();
181            var i = 1;
182            if (self.rtl) {
183                w = Math.max(self.$emptyStars.outerWidth(), self.$filledStars.outerWidth());
184                self.$emptyStars.width(w);
185            }
186            $container.insertBefore($el);
187        },
188        _getCaption: function () {
189            var self = this;
190            return self.$caption && self.$caption.length ? self.$caption.html() : self.defaultCaption;
191        },
192        _setCaption: function (content) {
193            var self = this;
194            if (self.$caption && self.$caption.length) {
195                self.$caption.html(content);
196            }
197        },
198        _renderCaption: function () {
199            var self = this, val = self.$element.val(), html, $cap = self.captionElement ? $(self.captionElement) : '';
200            if (!self.showCaption) {
201                return;
202            }
203            html = self.fetchCaption(val);
204            if ($cap && $cap.length) {
205                $h.addCss($cap, 'caption');
206                $cap.html(html);
207                self.$caption = $cap;
208                return;
209            }
210            self._addContent('caption', '<div class="caption">' + html + '</div>');
211            self.$caption = self.$container.find('.caption');
212        },
213        _renderClear: function () {
214            var self = this, css, $clr = self.clearElement ? $(self.clearElement) : '';
215            if (!self.showClear) {
216                return;
217            }
218            css = self._getClearClass();
219            if ($clr.length) {
220                $h.addCss($clr, css);
221                $clr.attr({'title': self.clearButtonTitle}).html(self.clearButton);
222                self.$clear = $clr;
223                return;
224            }
225            self._addContent('clear',
226                '<div class="' + css + '" title="' + self.clearButtonTitle + '">' + self.clearButton + '</div>');
227            self.$clear = self.$container.find('.' + self.clearButtonBaseClass);
228        },
229        _getClearClass: function () {
230            var self = this;
231            return self.clearButtonBaseClass + ' ' + (self.inactive ? '' : self.clearButtonActiveClass);
232        },
233        _toggleHover: function (out) {
234            var self = this, w, width, caption;
235            if (!out) {
236                return;
237            }
238            if (self.hoverChangeStars) {
239                w = self.getWidthFromValue(self.clearValue);
240                width = out.val <= self.clearValue ? w + '%' : out.width;
241                self.$filledStars.css('width', width);
242            }
243            if (self.hoverChangeCaption) {
244                caption = out.val <= self.clearValue ? self.fetchCaption(self.clearValue) : out.caption;
245                if (caption) {
246                    self._setCaption(caption + '');
247                }
248            }
249        },
250        _init: function (options) {
251            var self = this, $el = self.$element.attr('tabindex', -1).addClass('rating-input'), v,
252                m = self.minThreshold;
253            self.options = options;
254            $.each(options, function (key, value) {
255                self[key] = value;
256            });
257            if (self.rtl || $el.attr('dir') === 'rtl') {
258                self.rtl = true;
259                $el.attr('dir', 'rtl');
260            }
261            self.starClicked = false;
262            self.clearClicked = false;
263            self._initSlider(options);
264            self._checkDisabled();
265            if (self.displayOnly) {
266                self.inactive = true;
267                self.showClear = false;
268                self.hoverEnabled = false;
269                self.hoverChangeCaption = false;
270                self.hoverChangeStars = false;
271            }
272            self._generateRating();
273            self._initEvents();
274            self._listen();
275            if (!$h.isEmpty(m) && ($h.isEmpty($el.val()) || $el.val() < m)) {
276                $el.val(m);
277            }
278            v = self._parseValue($el.val());
279            $el.val(v);
280            return $el.removeClass('rating-loading');
281        },
282        _initCaptionTitle: function () {
283            var self = this, caption;
284            caption = self.fetchCaption(self.$element.val());
285            self.$rating.attr('title', $(caption).text());
286        },
287        _trigChange: function (params) {
288            var self = this;
289            self._initStarTitles();
290            self.$element.trigger('change').trigger('rating:change', params);
291        },
292        _initEvents: function () {
293            var self = this;
294            self.events = {
295                _getTouchPosition: function (e) {
296                    var pageX = $h.isEmpty(e.pageX) ? e.originalEvent.touches[0].pageX : e.pageX;
297                    return pageX - self.$rating.offset().left;
298                },
299                _listenClick: function (e, callback) {
300                    e.stopPropagation();
301                    e.preventDefault();
302                    if (e.handled !== true) {
303                        callback(e);
304                        e.handled = true;
305                    } else {
306                        return false;
307                    }
308                },
309                _noMouseAction: function (e) {
310                    return !self.mouseEnabled || !self.hoverEnabled || self.inactive || (e && e.isDefaultPrevented());
311                },
312                initTouch: function (e) {
313                    //noinspection JSUnresolvedVariable
314                    var ev, touches, pos, out, caption, w, width, params, clrVal = self.clearValue || 0,
315                        isTouchCapable = 'ontouchstart' in window ||
316                            (window.DocumentTouch && document instanceof window.DocumentTouch);
317                    if (!isTouchCapable || self.inactive) {
318                        return;
319                    }
320                    ev = e.originalEvent;
321                    //noinspection JSUnresolvedVariable
322                    touches = !$h.isEmpty(ev.touches) ? ev.touches : ev.changedTouches;
323                    pos = self.events._getTouchPosition(touches[0]);
324                    if (e.type === 'touchend') {
325                        self._setStars(pos);
326                        params = [self.$element.val(), self._getCaption()];
327                        self._trigChange(params);
328                        self.starClicked = true;
329                    } else {
330                        out = self.calculate(pos);
331                        caption = out.val <= clrVal ? self.fetchCaption(clrVal) : out.caption;
332                        w = self.getWidthFromValue(clrVal);
333                        width = out.val <= clrVal ? w + '%' : out.width;
334                        self._setCaption(caption);
335                        self.$filledStars.css('width', width);
336                    }
337                },
338                starClick: function (e) {
339                    var pos, params;
340                    self.events._listenClick(e, function (ev) {
341                        if (self.inactive) {
342                            return false;
343                        }
344                        pos = self.events._getTouchPosition(ev);
345                        self._setStars(pos);
346                        params = [self.$element.val(), self._getCaption()];
347                        self._trigChange(params);
348                        self.starClicked = true;
349                    });
350                },
351                clearClick: function (e) {
352                    self.events._listenClick(e, function () {
353                        if (!self.inactive) {
354                            self.clear();
355                            self.clearClicked = true;
356                        }
357                    });
358                },
359                starMouseMove: function (e) {
360                    var pos, out;
361                    if (self.events._noMouseAction(e)) {
362                        return;
363                    }
364                    self.starClicked = false;
365                    pos = self.events._getTouchPosition(e);
366                    out = self.calculate(pos);
367                    self._toggleHover(out);
368                    self.$element.trigger('rating:hover', [out.val, out.caption, 'stars']);
369                },
370                starMouseLeave: function (e) {
371                    var out;
372                    if (self.events._noMouseAction(e) || self.starClicked) {
373                        return;
374                    }
375                    out = self.cache;
376                    self._toggleHover(out);
377                    self.$element.trigger('rating:hoverleave', ['stars']);
378                },
379                clearMouseMove: function (e) {
380                    var caption, val, width, out;
381                    if (self.events._noMouseAction(e) || !self.hoverOnClear) {
382                        return;
383                    }
384                    self.clearClicked = false;
385                    caption = '<span class="' + self.clearCaptionClass + '">' + self.clearCaption + '</span>';
386                    val = self.clearValue;
387                    width = self.getWidthFromValue(val) || 0;
388                    out = {caption: caption, width: width, val: val};
389                    self._toggleHover(out);
390                    self.$element.trigger('rating:hover', [val, caption, 'clear']);
391                },
392                clearMouseLeave: function (e) {
393                    var out;
394                    if (self.events._noMouseAction(e) || self.clearClicked || !self.hoverOnClear) {
395                        return;
396                    }
397                    out = self.cache;
398                    self._toggleHover(out);
399                    self.$element.trigger('rating:hoverleave', ['clear']);
400                },
401                resetForm: function (e) {
402                    if (e && e.isDefaultPrevented()) {
403                        return;
404                    }
405                    if (!self.inactive) {
406                        self.reset();
407                    }
408                },
409                focus: function (e) {
410                    self.$rating.focus();
411                    self.$element.trigger('rating:focus');
412                },
413                blur: function (e) {
414                    self.$element.trigger('rating:blur');
415                },
416                keydown: function (e) {
417                    if (self.inactive || !self.keyboardEnabled) {
418                        return;
419                    }
420                    var $el = self.$element, v = $el.val(), isUpdated = false, step = parseFloat(self.step),
421                        precision = $h.getDecimalPlaces(step), upKey = self.rtl ? 37 : 39, dnKey = self.rtl ? 39 : 37,
422                        val = v ? parseFloat(v) : 0, key = parseInt(e.which || e.keyCode || 0, 10);
423                    if (key === upKey && val < self.max) { // key right (increase)
424                        val += step;
425                        isUpdated = true;
426                    }
427                    if (key === dnKey && val > self.minThreshold) { // key left (decrease)
428                        val -= step;
429                        isUpdated = true
430                    }
431                    if (isUpdated) {
432                        val = $h.applyPrecision(val, precision);
433                        $el.val(val);
434                        self._trigChange([val, self._getCaption()])
435                        self.showStars($el.val());
436                        self.$rating.focus();
437                    }
438                    if (key === 37 || key === 39) {
439                        $el.trigger('rating:keydown', [val, self._getCaption()]);
440                    }
441
442                }
443            };
444        },
445        _listen: function () {
446            var self = this, $el = self.$element, $form = $el.closest('form'), $rating = self.$rating,
447                $clear = self.$clear, events = self.events, ns = $h.NAMESPACE,
448                mouseEvents = 'mouseenter' + ns + ' mouseleave' + ns, $stars = self.$rating.find('.star');
449            $h.handler($rating, 'touchstart touchmove touchend', events.initTouch);
450            $h.handler($rating, 'click touchstart', events.starClick);
451            $h.handler($rating, 'mousemove', events.starMouseMove);
452            $h.handler($rating, 'mouseleave', events.starMouseLeave);
453            $h.handler($rating, 'keydown', events.keydown);
454            $h.handler($rating, 'blur', events.blur);
455            if (self.showClear && $clear.length) {
456                $h.handler($clear, 'click touchstart', events.clearClick);
457                $h.handler($clear, 'mousemove', events.clearMouseMove);
458                $h.handler($clear, 'mouseleave', events.clearMouseLeave);
459            }
460            if ($form.length) {
461                $h.handler($form, 'reset', events.resetForm, true);
462            }
463            $stars.off(mouseEvents).on(mouseEvents, function (e) {
464                var $star = $(this), index = $star.index(), status = $star.parent().attr('class').slice(0, -1);
465                self.$element.trigger('rating:' + e.type, [index + 1, status, $star]);
466            });
467            $h.handler(self.$container, 'click', events.focus);
468            return $el;
469        },
470        _getStars: function (type) {
471            var self = this, stars = '<span class="' + type + '-stars">', i;
472            for (i = 1; i <= self.stars; i++) {
473                stars += '<span class="star">' + self[type + 'Star'] + '</span>';
474            }
475            return stars + '</span>';
476        },
477        _initStarTitles: function (val) {
478            var self = this;
479            if (self.showCaptionAsTitle) {
480                self._initCaptionTitle();
481                return;
482            }
483            var starTitles = self.starTitles, setTitles;
484            setTitles = function ($stars) {
485                var i = 1, title;
486                $stars.each(function () {
487                    var $star = $(this), j, title;
488                    if (typeof starTitles === 'function') {
489                        j = i === Math.floor(val) ? val : i;
490                        title = starTitles(j);
491                    } else {
492                        title = starTitles[i];
493                    }
494                    if (title) {
495                        $star.attr({title: title});
496                    }
497                    i++;
498                });
499            };
500            setTitles(self.$emptyStars.find('.star'));
501            setTitles(self.$filledStars.find('.star'));
502        },
503        _setStars: function (pos) {
504            var self = this, out = arguments.length ? self.calculate(pos) : self.calculate(), $el = self.$element,
505                v = self._parseValue(out.val);
506            $el.val(v);
507            self.$filledStars.css('width', out.width);
508            self._setCaption(out.caption);
509            self.cache = out;
510            self._initStarTitles(v);
511            return $el;
512        },
513        showStars: function (val) {
514            var self = this, v = self._parseValue(val);
515            self.$element.val(v);
516            return self._setStars();
517        },
518        calculate: function (pos) {
519            var self = this, defaultVal = $h.isEmpty(self.$element.val()) ? 0 : self.$element.val(),
520                val = arguments.length ? self.getValueFromPosition(pos) : defaultVal,
521                caption = self.fetchCaption(val), width = self.getWidthFromValue(val);
522            width += '%';
523            return {caption: caption, width: width, val: val};
524        },
525 /*       getValueFromPosition: function (pos) {
526            var self = this, precision = $h.getDecimalPlaces(self.step), val, factor, maxWidth = self.$rating.width();
527            factor = (self.diff * pos) / (maxWidth * self.step);
528            factor = self.rtl ? Math.floor(factor) : Math.ceil(factor);
529            val = $h.applyPrecision(parseFloat(self.min + factor * self.step), precision);
530            val = Math.max(Math.min(val, self.max), self.minThreshold);
531            return self.rtl ? (self.max - val) : val;
532        },
533        getWidthFromValue: function (val) {
534            var self = this, min = self.min, max = self.max, factor, $r = self.$emptyStars, w;
535            if (!val || val <= self.min || min === max) {
536                return 0;
537            }
538            val = Math.max(val, self.minThreshold);
539            w = $r.outerWidth();
540            factor = w ? $r.width() / w : 1;
541            if (val >= max) {
542                return 100;
543            }
544            return (val - min) * factor * 100 / (max - min);
545        },
546   */     
547        
548        
549        getValueFromPosition: function (pos) {
550            var self = this;
551            var starWidth = self.$rating.width() / self.stars;  
552            var starIndex = Math.floor(pos / starWidth) + 1;   
553            starIndex = Math.min(Math.max(starIndex, 1), self.stars); 
554            return starIndex;
555        },
556 
557getWidthFromValue: function (val) {
558            var self = this;
559            var starWidth = self.$emptyStars.width() / self.stars;  
560            return (val * starWidth / self.$emptyStars.width()) * 100;
561},
562 
563        
564        fetchCaption: function (rating) {
565            var self = this, val = parseFloat(rating) || self.clearValue, css, cap, capVal, cssVal, caption,
566                vCap = self.starCaptions, vCss = self.starCaptionClasses, width = self.getWidthFromValue(val);
567            if (val && val !== self.clearValue) {
568                val = $h.applyPrecision(val, $h.getDecimalPlaces(self.step));
569            }
570            cssVal = typeof vCss === 'function' ? vCss(val, width) : vCss[val];
571            capVal = typeof vCap === 'function' ? vCap(val, width) : vCap[val];
572
573            cap = $h.isEmpty(capVal) ? self.defaultCaption.replace(/\{rating}/g, val) : capVal;
574            css = $h.isEmpty(cssVal) ? self.clearCaptionClass : cssVal;
575            caption = (val === self.clearValue) ? self.clearCaption : cap;
576            return '<span class="' + css + '">' + caption + '</span>';
577        },
578        destroy: function () {
579            var self = this, $el = self.$element;
580            if (!$h.isEmpty(self.$container)) {
581                self.$container.before($el).remove();
582            }
583            $.removeData($el.get(0));
584            return $el.off('rating').removeClass('rating rating-input');
585        },
586        create: function (options) {
587            var self = this, opts = options || self.options || {};
588            return self.destroy().rating(opts);
589        },
590        clear: function () {
591            var self = this, title = '<span class="' + self.clearCaptionClass + '">' + self.clearCaption + '</span>';
592            if (!self.inactive) {
593                self._setCaption(title);
594            }
595            return self.showStars(self.clearValue).trigger('change').trigger('rating:clear');
596        },
597        reset: function () {
598            var self = this;
599            return self.showStars(self.initialValue).trigger('rating:reset');
600        },
601        update: function (val) {
602            var self = this;
603            return arguments.length ? self.showStars(val) : self.$element;
604        },
605        refresh: function (options) {
606            var self = this, $el = self.$element;
607            if (!options) {
608                return $el;
609            }
610            return self.destroy().rating($.extend(true, self.options, options)).trigger('rating:refresh');
611        }
612    };
613
614    $.fn.rating = function (option) {
615        var args = Array.apply(null, arguments), retvals = [];
616        args.shift();
617        this.each(function () {
618            var self = $(this), data = self.data('rating'), options = typeof option === 'object' && option,
619                theme = options.theme || self.data('theme'), lang = options.language || self.data('language') || 'en',
620                thm = {}, loc = {}, opts;
621            if (!data) {
622                if (theme) {
623                    thm = $.fn.ratingThemes[theme] || {};
624                }
625                if (lang !== 'en' && !$h.isEmpty($.fn.ratingLocales[lang])) {
626                    loc = $.fn.ratingLocales[lang];
627                }
628                opts = $.extend(true, {}, $.fn.rating.defaults, thm, $.fn.ratingLocales.en, loc, options, self.data());
629                data = new Rating(this, opts);
630                self.data('rating', data);
631            }
632
633            if (typeof option === 'string') {
634                retvals.push(data[option].apply(data, args));
635            }
636        });
637        switch (retvals.length) {
638            case 0:
639                return this;
640            case 1:
641                return retvals[0] === undefined ? this : retvals[0];
642            default:
643                return retvals;
644        }
645    };
646
647    $.fn.rating.defaults = {
648        theme: 'krajee-svg',
649        language: 'en',
650        stars: 5,
651        tabindex: 0,
652        keyboardEnabled: true,
653        mouseEnabled: true,
654        containerClass: '',
655        size: 'md',
656        animate: true,
657        displayOnly: false,
658        rtl: false,
659        showClear: true,
660        showCaption: true,
661        starCaptionClasses: {
662            0.5: 'caption-badge caption-danger',
663            1: 'caption-badge caption-danger',
664            1.5: 'caption-badge caption-warning',
665            2: 'caption-badge caption-warning',
666            2.5: 'caption-badge caption-info',
667            3: 'caption-badge caption-info',
668            3.5: 'caption-badge caption-primary',
669            4: 'caption-badge caption-primary',
670            4.5: 'caption-badge caption-success',
671            5: 'caption-badge caption-success'
672        },
673        filledStar: '<span class="krajee-icon krajee-icon-star"></span>', // krajee-svg theme
674        emptyStar: '<span class="krajee-icon krajee-icon-star"></span>',  // krajee-svg theme
675        clearButton: '<span class="krajee-icon-clear"></span>',           // krajee-svg theme
676        clearButtonBaseClass: 'clear-rating',
677        clearButtonActiveClass: 'clear-rating-active',
678        clearCaptionClass: 'caption-badge caption-secondary',
679        clearValue: null,
680        captionElement: null,
681        clearElement: null,
682        showCaptionAsTitle: false,
683        hoverEnabled: true,
684        hoverChangeCaption: true,
685        hoverChangeStars: true,
686        hoverOnClear: true,
687        zeroAsNull: true
688    };
689
690    $.fn.ratingLocales.en = {
691        defaultCaption: '{rating} Stars',
692        starCaptions: {
693            0.5: 'Half Star',
694            1: 'One Star',
695            1.5: 'One & Half Star',
696            2: 'Two Stars',
697            2.5: 'Two & Half Stars',
698            3: 'Three Stars',
699            3.5: 'Three & Half Stars',
700            4: 'Four Stars',
701            4.5: 'Four & Half Stars',
702            5: 'Five Stars'
703        },
704        starTitles: {
705            1: 'One Star',
706            2: 'Two Stars',
707            3: 'Three Stars',
708            4: 'Four Stars',
709            5: 'Five Stars'
710        },
711        clearButtonTitle: 'Clear',
712        clearCaption: 'Not Rated'
713    };
714
715    $.fn.rating.Constructor = Rating;
716
717    /**
718     * Convert automatically inputs with class 'rating' into Krajee's star rating control.
719     */
720    $(document).ready(function () {
721        var $input = $('input.rating');
722        if ($input.length) {
723            $input.removeClass('rating-loading').addClass('rating-loading').rating();
724        }
725    });
726}));

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.