https://metroticketing.com/assets/javascript/backend.js

1/*
2 * Modernizr tests which native CSS3 and HTML5 features are available in
3 * the current UA and makes the results available to you in two ways:
4 * as properties on a global Modernizr object, and as classes on the
5 * <html> element. This information allows you to progressively enhance
6 * your pages with a granular level of control over the experience.
7 *
8 * Modernizr has an optional (not included) conditional resource loader
9 * called Modernizr.load(), based on Yepnope.js (yepnopejs.com).
10 * To get a build that includes Modernizr.load(), as well as choosing
11 * which tests to include, go to www.modernizr.com/download/
12 *
13 * Authors        Faruk Ates, Paul Irish, Alex Sexton
14 * Contributors   Ryan Seddon, Ben Alman
15 */
16
17window.Modernizr = (function (window, document, undefined) {
18
19    var version = '2.8.3',
20        Modernizr = {},
21        /*>>cssclasses*/
22        // option for enabling the HTML classes to be added
23        enableClasses = true,
24        /*>>cssclasses*/
25
26        docElement = document.documentElement,
27        /**
28         * Create our "modernizr" element that we do most feature tests on.
29         */
30        mod = 'modernizr',
31        modElem = document.createElement(mod),
32        mStyle = modElem.style,
33        /**
34         * Create the input element for various Web Forms feature tests.
35         */
36        inputElem /*>>inputelem*/ = document.createElement('input') /*>>inputelem*/,
37        /*>>smile*/
38        smile = ':)',
39        /*>>smile*/
40
41        toString = {}.toString,
42        // TODO :: make the prefixes more granular
43        /*>>prefixes*/
44        // List of property values to set for css tests. See ticket #21
45        prefixes = ' -webkit- -moz- -o- -ms- '.split(' '),
46        /*>>prefixes*/
47
48        /*>>domprefixes*/
49        // Following spec is to expose vendor-specific style properties as:
50        //   elem.style.WebkitBorderRadius
51        // and the following would be incorrect:
52        //   elem.style.webkitBorderRadius
53
54        // Webkit ghosts their properties in lowercase but Opera & Moz do not.
55        // Microsoft uses a lowercase `ms` instead of the correct `Ms` in IE8+
56        //   erik.eae.net/archives/2008/03/10/21.48.10/
57
58        // More here: github.com/Modernizr/Modernizr/issues/issue/21
59        omPrefixes = 'Webkit Moz O ms',
60        cssomPrefixes = omPrefixes.split(' '),
61        domPrefixes = omPrefixes.toLowerCase().split(' '),
62        /*>>domprefixes*/
63
64        /*>>ns*/
65        ns = { 'svg': 'http://www.w3.org/2000/svg' },
66        /*>>ns*/
67
68        tests = {},
69        inputs = {},
70        attrs = {},
71        classes = [],
72        slice = classes.slice,
73        featureName, // used in testing loop
74
75
76        /*>>teststyles*/
77        // Inject element with style element and some CSS rules
78        injectElementWithStyles = function (rule, callback, nodes, testnames) {
79
80            var style, ret, node, docOverflow,
81                div = document.createElement('div'),
82                // After page load injecting a fake body doesn't work so check if body exists
83                body = document.body,
84                // IE6 and 7 won't return offsetWidth or offsetHeight unless it's in the body element, so we fake it.
85                fakeBody = body || document.createElement('body');
86
87            if (parseInt(nodes, 10)) {
88                // In order not to give false positives we create a node for each test
89                // This also allows the method to scale for unspecified uses
90                while (nodes--) {
91                    node = document.createElement('div');
92                    node.id = testnames ? testnames[nodes] : mod + (nodes + 1);
93                    div.appendChild(node);
94                }
95            }
96
97            // <style> elements in IE6-9 are considered 'NoScope' elements and therefore will be removed
98            // when injected with innerHTML. To get around this you need to prepend the 'NoScope' element
99            // with a 'scoped' element, in our case the soft-hyphen entity as it won't mess with our measurements.
100            // msdn.microsoft.com/en-us/library/ms533897%28VS.85%29.aspx
101            // Documents served as xml will throw if using &shy; so use xml friendly encoded version. See issue #277
102            style = ['&#173;', '<style id="s', mod, '">', rule, '</style>'].join('');
103            div.id = mod;
104            // IE6 will false positive on some tests due to the style element inside the test div somehow interfering offsetHeight, so insert it into body or fakebody.
105            // Opera will act all quirky when injecting elements in documentElement when page is served as xml, needs fakebody too. #270
106            (body ? div : fakeBody).innerHTML += style;
107            fakeBody.appendChild(div);
108            if (!body) {
109                //avoid crashing IE8, if background image is used
110                fakeBody.style.background = '';
111                //Safari 5.13/5.1.4 OSX stops loading if ::-webkit-scrollbar is used and scrollbars are visible
112                fakeBody.style.overflow = 'hidden';
113                docOverflow = docElement.style.overflow;
114                docElement.style.overflow = 'hidden';
115                docElement.appendChild(fakeBody);
116            }
117
118            ret = callback(div, rule);
119            // If this is done after page load we don't want to remove the body so check if body exists
120            if (!body) {
121                fakeBody.parentNode.removeChild(fakeBody);
122                docElement.style.overflow = docOverflow;
123            } else {
124                div.parentNode.removeChild(div);
125            }
126
127            return !!ret;
128
129        },
130        /*>>teststyles*/
131
132        /*>>mq*/
133        // adapted from matchMedia polyfill
134        // by Scott Jehl and Paul Irish
135        // gist.github.com/786768
136        testMediaQuery = function (mq) {
137
138            var matchMedia = window.matchMedia || window.msMatchMedia;
139            if (matchMedia) {
140                return matchMedia(mq) && matchMedia(mq).matches || false;
141            }
142
143            var bool;
144
145            injectElementWithStyles('@media ' + mq + ' { #' + mod + ' { position: absolute; } }', function (node) {
146                bool = (window.getComputedStyle ?
147                    getComputedStyle(node, null) :
148                    node.currentStyle)['position'] == 'absolute';
149            });
150
151            return bool;
152
153        },
154        /*>>mq*/
155
156
157        /*>>hasevent*/
158        //
159        // isEventSupported determines if a given element supports the given event
160        // kangax.github.com/iseventsupported/
161        //
162        // The following results are known incorrects:
163        //   Modernizr.hasEvent("webkitTransitionEnd", elem) // false negative
164        //   Modernizr.hasEvent("textInput") // in Webkit. github.com/Modernizr/Modernizr/issues/333
165        //   ...
166        isEventSupported = (function () {
167
168            var TAGNAMES = {
169                'select': 'input', 'change': 'input',
170                'submit': 'form', 'reset': 'form',
171                'error': 'img', 'load': 'img', 'abort': 'img'
172            };
173
174            function isEventSupported(eventName, element) {
175
176                element = element || document.createElement(TAGNAMES[eventName] || 'div');
177                eventName = 'on' + eventName;
178
179                // When using `setAttribute`, IE skips "unload", WebKit skips "unload" and "resize", whereas `in` "catches" those
180                var isSupported = eventName in element;
181
182                if (!isSupported) {
183                    // If it has no `setAttribute` (i.e. doesn't implement Node interface), try generic element
184                    if (!element.setAttribute) {
185                        element = document.createElement('div');
186                    }
187                    if (element.setAttribute && element.removeAttribute) {
188                        element.setAttribute(eventName, '');
189                        isSupported = is(element[eventName], 'function');
190
191                        // If property was created, "remove it" (by setting value to `undefined`)
192                        if (!is(element[eventName], 'undefined')) {
193                            element[eventName] = undefined;
194                        }
195                        element.removeAttribute(eventName);
196                    }
197                }
198
199                element = null;
200                return isSupported;
201            }
202            return isEventSupported;
203        })(),
204        /*>>hasevent*/
205
206        // TODO :: Add flag for hasownprop ? didn't last time
207
208        // hasOwnProperty shim by kangax needed for Safari 2.0 support
209        _hasOwnProperty = ({}).hasOwnProperty, hasOwnProp;
210
211    if (!is(_hasOwnProperty, 'undefined') && !is(_hasOwnProperty.call, 'undefined')) {
212        hasOwnProp = function (object, property) {
213            return _hasOwnProperty.call(object, property);
214        };
215    }
216    else {
217        hasOwnProp = function (object, property) { /* yes, this can give false positives/negatives, but most of the time we don't care about those */
218            return ((property in object) && is(object.constructor.prototype[property], 'undefined'));
219        };
220    }
221
222    // Adapted from ES5-shim https://github.com/kriskowal/es5-shim/blob/master/es5-shim.js
223    // es5.github.com/#x15.3.4.5
224
225    if (!Function.prototype.bind) {
226        Function.prototype.bind = function bind(that) {
227
228            var target = this;
229
230            if (typeof target != "function") {
231                throw new TypeError();
232            }
233
234            var args = slice.call(arguments, 1),
235                bound = function () {
236
237                    if (this instanceof bound) {
238
239                        var F = function () {
240                        };
241                        F.prototype = target.prototype;
242                        var self = new F();
243
244                        var result = target.apply(
245                            self,
246                            args.concat(slice.call(arguments))
247                        );
248                        if (Object(result) === result) {
249                            return result;
250                        }
251                        return self;
252
253                    } else {
254
255                        return target.apply(
256                            that,
257                            args.concat(slice.call(arguments))
258                        );
259
260                    }
261
262                };
263
264            return bound;
265        };
266    }
267
268    /**
269     * setCss applies given styles to the Modernizr DOM node.
270     */
271    function setCss(str) {
272        mStyle.cssText = str;
273    }
274
275    /**
276     * setCssAll extrapolates all vendor-specific css strings.
277     */
278    function setCssAll(str1, str2) {
279        return setCss(prefixes.join(str1 + ';') + (str2 || ''));
280    }
281
282    /**
283     * is returns a boolean for if typeof obj is exactly type.
284     */
285    function is(obj, type) {
286        return typeof obj === type;
287    }
288
289    /**
290     * contains returns a boolean for if substr is found within str.
291     */
292    function contains(str, substr) {
293        return !!~('' + str).indexOf(substr);
294    }
295
296    /*>>testprop*/
297
298    // testProps is a generic CSS / DOM property test.
299
300    // In testing support for a given CSS property, it's legit to test:
301    //    `elem.style[styleName] !== undefined`
302    // If the property is supported it will return an empty string,
303    // if unsupported it will return undefined.
304
305    // We'll take advantage of this quick test and skip setting a style
306    // on our modernizr element, but instead just testing undefined vs
307    // empty string.
308
309    // Because the testing of the CSS property names (with "-", as
310    // opposed to the camelCase DOM properties) is non-portable and
311    // non-standard but works in WebKit and IE (but not Gecko or Opera),
312    // we explicitly reject properties with dashes so that authors
313    // developing in WebKit or IE first don't end up with
314    // browser-specific content by accident.
315
316    function testProps(props, prefixed) {
317        for (var i in props) {
318            var prop = props[i];
319            if (!contains(prop, "-") && mStyle[prop] !== undefined) {
320                return prefixed == 'pfx' ? prop : true;
321            }
322        }
323        return false;
324    }
325    /*>>testprop*/
326
327    // TODO :: add testDOMProps
328    /**
329     * testDOMProps is a generic DOM property test; if a browser supports
330     *   a certain property, it won't return undefined for it.
331     */
332    function testDOMProps(props, obj, elem) {
333        for (var i in props) {
334            var item = obj[props[i]];
335            if (item !== undefined) {
336
337                // return the property name as a string
338                if (elem === false)
339                    return props[i];
340
341                // let's bind a function
342                if (is(item, 'function')) {
343                    // default to autobind unless override
344                    return item.bind(elem || obj);
345                }
346
347                // return the unbound function or obj or value
348                return item;
349            }
350        }
351        return false;
352    }
353
354    /*>>testallprops*/
355    /**
356     * testPropsAll tests a list of DOM properties we want to check against.
357     *   We specify literally ALL possible (known and/or likely) properties on
358     *   the element including the non-vendor prefixed one, for forward-
359     *   compatibility.
360     */
361    function testPropsAll(prop, prefixed, elem) {
362
363        var ucProp = prop.charAt(0).toUpperCase() + prop.slice(1),
364            props = (prop + ' ' + cssomPrefixes.join(ucProp + ' ') + ucProp).split(' ');
365
366        // did they call .prefixed('boxSizing') or are we just testing a prop?
367        if (is(prefixed, "string") || is(prefixed, "undefined")) {
368            return testProps(props, prefixed);
369
370            // otherwise, they called .prefixed('requestAnimationFrame', window[, elem])
371        } else {
372            props = (prop + ' ' + (domPrefixes).join(ucProp + ' ') + ucProp).split(' ');
373            return testDOMProps(props, prefixed, elem);
374        }
375    }
376    /*>>testallprops*/
377
378
379    /**
380     * Tests
381     * -----
382     */
383
384    // The *new* flexbox
385    // dev.w3.org/csswg/css3-flexbox
386
387    tests['flexbox'] = function () {
388        return testPropsAll('flexWrap');
389    };
390
391    // The *old* flexbox
392    // www.w3.org/TR/2009/WD-css3-flexbox-20090723/
393
394    tests['flexboxlegacy'] = function () {
395        return testPropsAll('boxDirection');
396    };
397
398    // On the S60 and BB Storm, getContext exists, but always returns undefined
399    // so we actually have to call getContext() to verify
400    // github.com/Modernizr/Modernizr/issues/issue/97/
401
402    tests['canvas'] = function () {
403        var elem = document.createElement('canvas');
404        return !!(elem.getContext && elem.getContext('2d'));
405    };
406
407    tests['canvastext'] = function () {
408        return !!(Modernizr['canvas'] && is(document.createElement('canvas').getContext('2d').fillText, 'function'));
409    };
410
411    // webk.it/70117 is tracking a legit WebGL feature detect proposal
412
413    // We do a soft detect which may false positive in order to avoid
414    // an expensive context creation: bugzil.la/732441
415
416    tests['webgl'] = function () {
417        return !!window.WebGLRenderingContext;
418    };
419
420    /*
421     * The Modernizr.touch test only indicates if the browser supports
422     *    touch events, which does not necessarily reflect a touchscreen
423     *    device, as evidenced by tablets running Windows 7 or, alas,
424     *    the Palm Pre / WebOS (touch) phones.
425     *
426     * Additionally, Chrome (desktop) used to lie about its support on this,
427     *    but that has since been rectified: crbug.com/36415
428     *
429     * We also test for Firefox 4 Multitouch Support.
430     *
431     * For more info, see: modernizr.github.com/Modernizr/touch.html
432     */
433
434    tests['touch'] = function () {
435        var bool;
436
437        if (('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch) {
438            bool = true;
439        } else {
440            injectElementWithStyles(['@media (', prefixes.join('touch-enabled),('), mod, ')', '{#modernizr{top:9px;position:absolute}}'].join(''), function (node) {
441                bool = node.offsetTop === 9;
442            });
443        }
444
445        return bool;
446    };
447
448
449    // geolocation is often considered a trivial feature detect...
450    // Turns out, it's quite tricky to get right:
451    //
452    // Using !!navigator.geolocation does two things we don't want. It:
453    //   1. Leaks memory in IE9: github.com/Modernizr/Modernizr/issues/513
454    //   2. Disables page caching in WebKit: webk.it/43956
455    //
456    // Meanwhile, in Firefox < 8, an about:config setting could expose
457    // a false positive that would throw an exception: bugzil.la/688158
458
459    tests['geolocation'] = function () {
460        return 'geolocation' in navigator;
461    };
462
463
464    tests['postmessage'] = function () {
465        return !!window.postMessage;
466    };
467
468
469    // Chrome incognito mode used to throw an exception when using openDatabase
470    // It doesn't anymore.
471    tests['websqldatabase'] = function () {
472        return !!window.openDatabase;
473    };
474
475    // Vendors had inconsistent prefixing with the experimental Indexed DB:
476    // - Webkit's implementation is accessible through webkitIndexedDB
477    // - Firefox shipped moz_indexedDB before FF4b9, but since then has been mozIndexedDB
478    // For speed, we don't test the legacy (and beta-only) indexedDB
479    tests['indexedDB'] = function () {
480        return !!testPropsAll("indexedDB", window);
481    };
482
483    // documentMode logic from YUI to filter out IE8 Compat Mode
484    //   which false positives.
485    tests['hashchange'] = function () {
486        return isEventSupported('hashchange', window) && (document.documentMode === undefined || document.documentMode > 7);
487    };
488
489    // Per 1.6:
490    // This used to be Modernizr.historymanagement but the longer
491    // name has been deprecated in favor of a shorter and property-matching one.
492    // The old API is still available in 1.6, but as of 2.0 will throw a warning,
493    // and in the first release thereafter disappear entirely.
494    tests['history'] = function () {
495        return !!(window.history && history.pushState);
496    };
497
498    tests['draganddrop'] = function () {
499        var div = document.createElement('div');
500        return ('draggable' in div) || ('ondragstart' in div && 'ondrop' in div);
501    };
502
503    // FF3.6 was EOL'ed on 4/24/12, but the ESR version of FF10
504    // will be supported until FF19 (2/12/13), at which time, ESR becomes FF17.
505    // FF10 still uses prefixes, so check for it until then.
506    // for more ESR info, see: mozilla.org/en-US/firefox/organizations/faq/
507    tests['websockets'] = function () {
508        return 'WebSocket' in window || 'MozWebSocket' in window;
509    };
510
511
512    // css-tricks.com/rgba-browser-support/
513    tests['rgba'] = function () {
514        // Set an rgba() color and check the returned value
515
516        setCss('background-color:rgba(150,255,150,.5)');
517
518        return contains(mStyle.backgroundColor, 'rgba');
519    };
520
521    tests['hsla'] = function () {
522        // Same as rgba(), in fact, browsers re-map hsla() to rgba() internally,
523        //   except IE9 who retains it as hsla
524
525        setCss('background-color:hsla(120,40%,100%,.5)');
526
527        return contains(mStyle.backgroundColor, 'rgba') || contains(mStyle.backgroundColor, 'hsla');
528    };
529
530    tests['multiplebgs'] = function () {
531        // Setting multiple images AND a color on the background shorthand property
532        //  and then querying the style.background property value for the number of
533        //  occurrences of "url(" is a reliable method for detecting ACTUAL support for this!
534
535        setCss('background:url(https://),url(https://),red url(https://)');
536
537        // If the UA supports multiple backgrounds, there should be three occurrences
538        //   of the string "url(" in the return value for elemStyle.background
539
540        return (/(url\s*\(.*?){3}/).test(mStyle.background);
541    };
542
543
544
545    // this will false positive in Opera Mini
546    //   github.com/Modernizr/Modernizr/issues/396
547
548    tests['backgroundsize'] = function () {
549        return testPropsAll('backgroundSize');
550    };
551
552    tests['borderimage'] = function () {
553        return testPropsAll('borderImage');
554    };
555
556
557    // Super comprehensive table about all the unique implementations of
558    // border-radius: muddledramblings.com/table-of-css3-border-radius-compliance
559
560    tests['borderradius'] = function () {
561        return testPropsAll('borderRadius');
562    };
563
564    // WebOS unfortunately false positives on this test.
565    tests['boxshadow'] = function () {
566        return testPropsAll('boxShadow');
567    };
568
569    // FF3.0 will false positive on this test
570    tests['textshadow'] = function () {
571        return document.createElement('div').style.textShadow === '';
572    };
573
574
575    tests['opacity'] = function () {
576        // Browsers that actually have CSS Opacity implemented have done so
577        //  according to spec, which means their return values are within the
578        //  range of [0.0,1.0] - including the leading zero.
579
580        setCssAll('opacity:.55');
581
582        // The non-literal . in this regex is intentional:
583        //   German Chrome returns this value as 0,55
584        // github.com/Modernizr/Modernizr/issues/#issue/59/comment/516632
585        return (/^0.55$/).test(mStyle.opacity);
586    };
587
588
589    // Note, Android < 4 will pass this test, but can only animate
590    //   a single property at a time
591    //   goo.gl/v3V4Gp
592    tests['cssanimations'] = function () {
593        return testPropsAll('animationName');
594    };
595
596
597    tests['csscolumns'] = function () {
598        return testPropsAll('columnCount');
599    };
600
601
602    tests['cssgradients'] = function () {
603        /**
604         * For CSS Gradients syntax, please see:
605         * webkit.org/blog/175/introducing-css-gradients/
606         * developer.mozilla.org/en/CSS/-moz-linear-gradient
607         * developer.mozilla.org/en/CSS/-moz-radial-gradient
608         * dev.w3.org/csswg/css3-images/#gradients-
609         */
610
611        var str1 = 'background-image:',
612            str2 = 'gradient(linear,left top,right bottom,from(#9f9),to(white));',
613            str3 = 'linear-gradient(left top,#9f9, white);';
614
615        setCss(
616            // legacy webkit syntax (FIXME: remove when syntax not in use anymore)
617            (str1 + '-webkit- '.split(' ').join(str2 + str1) +
618                // standard syntax             // trailing 'background-image:'
619                prefixes.join(str3 + str1)).slice(0, -str1.length)
620        );
621
622        return contains(mStyle.backgroundImage, 'gradient');
623    };
624
625
626    tests['cssreflections'] = function () {
627        return testPropsAll('boxReflect');
628    };
629
630
631    tests['csstransforms'] = function () {
632        return !!testPropsAll('transform');
633    };
634
635
636    tests['csstransforms3d'] = function () {
637
638        var ret = !!testPropsAll('perspective');
639
640        // Webkit's 3D transforms are passed off to the browser's own graphics renderer.
641        //   It works fine in Safari on Leopard and Snow Leopard, but not in Chrome in
642        //   some conditions. As a result, Webkit typically recognizes the syntax but
643        //   will sometimes throw a false positive, thus we must do a more thorough check:
644        if (ret && 'webkitPerspective' in docElement.style) {
645
646            // Webkit allows this media query to succeed only if the feature is enabled.
647            // `@media (transform-3d),(-webkit-transform-3d){ ... }`
648            injectElementWithStyles('@media (transform-3d),(-webkit-transform-3d){#modernizr{left:9px;position:absolute;height:3px;}}', function (node, rule) {
649                ret = node.offsetLeft === 9 && node.offsetHeight === 3;
650            });
651        }
652        return ret;
653    };
654
655
656    tests['csstransitions'] = function () {
657        return testPropsAll('transition');
658    };
659
660
661    /*>>fontface*/
662    // @font-face detection routine by Diego Perini
663    // javascript.nwbox.com/CSSSupport/
664
665    // false positives:
666    //   WebOS github.com/Modernizr/Modernizr/issues/342
667    //   WP7   github.com/Modernizr/Modernizr/issues/538
668    tests['fontface'] = function () {
669        var bool;
670
671        injectElementWithStyles('@font-face {font-family:"font";src:url("https://")}', function (node, rule) {
672            var style = document.getElementById('smodernizr'),
673                sheet = style.sheet || style.styleSheet,
674                cssText = sheet ? (sheet.cssRules && sheet.cssRules[0] ? sheet.cssRules[0].cssText : sheet.cssText || '') : '';
675
676            bool = /src/i.test(cssText) && cssText.indexOf(rule.split(' ')[0]) === 0;
677        });
678
679        return bool;
680    };
681    /*>>fontface*/
682
683    // CSS generated content detection
684    tests['generatedcontent'] = function () {
685        var bool;
686
687        injectElementWithStyles(['#', mod, '{font:0/0 a}#', mod, ':after{content:"', smile, '";visibility:hidden;font:3px/1 a}'].join(''), function (node) {
688            bool = node.offsetHeight >= 3;
689        });
690
691        return bool;
692    };
693
694
695
696    // These tests evaluate support of the video/audio elements, as well as
697    // testing what types of content they support.
698    //
699    // We're using the Boolean constructor here, so that we can extend the value
700    // e.g.  Modernizr.video     // true
701    //       Modernizr.video.ogg // 'probably'
702    //
703    // Codec values from : github.com/NielsLeenheer/html5test/blob/9106a8/index.html#L845
704    //                     thx to NielsLeenheer and zcorpan
705
706    // Note: in some older browsers, "no" was a return value instead of empty string.
707    //   It was live in FF3.5.0 and 3.5.1, but fixed in 3.5.2
708    //   It was also live in Safari 4.0.0 - 4.0.4, but fixed in 4.0.5
709
710    tests['video'] = function () {
711        var elem = document.createElement('video'),
712            bool = false;
713
714        // IE9 Running on Windows Server SKU can cause an exception to be thrown, bug #224
715        try {
716            if (bool = !!elem.canPlayType) {
717                bool = new Boolean(bool);
718                bool.ogg = elem.canPlayType('video/ogg; codecs="theora"').replace(/^no$/, '');
719
720                // Without QuickTime, this value will be `undefined`. github.com/Modernizr/Modernizr/issues/546
721                bool.h264 = elem.canPlayType('video/mp4; codecs="avc1.42E01E"').replace(/^no$/, '');
722
723                bool.webm = elem.canPlayType('video/webm; codecs="vp8, vorbis"').replace(/^no$/, '');
724            }
725
726        } catch (e) {
727        }
728
729        return bool;
730    };
731
732    tests['audio'] = function () {
733        var elem = document.createElement('audio'),
734            bool = false;
735
736        try {
737            if (bool = !!elem.canPlayType) {
738                bool = new Boolean(bool);
739                bool.ogg = elem.canPlayType('audio/ogg; codecs="vorbis"').replace(/^no$/, '');
740                bool.mp3 = elem.canPlayType('audio/mpeg;').replace(/^no$/, '');
741
742                // Mimetypes accepted:
743                //   developer.mozilla.org/En/Media_formats_supported_by_the_audio_and_video_elements
744                //   bit.ly/iphoneoscodecs
745                bool.wav = elem.canPlayType('audio/wav; codecs="1"').replace(/^no$/, '');
746                bool.m4a = (elem.canPlayType('audio/x-m4a;') ||
747                    elem.canPlayType('audio/aac;')).replace(/^no$/, '');
748            }
749        } catch (e) {
750        }
751
752        return bool;
753    };
754
755
756    // In FF4, if disabled, window.localStorage should === null.
757
758    // Normally, we could not test that directly and need to do a
759    //   `('localStorage' in window) && ` test first because otherwise Firefox will
760    //   throw bugzil.la/365772 if cookies are disabled
761
762    // Also in iOS5 Private Browsing mode, attempting to use localStorage.setItem
763    // will throw the exception:
764    //   QUOTA_EXCEEDED_ERRROR DOM Exception 22.
765    // Peculiarly, getItem and removeItem calls do not throw.
766
767    // Because we are forced to try/catch this, we'll go aggressive.
768
769    // Just FWIW: IE8 Compat mode supports these features completely:
770    //   www.quirksmode.org/dom/html5.html
771    // But IE8 doesn't support either with local files
772
773    tests['localstorage'] = function () {
774        try {
775            localStorage.setItem(mod, mod);
776            localStorage.removeItem(mod);
777            return true;
778        } catch (e) {
779            return false;
780        }
781    };
782
783    tests['sessionstorage'] = function () {
784        try {
785            sessionStorage.setItem(mod, mod);
786            sessionStorage.removeItem(mod);
787            return true;
788        } catch (e) {
789            return false;
790        }
791    };
792
793
794    tests['webworkers'] = function () {
795        return !!window.Worker;
796    };
797
798
799    tests['applicationcache'] = function () {
800        return !!window.applicationCache;
801    };
802
803
804    // Thanks to Erik Dahlstrom
805    tests['svg'] = function () {
806        return !!document.createElementNS && !!document.createElementNS(ns.svg, 'svg').createSVGRect;
807    };
808
809    // specifically for SVG inline in HTML, not within XHTML
810    // test page: paulirish.com/demo/inline-svg
811    tests['inlinesvg'] = function () {
812        var div = document.createElement('div');
813        div.innerHTML = '<svg/>';
814        return (div.firstChild && div.firstChild.namespaceURI) == ns.svg;
815    };
816
817    // SVG SMIL animation
818    tests['smil'] = function () {
819        return !!document.createElementNS && /SVGAnimate/.test(toString.call(document.createElementNS(ns.svg, 'animate')));
820    };
821
822    // This test is only for clip paths in SVG proper, not clip paths on HTML content
823    // demo: srufaculty.sru.edu/david.dailey/svg/newstuff/clipPath4.svg
824
825    // However read the comments to dig into applying SVG clippaths to HTML content here:
826    //   github.com/Modernizr/Modernizr/issues/213#issuecomment-1149491
827    tests['svgclippaths'] = function () {
828        return !!document.createElementNS && /SVGClipPath/.test(toString.call(document.createElementNS(ns.svg, 'clipPath')));
829    };
830
831    /*>>webforms*/
832    // input features and input types go directly onto the ret object, bypassing the tests loop.
833    // Hold this guy to execute in a moment.
834    function webforms() {
835        /*>>input*/
836        // Run through HTML5's new input attributes to see if the UA understands any.
837        // We're using f which is the <input> element created early on
838        // Mike Taylr has created a comprehensive resource for testing these attributes
839        //   when applied to all input types:
840        //   miketaylr.com/code/input-type-attr.html
841        // spec: www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
842
843        // Only input placeholder is tested while textarea's placeholder is not.
844        // Currently Safari 4 and Opera 11 have support only for the input placeholder
845        // Both tests are available in feature-detects/forms-placeholder.js
846        Modernizr['input'] = (function (props) {
847            for (var i = 0, len = props.length; i < len; i++) {
848                attrs[props[i]] = !!(props[i] in inputElem);
849            }
850            if (attrs.list) {
851                // safari false positive's on datalist: webk.it/74252
852                // see also github.com/Modernizr/Modernizr/issues/146
853                attrs.list = !!(document.createElement('datalist') && window.HTMLDataListElement);
854            }
855            return attrs;
856        })('autocomplete autofocus list placeholder max min multiple pattern required step'.split(' '));
857        /*>>input*/
858
859        /*>>inputtypes*/
860        // Run through HTML5's new input types to see if the UA understands any.
861        //   This is put behind the tests runloop because it doesn't return a
862        //   true/false like all the other tests; instead, it returns an object
863        //   containing each input type with its corresponding true/false value
864
865        // Big thanks to @miketaylr for the html5 forms expertise. miketaylr.com/
866        Modernizr['inputtypes'] = (function (props) {
867
868            for (var i = 0, bool, inputElemType, defaultView, len = props.length; i < len; i++) {
869
870                inputElem.setAttribute('type', inputElemType = props[i]);
871                bool = inputElem.type !== 'text';
872
873                // We first check to see if the type we give it sticks..
874                // If the type does, we feed it a textual value, which shouldn't be valid.
875                // If the value doesn't stick, we know there's input sanitization which infers a custom UI
876                if (bool) {
877
878                    inputElem.value = smile;
879                    inputElem.style.cssText = 'position:absolute;visibility:hidden;';
880
881                    if (/^range$/.test(inputElemType) && inputElem.style.WebkitAppearance !== undefined) {
882
883                        docElement.appendChild(inputElem);
884                        defaultView = document.defaultView;
885
886                        // Safari 2-4 allows the smiley as a value, despite making a slider
887                        bool = defaultView.getComputedStyle &&
888                            defaultView.getComputedStyle(inputElem, null).WebkitAppearance !== 'textfield' &&
889                            // Mobile android web browser has false positive, so must
890                            // check the height to see if the widget is actually there.
891                            (inputElem.offsetHeight !== 0);
892
893                        docElement.removeChild(inputElem);
894
895                    } else if (/^(search|tel)$/.test(inputElemType)) {
896                        // Spec doesn't define any special parsing or detectable UI
897                        //   behaviors so we pass these through as true
898
899                        // Interestingly, opera fails the earlier test, so it doesn't
900                        //  even make it here.
901
902                    } else if (/^(url|email)$/.test(inputElemType)) {
903                        // Real url and email support comes with prebaked validation.
904                        bool = inputElem.checkValidity && inputElem.checkValidity() === false;
905
906                    } else {
907                        // If the upgraded input compontent rejects the :) text, we got a winner
908                        bool = inputElem.value != smile;
909                    }
910                }
911
912                inputs[props[i]] = !!bool;
913            }
914            return inputs;
915        })('search tel url email datetime date month week time datetime-local number range color'.split(' '));
916        /*>>inputtypes*/
917    }
918    /*>>webforms*/
919
920
921    // End of test definitions
922    // -----------------------
923
924
925
926    // Run through all tests and detect their support in the current UA.
927    // todo: hypothetically we could be doing an array of tests and use a basic loop here.
928    for (var feature in tests) {
929        if (hasOwnProp(tests, feature)) {
930            // run the test, throw the return value into the Modernizr,
931            //   then based on that boolean, define an appropriate className
932            //   and push it into an array of classes we'll join later.
933            featureName = feature.toLowerCase();
934            Modernizr[featureName] = tests[feature]();
935
936            classes.push((Modernizr[featureName] ? '' : 'no-') + featureName);
937        }
938    }
939
940    /*>>webforms*/
941    // input tests need to run.
942    Modernizr.input || webforms();
943    /*>>webforms*/
944
945
946    /**
947     * addTest allows the user to define their own feature tests
948     * the result will be added onto the Modernizr object,
949     * as well as an appropriate className set on the html element
950     *
951     * @param feature - String naming the feature
952     * @param test - Function returning true if feature is supported, false if not
953     */
954    Modernizr.addTest = function (feature, test) {
955        if (typeof feature == 'object') {
956            for (var key in feature) {
957                if (hasOwnProp(feature, key)) {
958                    Modernizr.addTest(key, feature[key]);
959                }
960            }
961        } else {
962
963            feature = feature.toLowerCase();
964
965            if (Modernizr[feature] !== undefined) {
966                // we're going to quit if you're trying to overwrite an existing test
967                // if we were to allow it, we'd do this:
968                //   var re = new RegExp("\\b(no-)?" + feature + "\\b");
969                //   docElement.className = docElement.className.replace( re, '' );
970                // but, no rly, stuff 'em.
971                return Modernizr;
972            }
973
974            test = typeof test == 'function' ? test() : test;
975
976            if (typeof enableClasses !== "undefined" && enableClasses) {
977                docElement.className += ' ' + (test ? '' : 'no-') + feature;
978            }
979            Modernizr[feature] = test;
980
981        }
982
983        return Modernizr; // allow chaining.
984    };
985
986
987    // Reset modElem.cssText to nothing to reduce memory footprint.
988    setCss('');
989    modElem = inputElem = null;
990
991    /*>>shiv*/
992    /**
993     * @preserve HTML5 Shiv prev3.7.1 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
994     */
995    ;
996    (function (window, document) {
997        /*jshint evil:true */
998        /** version */
999        var version = '3.7.0';
1000
1001        /** Preset options */
1002        var options = window.html5 || {};
1003
1004        /** Used to skip problem elements */
1005        var reSkip = /^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i;
1006
1007        /** Not all elements can be cloned in IE **/
1008        var saveClones = /^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i;
1009
1010        /** Detect whether the browser supports default html5 styles */
1011        var supportsHtml5Styles;
1012
1013        /** Name of the expando, to work with multiple documents or to re-shiv one document */
1014        var expando = '_html5shiv';
1015
1016        /** The id for the the documents expando */
1017        var expanID = 0;
1018
1019        /** Cached data for each document */
1020        var expandoData = {};
1021
1022        /** Detect whether the browser supports unknown elements */
1023        var supportsUnknownElements;
1024
1025        (function () {
1026            try {
1027                var a = document.createElement('a');
1028                a.innerHTML = '<xyz></xyz>';
1029                //if the hidden property is implemented we can assume, that the browser supports basic HTML5 Styles
1030                supportsHtml5Styles = ('hidden' in a);
1031
1032                supportsUnknownElements = a.childNodes.length == 1 || (function () {
1033                    // assign a false positive if unable to shiv
1034                    (document.createElement)('a');
1035                    var frag = document.createDocumentFragment();
1036                    return (
1037                        typeof frag.cloneNode == 'undefined' ||
1038                        typeof frag.createDocumentFragment == 'undefined' ||
1039                        typeof frag.createElement == 'undefined'
1040                    );
1041                }());
1042            } catch (e) {
1043                // assign a false positive if detection fails => unable to shiv
1044                supportsHtml5Styles = true;
1045                supportsUnknownElements = true;
1046            }
1047
1048        }());
1049
1050        /*--------------------------------------------------------------------------*/
1051
1052        /**
1053         * Creates a style sheet with the given CSS text and adds it to the document.
1054         * @private
1055         * @param {Document} ownerDocument The document.
1056         * @param {String} cssText The CSS text.
1057         * @returns {StyleSheet} The style element.
1058         */
1059        function addStyleSheet(ownerDocument, cssText) {
1060            var p = ownerDocument.createElement('p'),
1061                parent = ownerDocument.getElementsByTagName('head')[0] || ownerDocument.documentElement;
1062
1063            p.innerHTML = 'x<style>' + cssText + '</style>';
1064            return parent.insertBefore(p.lastChild, parent.firstChild);
1065        }
1066
1067        /**
1068         * Returns the value of `html5.elements` as an array.
1069         * @private
1070         * @returns {Array} An array of shived element node names.
1071         */
1072        function getElements() {
1073            var elements = html5.elements;
1074            return typeof elements == 'string' ? elements.split(' ') : elements;
1075        }
1076
1077        /**
1078         * Returns the data associated to the given document
1079         * @private
1080         * @param {Document} ownerDocument The document.
1081         * @returns {Object} An object of data.
1082         */
1083        function getExpandoData(ownerDocument) {
1084            var data = expandoData[ownerDocument[expando]];
1085            if (!data) {
1086                data = {};
1087                expanID++;
1088                ownerDocument[expando] = expanID;
1089                expandoData[expanID] = data;
1090            }
1091            return data;
1092        }
1093
1094        /**
1095         * returns a shived element for the given nodeName and document
1096         * @memberOf html5
1097         * @param {String}

1097 nodeName name of the element
1098         * @param {Document} ownerDocument The context document.
1099         * @returns {Object} The shived element.
1100         */
1101        function createElement(nodeName, ownerDocument, data) {
1102            if (!ownerDocument) {
1103                ownerDocument = document;
1104            }
1105            if (supportsUnknownElements) {
1106                return ownerDocument.createElement(nodeName);
1107            }
1108            if (!data) {
1109                data = getExpandoData(ownerDocument);
1110            }
1111            var node;
1112
1113            if (data.cache[nodeName]) {
1114                node = data.cache[nodeName].cloneNode();
1115            } else if (saveClones.test(nodeName)) {
1116                node = (data.cache[nodeName] = data.createElem(nodeName)).cloneNode();
1117            } else {
1118                node = data.createElem(nodeName);
1119            }
1120
1121            // Avoid adding some elements to fragments in IE < 9 because
1122            // * Attributes like `name` or `type` cannot be set/changed once an element
1123            //   is inserted into a document/fragment
1124            // * Link elements with `src` attributes that are inaccessible, as with
1125            //   a 403 response, will cause the tab/window to crash
1126            // * Script elements appended to fragments will execute when their `src`
1127            //   or `text` property is set
1128            return node.canHaveChildren && !reSkip.test(nodeName) && !node.tagUrn ? data.frag.appendChild(node) : node;
1129        }
1130
1131        /**
1132         * returns a shived DocumentFragment for the given document
1133         * @memberOf html5
1134         * @param {Document} ownerDocument The context document.
1135         * @returns {Object} The shived DocumentFragment.
1136         */
1137        function createDocumentFragment(ownerDocument, data) {
1138            if (!ownerDocument) {
1139                ownerDocument = document;
1140            }
1141            if (supportsUnknownElements) {
1142                return ownerDocument.createDocumentFragment();
1143            }
1144            data = data || getExpandoData(ownerDocument);
1145            var clone = data.frag.cloneNode(),
1146                i = 0,
1147                elems = getElements(),
1148                l = elems.length;
1149            for (; i < l; i++) {
1150                clone.createElement(elems[i]);
1151            }
1152            return clone;
1153        }
1154
1155        /**
1156         * Shivs the `createElement` and `createDocumentFragment` methods of the document.
1157         * @private
1158         * @param {Document|DocumentFragment} ownerDocument The document.
1159         * @param {Object} data of the document.
1160         */
1161        function shivMethods(ownerDocument, data) {
1162            if (!data.cache) {
1163                data.cache = {};
1164                data.createElem = ownerDocument.createElement;
1165                data.createFrag = ownerDocument.createDocumentFragment;
1166                data.frag = data.createFrag();
1167            }
1168
1169
1170            ownerDocument.createElement = function (nodeName) {
1171                //abort shiv
1172                if (!html5.shivMethods) {
1173                    return data.createElem(nodeName);
1174                }
1175                return createElement(nodeName, ownerDocument, data);
1176            };
1177
1178            ownerDocument.createDocumentFragment = Function('h,f', 'return function(){' +
1179                'var n=f.cloneNode(),c=n.createElement;' +
1180                'h.shivMethods&&(' +
1181                // unroll the `createElement` calls
1182                getElements().join().replace(/[\w\-]+/g, function (nodeName) {
1183                    data.createElem(nodeName);
1184                    data.frag.createElement(nodeName);
1185                    return 'c("' + nodeName + '")';
1186                }) +
1187                ');return n}'
1188            )(html5, data.frag);
1189        }
1190
1191        /*--------------------------------------------------------------------------*/
1192
1193        /**
1194         * Shivs the given document.
1195         * @memberOf html5
1196         * @param {Document} ownerDocument The document to shiv.
1197         * @returns {Document} The shived document.
1198         */
1199        function shivDocument(ownerDocument) {
1200            if (!ownerDocument) {
1201                ownerDocument = document;
1202            }
1203            var data = getExpandoData(ownerDocument);
1204
1205            if (html5.shivCSS && !supportsHtml5Styles && !data.hasCSS) {
1206                data.hasCSS = !!addStyleSheet(ownerDocument,
1207                    // corrects block display not defined in IE6/7/8/9
1208                    'article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{dis

1831    // CSS TRANSITION SUPPORT (Shoutout: http://www.modernizr.com/)
1832    // ============================================================
1833
1834    function transitionEnd() {
1835        var el = document.createElement('bootstrap')
1836
1837        var transEndEventNames = {
1838            WebkitTransition: 'webkitTransitionEnd',
1839            MozTransition: 'transitionend',
1840            OTransition: 'oTransitionEnd otransitionend',
1841            transition: 'transitionend'
1842        }
1843
1844        for (var name in transEndEventNames) {
1845            if (el.style[name] !== undefined) {
1846                return { end: transEndEventNames[name] }
1847            }
1848        }
1849
1850        return false // explicit for ie8 (  ._.)
1851    }
1852
1853    // http://blog.alexmaccaw.com/css-transitions
1854    $.fn.emulateTransitionEnd = function (duration) {
1855        var called = false
1856        var $el = this
1857        $(this).one('bsTransitionEnd', function () {
1858            called = true
1859        })
1860        var callback = function () {
1861            if (!called)
1862                $($el).trigger($.support.transition.end)
1863        }
1864        setTimeout(callback, duration)
1865        return this
1866    }
1867
1868    $(function () {
1869        $.support.transition = transitionEnd()
1870
1871        if (!$.support.transition)
1872            return
1873
1874        $.event.special.bsTransitionEnd = {
1875            bindType: $.support.transition.end,
1876            delegateType: $.support.transition.end,
1877            handle: function (e) {
1878                if ($(e.target).is(this))
1879                    return e.handleObj.handler.apply(this, arguments)
1880            }
1881        }
1882    })
1883
1884}(jQuery);
1885
1886/* ========================================================================
1887 * Bootstrap: alert.js v3.2.0
1888 * http://getbootstrap.com/javascript/#alerts
1889 * ========================================================================
1890 * Copyright 2011-2014 Twitter, Inc.
1891 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1892 * ======================================================================== */
1893
1894
1895+function ($) {
1896    'use strict';
1897
1898    // ALERT CLASS DEFINITION
1899    // ======================
1900
1901    var dismiss = '[data-dismiss="alert"]'
1902    var Alert = function (el) {
1903        $(el).on('click', dismiss, this.close)
1904    }
1905
1906    Alert.VERSION = '3.2.0'
1907
1908    Alert.prototype.close = function (e) {
1909        var $this = $(this)
1910        var selector = $this.attr('data-target')
1911
1912        if (!selector) {
1913            selector = $this.attr('href')
1914            selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
1915        }
1916
1917        var $parent = $(selector)
1918
1919        if (e)
1920            e.preventDefault()
1921
1922        if (!$parent.length) {
1923            $parent = $this.hasClass('alert') ? $this : $this.parent()
1924        }
1925
1926        $parent.trigger(e = $.Event('close.bs.alert'))
1927
1928        if (e.isDefaultPrevented())
1929            return
1930
1931        $parent.removeClass('in')
1932
1933        function removeElement() {
1934            // detach from parent, fire event then clean up data
1935            $parent.detach().trigger('closed.bs.alert').remove()
1936        }
1937
1938        $.support.transition && $parent.hasClass('fade') ?
1939            $parent
1940                .one('bsTransitionEnd', removeElement)
1941                .emulateTransitionEnd(150) :
1942            removeElement()
1943    }
1944
1945
1946    // ALERT PLUGIN DEFINITION
1947    // =======================
1948
1949    function Plugin(option) {
1950        return this.each(function () {
1951            var $this = $(this)
1952            var data = $this.data('bs.alert')
1953
1954            if (!data)
1955                $this.data('bs.alert', (data = new Alert(this)))
1956            if (typeof option == 'string')
1957                data[option].call($this)
1958        })
1959    }
1960
1961    var old = $.fn.alert
1962
1963    $.fn.alert = Plugin
1964    $.fn.alert.Constructor = Alert
1965
1966
1967    // ALERT NO CONFLICT
1968    // =================
1969
1970    $.fn.alert.noConflict = function () {
1971        $.fn.alert = old
1972        return this
1973    }
1974
1975
1976    // ALERT DATA-API
1977    // ==============
1978
1979    $(document).on('click.bs.alert.data-api', dismiss, Alert.prototype.close)
1980
1981}(jQuery);
1982
1983/* ========================================================================
1984 * Bootstrap: button.js v3.2.0
1985 * http://getbootstrap.com/javascript/#buttons
1986 * ========================================================================
1987 * Copyright 2011-2014 Twitter, Inc.
1988 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
1989 * ======================================================================== */
1990
1991
1992+function ($) {
1993    'use strict';
1994
1995    // BUTTON PUBLIC CLASS DEFINITION
1996    // ==============================
1997
1998    var Button = function (element, options) {
1999        this.$element = $(element)
2000        this.options = $.extend({}, Button.DEFAULTS, options)
2001        this.isLoading = false
2002    }
2003
2004    Button.VERSION = '3.2.0'
2005
2006    Button.DEFAULTS = {
2007        loadingText: 'loading...'
2008    }
2009
2010    Button.prototype.setState = function (state) {
2011        var d = 'disabled'
2012        var $el = this.$element
2013        var val = $el.is('input') ? 'val' : 'html'
2014        var data = $el.data()
2015

2252        if ($.support.transition && this.$element.hasClass('slide')) {
2253            $next.addClass(type)
2254            $next[0].offsetWidth // force reflow
2255            $active.addClass(direction)
2256            $next.addClass(direction)
2257            $active
2258                .one('bsTransitionEnd', function () {
2259                    $next.removeClass([type, direction].join(' ')).addClass('active')
2260                    $active.removeClass(['active', direction].join(' '))
2261                    that.sliding = false
2262                    setTimeout(function () {
2263                        that.$element.trigger(slidEvent)
2264                    }, 0)
2265                })
2266                .emulateTransitionEnd($active.css('transition-duration').slice(0, -1) * 1000)
2267        } else {
2268            $active.removeClass('active')
2269            $next.addClass('active')
2270            this.sliding = false
2271            this.$element.trigger(slidEvent)
2272        }
2273
2274        isCycling && this.cycle()
2275
2276        return this
2277    }
2278
2279
2280    // CAROUSEL PLUGIN DEFINITION
2281    // ==========================
2282
2283    function Plugin(option) {
2284        return this.each(function () {
2285            var $this = $(this)
2286            var data = $this.data('bs.carousel')
2287            var options = $.extend({}, Carousel.DEFAULTS, $this.data(), typeof option == 'object' && option)
2288            var action = typeof option == 'string' ? option : options.slide
2289
2290            if (!data)
2291                $this.data('bs.carousel', (data = new Carousel(this, options)))
2292            if (typeof option == 'number')
2293                data.to(option)
2294            else if (action)
2295                data[action]()
2296            else if (options.interval)
2297                data.pause().cycle()
2298        })
2299    }
2300
2301    var old = $.fn.carousel
2302
2303    $.fn.carousel = Plugin
2304    $.fn.carousel.Constructor = Carousel
2305
2306
2307    // CAROUSEL NO CONFLICT
2308    // ====================
2309
2310    $.fn.carousel.noConflict = function () {
2311        $.fn.carousel = old
2312        return this
2313    }
2314
2315
2316    // CAROUSEL DATA-API
2317    // =================
2318
2319    $(document).on('click.bs.carousel.data-api', '[data-slide], [data-slide-to]', function (e) {
2320        var href
2321        var $this = $(this)
2322        var $target = $($this.attr('data-target') || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) // strip for ie7
2323        if (!$target.hasClass('carousel'))
2324            return
2325        var options = $.extend({}, $target.data(), $this.data())
2326        var slideIndex = $this.attr('data-slide-to')
2327        if (slideIndex)
2328            options.interval = false
2329
2330        Plugin.call($target, options)
2331
2332        if (slideIndex) {
2333            $target.data('bs.carousel').to(slideIndex)
2334        }
2335
2336        e.preventDefault()
2337    })
2338
2339    $(window).on('load', function () {
2340        $('[data-ride="carousel"]').each(function () {
2341            var $carousel = $(this)
2342            Plugin.call($carousel, $carousel.data())
2343        })
2344    })
2345
2346}(jQuery);
2347
2348/* ========================================================================
2349 * Bootstrap: collapse.js v3.2.0
2350 * http://getbootstrap.com/javascript/#collapse
2351 * ========================================================================
2352 * Copyright 2011-2014 Twitter, Inc.
2353 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
2354 * ======================================================================== */
2355
2356
2357+function ($) {
2358    'use strict';
2359
2360    // COLLAPSE PUBLIC CLASS DEFINITION
2361    // ================================
2362
2363    var Collapse = function (element, options) {
2364        this.$element = $(element)
2365        this.options = $.extend({}, Collapse.DEFAULTS, options)
2366        this.transitioning = null
2367
2368        if (this.options.parent)
2369            this.$parent = $(this.options.parent)
2370        if (this.options.toggle)
2371            this.toggle()
2372    }
2373
2374    Collapse.VERSION = '3.2.0'
2375
2376    Collapse.DEFAULTS = {
2377        toggle: true
2378    }
2379
2380    Collapse.prototype.dimension = function () {
2381        var hasWidth = this.$element.hasClass('width')
2382        return hasWidth ? 'width' : 'height'
2383    }
2384
2385    Collapse.prototype.show = function () {
2386        if (this.transitioning || this.$element.hasClass('in'))
2387            return
2388
2389        var startEvent = $.Event('show.bs.collapse')
2390        this.$element.trigger(startEvent)
2391        if (startEvent.isDefaultPrevented())
2392            return
2393
2394        var actives = this.$parent && this.$parent.find('> .panel > .in')
2395
2396        if (actives && actives.length) {
2397            var hasData = actives.data('bs.collapse')
2398            if (hasData && hasData.transitioning)
2399                return
2400            Plugin.call(actives, 'hide')
2401            hasData || actives.data('bs.collapse', null)
2402        }
2403
2404        var dimension = this.dimension()
2405
2406        this.$element
2407            .removeClass('collapse')
2408            .addClass('collapsing')[dimension](0)
2409
2410        this.transitioning = 1
2411
2412        var complete = function () {
2413            this.$element
2414                .removeClass('collapsing')
2415                .addClass('collapse in')[dimension]('')
2416            this.transitioning = 0
2417            this.$element
2418                .trigger('shown.bs.collapse')
2419        }
2420
2421        if (!$.support.transition)
2422            return complete.call(this)
2423
2424        var scrollSize = $.camelCase(['scroll', dimension].join('-'))
2425
2426        this.$element
2427            .one('bsTransitionEnd', $.proxy(complete, this))
2428            .emulateTransitionEnd(350)[dimension](this.$element[0][scrollSize])
2429    }
2430
2431    Collapse.prototype.hide = function () {
2432        if (this.transitioning || !this.$element.hasClass('in'))
2433            return
2434
2435        var startEvent = $.Event('hide.bs.collapse')
2436        this.$element.trigger(startEvent)
2437        if (startEvent.isDefaultPrevented())
2438            return
2439
2440        var dimension = this.dimension()
2441
2442        this.$element[dimension](this.$element[dimension]())[0].offsetHeight
2443
2444        this.$element
2445            .addClass('collapsing')
2446            .removeClass('collapse')
2447            .removeClass('in')
2448
2449        this.transitioning = 1
2450
2451        var complete = function () {
2452            this.transitioning = 0
2453            this.$element
2454                .trigger('hidden.bs.collapse')
2455                .removeClass('collapsing')
2456                .addClass('collapse')
2457        }
2458
2459        if (!$.support.transition)
2460            return complete.call(this)
2461
2462        this.$element
2463        [dimension](0)
2464            .one('bsTransitionEnd', $.proxy(complete, this))
2465            .emulateTransitionEnd(350)
2466    }
2467
2468    Collapse.prototype.toggle = function () {
2469        this[this.$element.hasClass('in') ? 'hide' : 'show']()
2470    }
2471
2472
2473    // COLLAPSE PLUGIN DEFINITION
2474    // ==========================
2475
2476    function Plugin(option) {
2477        return this.each(function () {
2478            var $this = $(this)
2479            var data = $this.data('bs.collapse')
2480            var options = $.extend({}, Collapse.DEFAULTS, $this.data(), typeof option == 'object' && option)
2481
2482            if (!data && options.toggle && option == 'show')
2483                option = !option
2484            if (!data)
2485                $this.data('bs.collapse', (data = new Collapse(this, options)))
2486            if (typeof option == 'string')
2487                data[option]()
2488        })
2489    }
2490
2491    var old = $.fn.collapse
2492
2493    $.fn.collapse = Plugin
2494    $.fn.collapse.Constructor = Collapse
2495
2496
2497    // COLLAPSE NO CONFLICT
2498    // ====================
2499
2500    $.fn.collapse.noConflict = function () {
2501        $.fn.collapse = old
2502        return this
2503    }
2504
2505
2506    // COLLAPSE DATA-API
2507    // =================
2508
2509    $(document).on('click.bs.collapse.data-api', '[data-toggle="collapse"]', function (e) {
2510        var href
2511        var $this = $(this)
2512        var target = $this.attr('data-target')
2513            || e.preventDefault()
2514            || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '') // strip for ie7
2515        var $target = $(target)
2516        var data = $target.data('bs.collapse')
2517        var option = data ? 'toggle' : $this.data()
2518        var parent = $this.attr('data-parent')
2519        var $parent = parent && $(parent)
2520
2521        if (!data || !data.transitioning) {
2522            if ($parent)
2523                $parent.find('[data-toggle="collapse"][data-parent="' + parent + '"]').not($this).addClass('collapsed')
2524            $this[$target.hasClass('in') ? 'addClass' : 'removeClass']('collapsed')
2525        }
2526
2527        Plugin.call($target, option)
2528    })
2529
2530}(jQuery);
2531
2532/* ========================================================================
2533 * Bootstrap: dropdown.js v3.2.0
2534 * http://getbootstrap.com/javascript/#dropdowns
2535 * ========================================================================
2536 * Copyright 2011-2014 Twitter, Inc.
2537 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
2538 * ======================================================================== */
2539
2540
2541+function ($) {
2542    'use strict';
2543
2544    // DROPDOWN CLASS DEFINITION
2545    // =========================
2546
2547    var backdrop = '.dropdown-backdrop'
2548    var toggle = '[data-toggle="dropdown"]'
2549    var Dropdown = function (element) {
2550        $(element).on('click.bs.dropdown', this.toggle)
2551    }
2552
2553    Dropdown.VERSION = '3.2.0'
2554
2555    Dropdown.prototype.toggle = function (e) {
2556        var $this = $(this)
2557
2558        if ($this.is('.disabled, :disabled'))
2559            return
2560
2561        var $parent = getParent($this)
2562        var isActive = $parent.hasClass('open')
2563
2564        clearMenus()
2565
2566        if (!isActive) {
2567            if ('ontouchstart' in document.documentElement && !$parent.closest('.navbar-nav').length) {
2568                // if mobile we use a backdrop because click events don't delegate
2569                $('<div class="dropdown-backdrop"/>').insertAfter($(this)).on('click', clearMenus)
2570            }
2571
2572            var relatedTarget = { relatedTarget: this }
2573            $parent.trigger(e = $.Event('show.bs.dropdown', relatedTarget))
2574
2575            if (e.isDefaultPrevented())
2576                return
2577
2578            $this.trigger('focus')
2579
2580            $parent
2581                .toggleClass('open')
2582                .trigger('shown.bs.dropdown', relatedTarget)
2583        }
2584
2585        return false
2586    }
2587
2588    Dropdown.prototype.keydown = function (e) {
2589        if (!/(38|40|27)/.test(e.keyCode))
2590            return
2591
2592        var $this = $(this)
2593
2594        e.preventDefault()
2595        e.stopPropagation()
2596
2597        if ($this.is('.disabled, :disabled'))
2598            return
2599
2600        var $parent = getParent($this)
2601        var isActive = $parent.hasClass('open')
2602
2603        if (!isActive || (isActive && e.keyCode == 27)) {
2604            if (e.which == 27)
2605                $parent.find(toggle).trigger('focus')
2606            return $this.trigger('click')
2607        }
2608
2609        var desc = ' li:not(.divider):visible a'
2610        var $items = $parent.find('[role="menu"]' + desc + ', [role="listbox"]' + desc)
2611
2612        if (!$items.length)
2613            return
2614
2615        var index = $items.index($items.filter(':focus'))
2616
2617        if (e.keyCode == 38 && index > 0)
2618            index--                        // up
2619        if (e.keyCode == 40 && index < $items.length - 1)
2620            index++                        // down
2621        if (!~index)
2622            index = 0
2623
2624        $items.eq(index).trigger('focus')
2625    }
2626
2627    function clearMenus(e) {
2628        if (e && e.which === 3)
2629            return
2630        $(backdrop).remove()
2631        $(toggle).each(function () {
2632            var $parent = getParent($(this))
2633            var relatedTarget = { relatedTarget: this }
2634            if (!$parent.hasClass('open'))
2635                return
2636            $parent.trigger(e = $.Event('hide.bs.dropdown', relatedTarget))
2637            if (e.isDefaultPrevented())
2638                return
2639            $parent.removeClass('open').trigger('hidden.bs.dropdown', relatedTarget)
2640        })
2641    }
2642
2643    function getParent($this) {
2644        var selector = $this.attr('data-target')
2645
2646        if (!selector) {
2647            selector = $this.attr('href')
2648            selector = selector && /#[A-Za-z]/.test(selector) && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
2649        }
2650
2651        var $parent = selector && $(selector)
2652
2653        return $parent && $parent.length ? $parent : $this.parent()
2654    }
2655
2656
2657    // DROPDOWN PLUGIN DEFINITION
2658    // ==========================
2659
2660    function Plugin(option) {
2661        return this.each(function () {
2662            var $this = $(this)
2663            var data = $this.data('bs.dropdown')
2664
2665            if (!data)
2666                $this.data('bs.dropdown', (data = new Dropdown(this)))
2667            if (typeof option == 'string')
2668                data[option].call($this)
2669        })
2670    }
2671
2672    var old = $.fn.dropdown
2673
2674    $.fn.dropdown = Plugin
2675    $.fn.dropdown.Constructor = Dropdown
2676
2677
2678    // DROPDOWN NO CONFLICT
2679    // ====================
2680
2681    $.fn.dropdown.noConflict = function () {
2682        $.fn.dropdown = old
2683        return this
2684    }
2685
2686
2687    // APPLY TO STANDARD DROPDOWN ELEMENTS
2688    // ===================================
2689
2690    $(document)
2691        .on('click.bs.dropdown.data-api', clearMenus)
2692        .on('click.bs.dropdown.data-api', '.dropdown form', function (e) {
2693            e.stopPropagation()
2694        })
2695        .on('click.bs.dropdown.data-api', toggle, Dropdown.prototype.toggle)
2696        .on('keydown.bs.dropdown.data-api', toggle + ', [role="menu"], [role="listbox"]', Dropdown.prototype.keydown)
2697
2698}(jQuery);
2699
2700/* ========================================================================
2701 * Bootstrap: modal.js v3.2.0
2702 * http://getbootstrap.com/javascript/#modals
2703 * ========================================================================
2704 * Copyright 2011-2014 Twitter, Inc.
2705 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
2706 * ======================================================================== */
2707
2708
2709+function ($) {
2710    'use strict';
2711
2712    // MODAL CLASS DEFINITION
2713    // ======================
2714
2715    var Modal = function (element, options) {
2716        this.options = options
2717        this.$body = $(document.body)
2718        this.$element = $(element)
2719        this.$backdrop =
2720            this.isShown = null
2721        this.scrollbarWidth = 0
2722
2723        if (this.options.remote) {
2724            this.$element
2725                .find('.modal-content')
2726                .load(this.options.remote, $.proxy(function () {
2727                    this.$element.trigger('loaded.bs.modal')
2728                }, this))
2729        }
2730    }
2731
2732    Modal.VERSION = '3.2.0'
2733
2734    Modal.DEFAULTS = {
2735        backdrop: true,
2736        keyboard: true,
2737        show: true
2738    }
2739
2740    Modal.prototype.toggle = function (_relatedTarget) {
2741        return this.isShown ? this.hide() : this.show(_relatedTarget)
2742    }
2743
2744    Modal.prototype.show = function (_relatedTarget) {
2745        var that = this
2746        var e = $.Event('show.bs.modal', { relatedTarget: _relatedTarget })
2747
2748        this.$element.trigger(e)
2749
2750        if (this.isShown || e.isDefaultPrevented())
2751            return
2752
2753        this.isShown = true
2754
2755        this.checkScrollbar()
2756        this.$body.addClass('modal-open')
2757
2758        this.setScrollbar()
2759        this.escape()
2760
2761        this.$element.on('click.dismiss.bs.modal', '[data-dismiss="modal"]', $.proxy(this.hide, this))
2762
2763        this.backdrop(function () {
2764            var transition = $.support.transition && that.$element.hasClass('fade')
2765
2766            if (!that.$element.parent().length) {
2767                that.$element.appendTo(that.$body) // don't move modals dom position
2768            }
2769
2770            that.$element
2771                .show()
2772                .scrollTop(0)
2773
2774            if (transition) {
2775                that.$element[0].offsetWidth // force reflow
2776            }
2777
2778            that.$element
2779                .addClass('in')
2780                .attr('aria-hidden', false)
2781
2782            that.enforceFocus()
2783
2784            var e = $.Event('shown.bs.modal', { relatedTarget: _relatedTarget })
2785
2786            transition ?
2787                that.$element.find('.modal-dialog') // wait for modal to slide in
2788                    .one('bsTransitionEnd', function () {
2789                        that.$element.trigger('focus').trigger(e)
2790                    })
2791                    .emulateTransitionEnd(300) :
2792                that.$element.trigger('focus').trigger(e)
2793        })
2794    }
2795
2796    Modal.prototype.hide = function (e) {
2797        if (e)
2798            e.preventDefault()
2799
2800        e = $.Event('hide.bs.modal')
2801
2802        this.$element.trigger(e)
2803
2804        if (!this.isShown || e.isDefaultPrevented())
2805            return
2806
2807        this.isShown = false
2808
2809        this.$body.removeClass('modal-open')
2810
2811        this.resetScrollbar()
2812        this.escape()
2813
2814        $(document).off('focusin.bs.modal')
2815
2816        this.$element
2817            .removeClass('in')
2818            .attr('aria-hidden', true)
2819            .off('click.dismiss.bs.modal')
2820
2821        $.support.transition && this.$element.hasClass('fade') ?
2822            this.$element
2823                .one('bsTransitionEnd', $.proxy(this.hideModal, this))
2824                .emulateTransitionEnd(300) :
2825            this.hideModal()
2826    }
2827
2828    Modal.prototype.enforceFocus = function () {
2829        $(document)
2830            .off('focusin.bs.modal') // guard against infinite focus loop
2831            .on('focusin.bs.modal', $.proxy(function (e) {
2832                if (this.$element[0] !== e.target && !this.$element.has(e.target).length) {
2833                    this.$element.trigger('focus')
2834                }
2835            }, this))
2836    }
2837
2838    Modal.prototype.escape = function () {
2839        if (this.isShown && this.options.keyboard) {
2840            this.$element.on('keyup.dismiss.bs.modal', $.proxy(function (e) {
2841                e.which == 27 && this.hide()
2842            }, this))
2843        } else if (!this.isShown) {
2844            this.$element.off('keyup.dismiss.bs.modal')
2845        }
2846    }
2847
2848    Modal.prototype.hideModal = function () {
2849        var that = this
2850        this.$element.hide()
2851        this.backdrop(function () {
2852            that.$element.trigger('hidden.bs.modal')
2853        })
2854    }
2855
2856    Modal.prototype.removeBackdrop = function () {
2857        this.$backdrop && this.$backdrop.remove()
2858        this.$backdrop = null
2859    }
2860
2861    Modal.prototype.backdrop = function (callback) {
2862        var that = this
2863        var animate = this.$element.hasClass('fade') ? 'fade' : ''
2864
2865        if (this.isShown && this.options.backdrop) {
2866            var doAnimate = $.support.transition && animate
2867
2868            this.$backdrop = $('<div class="modal-backdrop ' + animate + '" />')
2869                .appendTo(this.$body)
2870
2871            this.$element.on('click.dismiss.bs.modal', $.proxy(function (e) {
2872                if (e.target !== e.currentTarget)
2873                    return
2874                this.options.backdrop == 'static'
2875                    ? this.$element[0].focus.call(this.$element[0])
2876                    : this.hide.call(this)
2877            }, this))
2878
2879            if (doAnimate)
2880                this.$backdrop[0].offsetWidth // force reflow
2881
2882            this.$backdrop.addClass('in')
2883
2884            if (!callback)
2885                return
2886
2887            doAnimate ?
2888                this.$backdrop
2889                    .one('bsTransitionEnd', callback)
2890                    .emulateTransitionEnd(150) :
2891                callback()
2892
2893        } else if (!this.isShown && this.$backdrop) {
2894            this.$backdrop.removeClass('in')
2895
2896            var callbackRemove = function () {
2897                that.removeBackdrop()
2898                callback && callback()
2899            }
2900            $.support.transition && this.$element.hasClass('fade') ?
2901                this.$backdrop
2902                    .one('bsTransitionEnd', callbackRemove)
2903                    .emulateTransitionEnd(150) :
2904                callbackRemove()
2905
2906        } else if (callback) {
2907            callback()
2908        }
2909    }
2910
2911    Modal.prototype.checkScrollbar = function () {
2912        if (document.body.clientWidth >= window.innerWidth)
2913            return
2914        this.scrollbarWidth = this.scrollbarWidth || this.measureScrollbar()
2915    }
2916
2917    Modal.prototype.setScrollbar = function () {
2918        var bodyPad = parseInt((this.$body.css('padding-right') || 0), 10)
2919        if (this.scrollbarWidth)
2920            this.$body.css('padding-right', bodyPad + this.scrollbarWidth)
2921    }
2922
2923    Modal.prototype.resetScrollbar = function () {
2924        this.$body.css('padding-right', '')
2925    }
2926
2927    Modal.prototype.measureScrollbar = function () { // thx walsh
2928        var scrollDiv = document.createElement('div')
2929        scrollDiv.className = 'modal-scrollbar-measure'
2930        this.$body.append(scrollDiv)
2931        var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth
2932        this.$body[0].removeChild(scrollDiv)
2933        return scrollbarWidth
2934    }
2935
2936
2937    // MODAL PLUGIN DEFINITION
2938    // =======================
2939
2940    function Plugin(option, _relatedTarget) {
2941        return this.each(function () {
2942            var $this = $(this)
2943            var data = $this.data('bs.modal')
2944            var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option == 'object' && option)
2945
2946            if (!data)
2947                $this.data('bs.modal', (data = new Modal(this, options)))
2948            if (typeof option == 'string')
2949                data[option](_relatedTarget)
2950            else if (options.show)
2951                data.show(_relatedTarget)
2952        })
2953    }
2954
2955    var old = $.fn.modal
2956
2957    $.fn.modal = Plugin
2958    $.fn.modal.Constructor = Modal
2959
2960
2961    // MODAL NO CONFLICT
2962    // =================
2963
2964    $.fn.modal.noConflict = function () {
2965        $.fn.modal = old
2966        return this
2967    }
2968
2969
2970    // MODAL DATA-API
2971    // ==============
2972
2973    $(document).on('click.bs.modal.data-api', '[data-toggle="modal"]', function (e) {
2974        var $this = $(this)
2975        var href = $this.attr('href')
2976        var $target = $($this.attr('data-target') || (href && href.replace(/.*(?=#[^\s]+$)/, ''))) // strip for ie7
2977        var option = $target.data('bs.modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())
2978
2979        if ($this.is('a'))
2980            e.preventDefault()
2981
2982        $target.one('show.bs.modal', function (showEvent) {
2983            if (showEvent.isDefaultPrevented())
2984                return // only register focus restorer if modal will actually get shown
2985            $target.one('hidden.bs.modal', function () {
2986                $this.is(':visible') && $this.trigger('focus')
2987            })
2988        })
2989        Plugin.call($target, option, this)
2990    })
2991
2992}(jQuery);
2993
2994/* ========================================================================
2995 * Bootstrap: tooltip.js v3.2.0
2996 * http://getbootstrap.com/javascript/#tooltip
2997 * Inspired by the original jQuery.tipsy by Jason Frame
2998 * ========================================================================
2999 * Copyright 2011-2014 Twitter, Inc.
3000 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
3001 * ======================================================================== */
3002
3003
3004+function ($) {
3005    'use strict';
3006
3007    // TOOLTIP PUBLIC CLASS DEFINITION
3008    // ===============================
3009
3010    var Tooltip = function (element, options) {
3011        this.type =
3012            this.options =
3013            this.enabled =
3014            this.timeout =
3015            this.hoverState =
3016            this.$element = null
3017
3018        this.init('tooltip', element, options)
3019    }
3020
3021    Tooltip.VERSION = '3.2.0'
3022
3023    Tooltip.DEFAULTS = {
3024        animation: true,
3025        placement: 'top',
3026        selector: false,
3027        template: '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
3028        trigger: 'hover focus',
3029        title: '',
3030        delay: 0,
3031        html: false,
3032        container: false,
3033        viewport: {
3034            selector: 'body',
3035            padding: 0
3036        }
3037    }
3038
3039    Tooltip.prototype.init = function (type, element, options) {
3040        this.enabled = true
3041        this.type = type
3042        this.$element = $(element)
3043        this.options = this.getOptions(options)
3044        this.$viewport = this.options.viewport && $(this.options.viewport.selector || this.options.viewport)
3045
3046        var triggers = this.options.trigger.split(' ')
3047
3048        for (var i = triggers.length; i--;) {
3049            var trigger = triggers[i]
3050
3051            if (trigger == 'click') {
3052                this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
3053            } else if (trigger != 'manual') {
3054                var eventIn = trigger == 'hover' ? 'mouseenter' : 'focusin'
3055                var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout'
3056
3057                this.$element.on(eventIn + '.' + this.type, this.options.selector, $.proxy(this.enter, this))
3058                this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))
3059            }
3060        }
3061
3062        this.options.selector ?
3063            (this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
3064            this.fixTitle()
3065    }
3066
3067    Tooltip.prototype.getDefaults = function () {
3068        return Tooltip.DEFAULTS
3069    }
3070
3071    Tooltip.prototype.getOptions = function (options) {
3072        options = $.extend({}, this.getDefaults(), this.$element.data(), options)
3073
3074        if (options.delay && typeof options.delay == 'number') {
3075            options.delay = {
3076                show: options.delay,
3077                hide: options.delay
3078            }
3079        }
3080
3081        return options
3082    }
3083
3084    Tooltip.prototype.getDelegateOptions = function () {
3085        var options = {}
3086        var defaults = this.getDefaults()
3087
3088        this._options && $.each(this._options, function (key, value) {
3089            if (defaults[key] != value)
3090                options[key] = value
3091        })
3092
3093        return options
3094    }
3095
3096    Tooltip.prototype.enter = function (obj) {
3097        var self = obj instanceof this.constructor ?
3098            obj : $(obj.currentTarget).data('bs.' + this.type)
3099
3100        if (!self) {
3101            self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
3102            $(obj.currentTarget).data('bs.' + this.type, self)
3103        }
3104
3105        clearTimeout(self.timeout)
3106
3107        self.hoverState = 'in'
3108
3109        if (!self.options.delay || !self.options.delay.show)
3110            return self.show()
3111
3112        self.timeout = setTimeout(function () {
3113            if (self.hoverState == 'in')
3114                self.show()
3115        }, self.options.delay.show)
3116    }
3117
3118    Tooltip.prototype.leave = function (obj) {
3119        var self = obj instanceof this.constructor ?
3120            obj : $(obj.currentTarget).data('bs.' + this.type)
3121
3122        if (!self) {
3123            self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
3124            $(obj.currentTarget).data('bs.' + this.type, self)
3125        }
3126
3127        clearTimeout(self.timeout)
3128
3129        self.hoverState = 'out'
3130
3131        if (!self.options.delay || !self.options.delay.hide)
3132            return self.hide()
3133
3134        self.timeout = setTimeout(function () {
3135            if (self.hoverState == 'out')
3136                self.hide()
3137        }, self.options.delay.hide)
3138    }
3139
3140    Tooltip.prototype.show = function () {
3141        var e = $.Event('show.bs.' + this.type)
3142
3143        if (this.hasContent() && this.enabled) {
3144            this.$element.trigger(e)
3145
3146            var inDom = $.contains(document.documentElement, this.$element[0])
3147            if (e.isDefaultPrevented() || !inDom)
3148                return
3149            var that = this
3150
3151            var $tip = this.tip()
3152
3153            var tipId = this.getUID(this.type)
3154
3155            this.setContent()