https://udobach.com/wp-content/themes/Minamaze_Pro/lib/scripts/modernizr_ver-2.6.2.js

1var _____WB$wombat$assign$function_____=function(name){return (self._wb_wombat && self._wb_wombat.local_init && self._wb_wombat.local_init(name))||self[name];};if(!self.__WB_pmw){self.__WB_pmw=function(obj){this.__WB_source=obj;return this;}}{
2let window = _____WB$wombat$assign$function_____("window");
3let self = _____WB$wombat$assign$function_____("self");
4let document = _____WB$wombat$assign$function_____("document");
5let location = _____WB$wombat$assign$function_____("location");
6let top = _____WB$wombat$assign$function_____("top");
7let parent = _____WB$wombat$assign$function_____("parent");
8let frames = _____WB$wombat$assign$function_____("frames");
9let opens = _____WB$wombat$assign$function_____("opens");
10/*!
11 * Modernizr v2.6.2
12 * www.modernizr.com
13 *
14 * Copyright (c) Faruk Ates, Paul Irish, Alex Sexton
15 * Available under the BSD and MIT licenses: www.modernizr.com/license/
16 */
17
18/*
19 * Modernizr tests which native CSS3 and HTML5 features are available in
20 * the current UA and makes the results available to you in two ways:
21 * as properties on a global Modernizr object, and as classes on the
22 * <html> element. This information allows you to progressively enhance
23 * your pages with a granular level of control over the experience.
24 *
25 * Modernizr has an optional (not included) conditional resource loader
26 * called Modernizr.load(), based on Yepnope.js (yepnopejs.com).
27 * To get a build that includes Modernizr.load(), as well as choosing
28 * which tests to include, go to www.modernizr.com/download/
29 *
30 * Authors        Faruk Ates, Paul Irish, Alex Sexton
31 * Contributors   Ryan Seddon, Ben Alman
32 */
33
34window.Modernizr = (function( window, document, undefined ) {
35
36    var version = '2.6.2',
37
38    Modernizr = {},
39
40    /*>>cssclasses*/
41    // option for enabling the HTML classes to be added
42    enableClasses = true,
43    /*>>cssclasses*/
44
45    docElement = document.documentElement,
46
47    /**
48     * Create our "modernizr" element that we do most feature tests on.
49     */
50    mod = 'modernizr',
51    modElem = document.createElement(mod),
52    mStyle = modElem.style,
53
54    /**
55     * Create the input element for various Web Forms feature tests.
56     */
57    inputElem /*>>inputelem*/ = document.createElement('input') /*>>inputelem*/ ,
58
59    /*>>smile*/
60    smile = ':)',
61    /*>>smile*/
62
63    toString = {}.toString,
64
65    // TODO :: make the prefixes more granular
66    /*>>prefixes*/
67    // List of property values to set for css tests. See ticket #21
68    prefixes = ' -webkit- -moz- -o- -ms- '.split(' '),
69    /*>>prefixes*/
70
71    /*>>domprefixes*/
72    // Following spec is to expose vendor-specific style properties as:
73    //   elem.style.WebkitBorderRadius
74    // and the following would be incorrect:
75    //   elem.style.webkitBorderRadius
76
77    // Webkit ghosts their properties in lowercase but Opera & Moz do not.
78    // Microsoft uses a lowercase `ms` instead of the correct `Ms` in IE8+
79    //   erik.eae.net/archives/2008/03/10/21.48.10/
80
81    // More here: github.com/Modernizr/Modernizr/issues/issue/21
82    omPrefixes = 'Webkit Moz O ms',
83
84    cssomPrefixes = omPrefixes.split(' '),
85
86    domPrefixes = omPrefixes.toLowerCase().split(' '),
87    /*>>domprefixes*/
88
89    /*>>ns*/
90    ns = {'svg': 'http://www.w3.org/2000/svg'},
91    /*>>ns*/
92
93    tests = {},
94    inputs = {},
95    attrs = {},
96
97    classes = [],
98
99    slice = classes.slice,
100
101    featureName, // used in testing loop
102
103
104    /*>>teststyles*/
105    // Inject element with style element and some CSS rules
106    injectElementWithStyles = function( rule, callback, nodes, testnames ) {
107
108      var style, ret, node, docOverflow,
109          div = document.createElement('div'),
110          // After page load injecting a fake body doesn't work so check if body exists
111          body = document.body,
112          // IE6 and 7 won't return offsetWidth or offsetHeight unless it's in the body element, so we fake it.
113          fakeBody = body || document.createElement('body');
114
115      if ( parseInt(nodes, 10) ) {
116          // In order not to give false positives we create a node for each test
117          // This also allows the method to scale for unspecified uses
118          while ( nodes-- ) {
119              node = document.createElement('div');
120              node.id = testnames ? testnames[nodes] : mod + (nodes + 1);
121              div.appendChild(node);
122          }
123      }
124
125      // <style> elements in IE6-9 are considered 'NoScope' elements and therefore will be removed
126      // when injected with innerHTML. To get around this you need to prepend the 'NoScope' element
127      // with a 'scoped' element, in our case the soft-hyphen entity as it won't mess with our measurements.
128      // msdn.microsoft.com/en-us/library/ms533897%28VS.85%29.aspx
129      // Documents served as xml will throw if using &shy; so use xml friendly encoded version. See issue #277
130      style = ['&#173;','<style id="s', mod, '">', rule, '</style>'].join('');
131      div.id = mod;
132      // 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.
133      // Opera will act all quirky when injecting elements in documentElement when page is served as xml, needs fakebody too. #270
134      (body ? div : fakeBody).innerHTML += style;
135      fakeBody.appendChild(div);
136      if ( !body ) {
137          //avoid crashing IE8, if background image is used
138          fakeBody.style.background = '';
139          //Safari 5.13/5.1.4 OSX stops loading if ::-webkit-scrollbar is used and scrollbars are visible
140          fakeBody.style.overflow = 'hidden';
141          docOverflow = docElement.style.overflow;
142          docElement.style.overflow = 'hidden';
143          docElement.appendChild(fakeBody);
144      }
145
146      ret = callback(div, rule);
147      // If this is done after page load we don't want to remove the body so check if body exists
148      if ( !body ) {
149          fakeBody.parentNode.removeChild(fakeBody);
150          docElement.style.overflow = docOverflow;
151      } else {
152          div.parentNode.removeChild(div);
153      }
154
155      return !!ret;
156
157    },
158    /*>>teststyles*/
159
160    /*>>mq*/
161    // adapted from matchMedia polyfill
162    // by Scott Jehl and Paul Irish
163    // gist.github.com/786768
164    testMediaQuery = function( mq ) {
165
166      var matchMedia = window.matchMedia || window.msMatchMedia;
167      if ( matchMedia ) {
168        return matchMedia(mq).matches

168;
169      }
170
171      var bool;
172
173      injectElementWithStyles('@media ' + mq + ' { #' + mod + ' { position: absolute; } }', function( node ) {
174        bool = (window.getComputedStyle ?
175                  getComputedStyle(node, null) :
176                  node.currentStyle)['position'] == 'absolute';
177      });
178
179      return bool;
180
181     },
182     /*>>mq*/
183
184
185    /*>>hasevent*/
186    //
187    // isEventSupported determines if a given element supports the given event
188    // kangax.github.com/iseventsupported/
189    //
190    // The following results are known incorrects:
191    //   Modernizr.hasEvent("webkitTransitionEnd", elem) // false negative
192    //   Modernizr.hasEvent("textInput") // in Webkit. github.com/Modernizr/Modernizr/issues/333
193    //   ...
194    isEventSupported = (function() {
195
196      var TAGNAMES = {
197        'select': 'input', 'change': 'input',
198        'submit': 'form', 'reset': 'form',
199        'error': 'img', 'load': 'img', 'abort': 'img'
200      };
201
202      function isEventSupported( eventName, element ) {
203
204        element = element || document.createElement(TAGNAMES[eventName] || 'div');
205        eventName = 'on' + eventName;
206
207        // When using `setAttribute`, IE skips "unload", WebKit skips "unload" and "resize", whereas `in` "catches" those
208        var isSupported = eventName in element;
209
210        if ( !isSupported ) {
211          // If it has no `setAttribute` (i.e. doesn't implement Node interface), try generic element
212          if ( !element.setAttribute ) {
213            element = document.createElement('div');
214          }
215          if ( element.setAttribute && element.removeAttribute ) {
216            element.setAttribute(eventName, '');
217            isSupported = is(element[eventName], 'function');
218
219            // If property was created, "remove it" (by setting value to `undefined`)
220            if ( !is(element[eventName], 'undefined') ) {
221              element[eventName] = undefined;
222            }
223            element.removeAttribute(eventName);
224          }
225        }
226
227        element = null;
228        return isSupported;
229      }
230      return isEventSupported;
231    })(),
232    /*>>hasevent*/
233
234    // TODO :: Add flag for hasownprop ? didn't last time
235
236    // hasOwnProperty shim by kangax needed for Safari 2.0 support
237    _hasOwnProperty = ({}).hasOwnProperty, hasOwnProp;
238
239    if ( !is(_hasOwnProperty, 'undefined') && !is(_hasOwnProperty.call, 'undefined') ) {
240      hasOwnProp = function (object, property) {
241        return _hasOwnProperty.call(object, property);
242      };
243    }
244    else {
245      hasOwnProp = function (object, property) { /* yes, this can give false positives/negatives, but most of the time we don't care about those */
246        return ((property in object) && is(object.constructor.prototype[property], 'undefined'));
247      };
248    }
249
250    // Adapted from ES5-shim https://github.com/kriskowal/es5-shim/blob/master/es5-shim.js
251    // es5.github.com/#x15.3.4.5
252
253    if (!Function.prototype.bind) {
254      Function.prototype.bind = function bind(that) {
255
256        var target = this;
257
258        if (typeof target != "function") {
259            throw new TypeError();
260        }
261
262        var args = slice.call(arguments, 1),
263            bound = function () {
264
265            if (this instanceof bound) {
266
267              var F = function(){};
268              F.prototype = target.prototype;
269              var self = new F();
270
271              var result = target.apply(
272                  self,
273                  args.concat(slice.call(arguments))
274              );
275              if (Object(result) === result) {
276                  return result;
277              }
278              return self;
279
280            } else {
281
282              return target.apply(
283                  that,
284                  args.concat(slice.call(arguments))
285              );
286
287            }
288
289        };
290
291        return bound;
292      };
293    }
294
295    /**
296     * setCss applies given styles to the Modernizr DOM node.
297     */
298    function setCss( str ) {
299        mStyle.cssText = str;
300    }
301
302    /**
303     * setCssAll extrapolates all vendor-specific css strings.
304     */
305    function setCssAll( str1, str2 ) {
306        return setCss(prefixes.join(str1 + ';') + ( str2 || '' ));
307    }
308
309    /**
310     * is returns a boolean for if typeof obj is exactly type.
311     */
312    function is( obj, type ) {
313        return typeof obj === type;
314    }
315
316    /**
317     * contains returns a boolean for if substr is found within str.
318     */
319    function contains( str, substr ) {
320        return !!~('' + str).indexOf(substr);
321    }
322
323    /*>>testprop*/
324
325    // testProps is a generic CSS / DOM property test.
326
327    // In testing support for a given CSS property, it's legit to test:
328    //    `elem.style[styleName] !== undefined`
329    // If the property is supported it will return an empty string,
330    // if unsupported it will return undefined.
331
332    // We'll take advantage of this quick test and skip setting a style
333    // on our modernizr element, but instead just testing undefined vs
334    // empty string.
335
336    // Because the testing of the CSS property names (with "-", as
337    // opposed to the camelCase DOM properties) is non-portable and
338    // non-standard but works in WebKit and IE (but not Gecko or Opera),
339    // we explicitly reject properties with dashes so that authors
340    // developing in WebKit or IE first don't end up with
341    // browser-specific content by accident.
342
343    function testProps( props, prefixed ) {
344        for ( var i in props ) {
345            var prop = props[i];
346            if ( !contains(prop, "-") && mStyle[prop] !== undefined ) {
347                return prefixed == 'pfx' ? prop : true;
348            }
349        }
350        return false;
351    }
352    /*>>testprop*/
353
354    // TODO :: add testDOMProps
355    /**
356     * testDOMProps is a generic DOM property test; if a browser supports
357     *   a certain property, it won't return undefined for it.
358     */
359    function testDOMProps( props, obj, elem ) {
360        for ( var i in props ) {
361            var item = obj[props[i]];
362            if ( item !== undefined) {
363
364                // return the property name as a string
365                if (elem === false) return props[i];
366
367                // let's bind a function
368                if (is(item, 'function')){
369                  // default to autobind unless override
370                  return item.bind(elem || obj);
371                }
372
373                // return the unbound function or obj or value
374                return item;
375            }
376        }
377        return false;
378    }
379
380    /*>>testallprops*/
381    /**
382     * testPropsAll tests a list of DOM properties we want to check against.
383     *   We specify literally ALL possible (known and/or likely) properties on
384     *   the element including the non-vendor prefixed one, for forward-
385     *   compatibility.
386     */
387    function testPropsAll( prop, prefixed, elem ) {
388
389        var ucProp  = prop.charAt(0).toUpperCase() + prop.slice(1),
390            props   = (prop + ' ' + cssomPrefixes.join(ucProp + ' ') + ucProp).split(' ');
391
392        // did they call .prefixed('boxSizing') or are we just testing a prop?
393        if(is(prefixed, "string") || is(prefixed, "undefined")) {
394          return testProps(props, prefixed);
395
396        // otherwise, they called .prefixed('requestAnimationFrame', window[, elem])
397        } else {
398          props = (prop + ' ' + (domPrefixes).join(ucProp + ' ') + ucProp).split(' ');
399          return testDOMProps(props, prefixed, elem);
400        }
401    }
402    /*>>testallprops*/
403
404
405    /**
406     * Tests
407     * -----
408     */
409
410    // The *new* flexbox
411    // dev.w3.org/csswg/css3-flexbox
412
413    tests['flexbox'] = function() {
414      return testPropsAll('flexWrap');
415    };
416
417    // The *old* flexbox
418    // www.w3.org/TR/2009/WD-css3-flexbox-20090723/
419
420    tests['flexboxlegacy'] = function() {
421        return testPropsAll('boxDirection');
422    };
423
424    // On the S60 and BB Storm, getContext exists, but always returns undefined
425    // so we actually have to call getContext() to verify
426    // github.com/Modernizr/Modernizr/issues/issue/97/
427
428    tests['canvas'] = function() {
429        var elem = document.createElement('canvas');
430        return !!(elem.getContext && elem.getContext('2d'));
431    };
432
433    tests['canvastext'] = function() {
434        return !!(Modernizr['canvas'] && is(document.createElement('canvas').getContext('2d').fillText, 'function'));
435    };
436
437    // webk.it/70117 is tracking a legit WebGL feature detect proposal
438
439    // We do a soft detect which may false positive in order to avoid
440    // an expensive context creation: bugzil.la/732441
441
442    tests['webgl'] = function() {
443        return !!window.WebGLRenderingContext;
444    };
445
446    /*
447     * The Modernizr.touch test only indicates if the browser supports
448     *    touch events, which does not necessarily reflect a touchscreen
449     *    device, as evidenced by tablets running Windows 7 or, alas,
450     *    the Palm Pre / WebOS (touch) phones.
451     *
452     * Additionally, Chrome (desktop) used to lie about its support on this,
453     *    but that has since been rectified: crbug.com/36415
454     *
455     * We also test for Firefox 4 Multitouch Support.
456     *
457     * For more info, see: modernizr.github.com/Modernizr/touch.html
458     */
459
460    tests['touch'] = function() {
461        var bool;
462
463        if(('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch) {
464          bool = true;
465        } else {
466          injectElementWithStyles(['@media (',prefixes.join('touch-enabled),('),mod,')','{#modernizr{top:9px;position:absolute}}'].join(''), function( node ) {
467            bool = node.offsetTop === 9;
468          });
469        }
470
471        return bool;
472    };
473
474
475    // geolocation is often considered a trivial feature detect...
476    // Turns out, it's quite tricky to get right:
477    //
478    // Using !!navigator.geolocation does two things we don't want. It:
479    //   1. Leaks memory in IE9: github.com/Modernizr/Modernizr/issues/513
480    //   2. Disables page caching in WebKit: webk.it/43956
481    //
482    // Meanwhile, in Firefox < 8, an about:config setting could expose
483    // a false positive that would throw an exception: bugzil.la/688158
484
485    tests['geolocation'] = function() {
486        return 'geolocation' in navigator;
487    };
488
489
490    tests['postmessage'] = function() {
491      return !!window.postMessage;
492    };
493
494
495    // Chrome incognito mode used to throw an exception when using openDatabase
496    // It doesn't anymore.
497    tests['websqldatabase'] = function() {
498      return !!window.openDatabase;
499    };
500
501    // Vendors had inconsistent prefixing with the experimental Indexed DB:
502    // - Webkit's implementation is accessible through webkitIndexedDB
503    // - Firefox shipped moz_indexedDB before FF4b9, but since then has been mozIndexedDB
504    // For speed, we don't test the legacy (and beta-only) indexedDB
505    tests['indexedDB'] = function() {
506      return !!testPropsAll("indexedDB", window);
507    };
508
509    // documentMode logic from YUI to filter out IE8 Compat Mode
510    //   which false positives.
511    tests['hashchange'] = function() {
512      return isEventSupported('hashchange', window) && (document.documentMode === undefined || document.documentMode > 7);
513    };
514
515    // Per 1.6:
516    // This used to be Modernizr.historymanagement but the longer
517    // name has been deprecated in favor of a shorter and property-matching one.
518    // The old API is still available in 1.6, but as of 2.0 will throw a warning,
519    // and in the first release thereafter disappear entirely.
520    tests['history'] = function() {
521      return !!(window.history && history.pushState);
522    };
523
524    tests['draganddrop'] = function() {
525        var div = document.createElement('div');
526        return ('draggable' in div) || ('ondragstart' in div && 'ondrop' in div);
527    };
528
529    // FF3.6 was EOL'ed on 4/24/12, but the ESR version of FF10
530    // will be supported until FF19 (2/12/13), at which time, ESR becomes FF17.
531    // FF10 still uses prefixes, so check for it until then.
532    // for more ESR info, see: mozilla.org/en-US/firefox/organizations/faq/
533    tests['websockets'] = function() {
534        return 'WebSocket' in window || 'MozWebSocket' in window;
535    };
536
537
538    // css-tricks.com/rgba-browser-support/
539    tests['rgba'] = function() {
540        // Set an rgba() color and check the returned value
541
542        setCss('background-color:rgba(150,255,150,.5)');
543
544        return contains(mStyle.backgroundColor, 'rgba');
545    };
546
547    tests['hsla'] = function() {
548        // Same as rgba(), in fact, browsers re-map hsla() to rgba() internally,
549        //   except IE9 who retains it as hsla
550
551        setCss('background-color:hsla(120,40%,100%,.5)');
552
553        return contains(mStyle.backgroundColor, 'rgba') || contains(mStyle.backgroundColor, 'hsla');
554    };
555
556    tests['multiplebgs'] = function() {
557        // Setting multiple images AND a color on the background shorthand property
558        //  and then querying the style.background property value for the number of
559        //  occurrences of "url(" is a reliable method for detecting ACTUAL support for this!
560
561        setCss('background:url(https://),url(https://),red url(https://)');
562
563        // If the UA supports multiple backgrounds, there should be three occurrences
564        //   of the string "url(" in the return value for elemStyle.background
565
566        return (/(url\s*\(.*?){3}/).test(mStyle.background);
567    };
568
569
570
571    // this will false positive in Opera Mini
572    //   github.com/Modernizr/Modernizr/issues/396
573
574    tests['backgroundsize'] = function() {
575        return testPropsAll('backgroundSize');
576    };
577
578    tests['borderimage'] = function() {
579        return testPropsAll('borderImage');
580    };
581
582
583    // Super comprehensive table about all the unique implementations of
584    // border-radius: muddledramblings.com/table-of-css3-border-radius-compliance
585
586    tests['borderradius'] = function() {
587        return testPropsAll('borderRadius');
588    };
589
590    // WebOS unfortunately false positives on this test.
591    tests['boxshadow'] = function() {
592        return testPropsAll('boxShadow');
593    };
594
595    // FF3.0 will false positive on this test
596    tests['textshadow'] = function() {
597        return document.createElement('div').style.textShadow === '';
598    };
599
600
601    tests['opacity'] = function() {
602        // Browsers that actually have CSS Opacity implemented have done so
603        //  according to spec, which means their return values are within the
604        //  range of [0.0,1.0] - including the leading zero.
605
606        setCssAll('opacity:.55');
607
608        // The non-literal . in this regex is intentional:
609        //   German Chrome returns this value as 0,55
610        // github.com/Modernizr/Modernizr/issues/#issue/59/comment/516632
611        return (/^0.55$/).test(mStyle.opacity);
612    };
613
614
615    // Note, Android < 4 will pass this test, but can only animate
616    //   a single property at a time
617    //   

617
618    tests['cssanimations'] = function() {
619        return testPropsAll('animationName');
620    };
621
622
623    tests['csscolumns'] = function() {
624        return testPropsAll('columnCount');
625    };
626
627
628    tests['cssgradients'] = function() {
629        /**
630         * For CSS Gradients syntax, please see:
631         * webkit.org/blog/175/introducing-css-gradients/
632         * developer.mozilla.org/en/CSS/-moz-linear-gradient
633         * developer.mozilla.org/en/CSS/-moz-radial-gradient
634         * dev.w3.org/csswg/css3-images/#gradients-
635         */
636
637        var str1 = 'background-image:',
638            str2 = 'gradient(linear,left top,right bottom,from(#9f9),to(white));',
639            str3 = 'linear-gradient(left top,#9f9, white);';
640
641        setCss(
642             // legacy webkit syntax (FIXME: remove when syntax not in use anymore)
643              (str1 + '-webkit- '.split(' ').join(str2 + str1) +
644             // standard syntax             // trailing 'background-image:'
645              prefixes.join(str3 + str1)).slice(0, -str1.length)
646        );
647
648        return contains(mStyle.backgroundImage, 'gradient');
649    };
650
651
652    tests['cssreflections'] = function() {
653        return testPropsAll('boxReflect');
654    };
655
656
657    tests['csstransforms'] = function() {
658        return !!testPropsAll('transform');
659    };
660
661
662    tests['csstransforms3d'] = function() {
663
664        var ret = !!testPropsAll('perspective');
665
666        // Webkit's 3D transforms are passed off to the browser's own graphics renderer.
667        //   It works fine in Safari on Leopard and Snow Leopard, but not in Chrome in
668        //   some conditions. As a result, Webkit typically recognizes the syntax but
669        //   will sometimes throw a false positive, thus we must do a more thorough check:
670        if ( ret && 'webkitPerspective' in docElement.style ) {
671
672          // Webkit allows this media query to succeed only if the feature is enabled.
673          // `@media (transform-3d),(-webkit-transform-3d){ ... }`
674          injectElementWithStyles('@media (transform-3d),(-webkit-transform-3d){#modernizr{left:9px;position:absolute;height:3px;}}', function( node, rule ) {
675            ret = node.offsetLeft === 9 && node.offsetHeight === 3;
676          });
677        }
678        return ret;
679    };
680
681
682    tests['csstransitions'] = function() {
683        return testPropsAll('transition');
684    };
685
686
687    /*>>fontface*/
688    // @font-face detection routine by Diego Perini
689    // javascript.nwbox.com/CSSSupport/
690
691    // false positives:
692    //   WebOS github.com/Modernizr/Modernizr/issues/342
693    //   WP7   github.com/Modernizr/Modernizr/issues/538
694    tests['fontface'] = function() {
695        var bool;
696
697        injectElementWithStyles('@font-face {font-family:"font";src:url("https://")}', function( node, rule ) {
698          var style = document.getElementById('smodernizr'),
699              sheet = style.sheet || style.styleSheet,
700              cssText = sheet ? (sheet.cssRules && sheet.cssRules[0] ? sheet.cssRules[0].cssText : sheet.cssText || '') : '';
701
702          bool = /src/i.test(cssText) && cssText.indexOf(rule.split(' ')[0]) === 0;
703        });
704
705        return bool;
706    };
707    /*>>fontface*/
708
709    // CSS generated content detection
710    tests['generatedcontent'] = function() {
711        var bool;
712
713        injectElementWithStyles(['#',mod,'{font:0/0 a}#',mod,':after{content:"',smile,'";visibility:hidden;font:3px/1 a}'].join(''), function( node ) {
714          bool = node.offsetHeight >= 3;
715        });
716
717        return bool;
718    };
719
720
721
722    // These tests evaluate support of the video/audio elements, as well as
723    // testing what types of content they support.
724    //
725    // We're using the Boolean constructor here, so that we can extend the value
726    // e.g.  Modernizr.video     // true
727    //       Modernizr.video.ogg // 'probably'
728    //
729    // Codec values from : github.com/NielsLeenheer/html5test/blob/9106a8/index.html#L845
730    //                     thx to NielsLeenheer and zcorpan
731
732    // Note: in some older browsers, "no" was a return value instead of empty string.
733    //   It was live in FF3.5.0 and 3.5.1, but fixed in 3.5.2
734    //   It was also live in Safari 4.0.0 - 4.0.4, but fixed in 4.0.5
735
736    tests['video'] = function() {
737        var elem = document.createElement('video'),
738            bool = false;
739
740        // IE9 Running on Windows Server SKU can cause an exception to be thrown, bug #224
741        try {
742            if ( bool = !!elem.canPlayType ) {
743                bool      = new Boolean(bool);
744                bool.ogg  = elem.canPlayType('video/ogg; codecs="theora"')      .replace(/^no$/,'');
745
746                // Without QuickTime, this value will be `undefined`. github.com/Modernizr/Modernizr/issues/546
747                bool.h264 = elem.canPlayType('video/mp4; codecs="avc1.42E01E"') .replace(/^no$/,'');
748
749                bool.webm = elem.canPlayType('video/webm; codecs="vp8, vorbis"').replace(/^no$/,'');
750            }
751
752        } catch(e) { }
753
754        return bool;
755    };
756
757    tests['audio'] = function() {
758        var elem = document.createElement('audio'),
759            bool = false;
760
761        try {
762            if ( bool = !!elem.canPlayType ) {
763                bool      = new Boolean(bool);
764                bool.ogg  = elem.canPlayType('audio/ogg; codecs="vorbis"').replace(/^no$/,'');
765                bool.mp3  = elem.canPlayType('audio/mpeg;')               .replace(/^no$/,'');
766
767                // Mimetypes accepted:
768                //   developer.mozilla.org/En/Media_formats_supported_by_the_audio_and_video_elements
769                //   bit.ly/iphoneoscodecs
770                bool.wav  = elem.canPlayType('audio/wav; codecs="1"')     .replace(/^no$/,'');
771                bool.m4a  = ( elem.canPlayType('audio/x-m4a;')            ||
772                              elem.canPlayType('audio/aac;'))             .replace(/^no$/,'');
773            }
774        } catch(e) { }
775
776        return bool;
777    };
778
779
780    // In FF4, if disabled, window.localStorage should === null.
781
782    // Normally, we could not test that directly and need to do a
783    //   `('localStorage' in window) && ` test first because otherwise Firefox will
784    //   throw bugzil.la/365772 if cookies are disabled
785
786    // Also in iOS5 Private Browsing mode, attempting to use localStorage.setItem
787    // will throw the exception:
788    //   QUOTA_EXCEEDED_ERRROR DOM Exception 22.
789    // Peculiarly, getItem and removeItem calls do not throw.
790
791    // Because we are forced to try/catch this, we'll go aggressive.
792
793    // Just FWIW: IE8 Compat mode supports these features completely:
794    //   www.quirksmode.org/dom/html5.html
795    // But IE8 doesn't support either with local files
796
797    tests['localstorage'] = function() {
798        try {
799            localStorage.setItem(mod, mod);
800            localStorage.removeItem(mod);
801            return true;
802        } catch(e) {
803            return false;
804        }
805    };
806
807    tests['sessionstorage'] = function() {
808        try {
809            sessionStorage.setItem(mod, mod);
810            sessionStorage.removeItem(mod);
811            return true;
812        } catch(e) {
813            return false;
814        }
815    };
816
817
818    tests['webworkers'] = function() {
819        return !!window.Worker;
820    };
821
822
823    tests['applicationcache'] = function() {
824        return !!window.applicationCache;
825    };
826
827
828    // Thanks to Erik Dahlstrom
829    tests['svg'] = function() {
830        return !!document.createElementNS && !!document.createElementNS(ns.svg, 'svg').createSVGRect;
831    };
832
833    // specifically for SVG inline in HTML, not within XHTML
834    // test page: paulirish.com/demo/inline-svg
835    tests['inlinesvg'] = function() {
836      var div = document.createElement('div');
837      div.innerHTML = '<svg/>';
838      return (div.firstChild && div.firstChild.namespaceURI) == ns.svg;
839    };
840
841    // SVG SMIL animation
842    tests['smil'] = function() {
843        return !!document.createElementNS && /SVGAnimate/.test(toString.call(document.createElementNS(ns.svg, 'animate')));
844    };
845
846    // This test is only for clip paths in SVG proper, not clip paths on HTML content
847    // demo: srufaculty.sru.edu/david.dailey/svg/newstuff/clipPath4.svg
848
849    // However read the comments to dig into applying SVG clippaths to HTML content here:
850    //   github.com/Modernizr/Modernizr/issues/213#issuecomment-1149491
851    tests['svgclippaths'] = function() {
852        return !!document.createElementNS && /SVGClipPath/.test(toString.call(document.createElementNS(ns.svg, 'clipPath')));
853    };
854
855    /*>>webforms*/
856    // input features and input types go directly onto the ret object, bypassing the tests loop.
857    // Hold this guy to execute in a moment.
858    function webforms() {
859        /*>>input*/
860        // Run through HTML5's new input attributes to see if the UA understands any.
861        // We're using f which is the <input> element created early on
862        // Mike Taylr has created a comprehensive resource for testing these attributes
863        //   when applied to all input types:
864        //   miketaylr.com/code/input-type-attr.html
865        // spec: www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
866
867        // Only input placeholder is tested while textarea's placeholder is not.
868        // Currently Safari 4 and Opera 11 have support only for the input placeholder
869        // Both tests are available in feature-detects/forms-placeholder.js
870        Modernizr['input'] = (function( props ) {
871            for ( var i = 0, len = props.length; i < len; i++ ) {
872                attrs[ props[i] ] = !!(props[i] in inputElem);
873            }
874            if (attrs.list){
875              // safari false positive's on datalist: webk.it/74252
876              // see also github.com/Modernizr/Modernizr/issues/146
877              attrs.list = !!(document.createElement('datalist') && window.HTMLDataListElement);
878            }
879            return attrs;
880        })('autocomplete autofocus list placeholder max min multiple pattern required step'.split(' '));
881        /*>>input*/
882
883        /*>>inputtypes*/
884        // Run through HTML5's new input types to see if the UA understands any.
885        //   This is put behind the tests runloop because it doesn't return a
886        //   true/false like all the other tests; instead, it returns an object
887        //   containing each input type with its corresponding true/false value
888
889        // Big thanks to @miketaylr for the html5 forms expertise. miketaylr.com/
890        Modernizr['inputtypes'] = (function(props) {
891
892            for ( var i = 0, bool, inputElemType, defaultView, len = props.length; i < len; i++ ) {
893
894                inputElem.setAttribute('type', inputElemType = props[i]);
895                bool = inputElem.type !== 'text';
896
897                // We first check to see if the type we give it sticks..
898                // If the type does, we feed it a textual value, which shouldn't be valid.
899                // If the value doesn't stick, we know there's input sanitization which infers a custom UI
900                if ( bool ) {
901
902                    inputElem.value         = smile;
903                    inputElem.style.cssText = 'position:absolute;visibility:hidden;';
904
905                    if ( /^range$/.test(inputElemType) && inputElem.style.WebkitAppearance !== undefined ) {
906
907                      docElement.appendChild(inputElem);
908                      defaultView = document.defaultView;
909
910                      // Safari 2-4 allows the smiley as a value, despite making a slider
911                      bool =  defaultView.getComputedStyle &&
912                              defaultView.getComputedStyle(inputElem, null).WebkitAppearance !== 'textfield' &&
913                              // Mobile android web browser has false positive, so must
914                              // check the height to see if the widget is actually there.
915                              (inputElem.offsetHeight !== 0);
916
917                      docElement.removeChild(inputElem);
918
919                    } else if ( /^(search|tel)$/.test(inputElemType) ){
920                      // Spec doesn't define any special parsing or detectable UI
921                      //   behaviors so we pass these through as true
922
923                      // Interestingly, opera fails the earlier test, so it doesn't
924                      //  even make it here.
925
926                    } else if ( /^(url|email)$/.test(inputElemType) ) {
927                      // Real url and email support comes with prebaked validation.
928                      bool = inputElem.checkValidity && inputElem.checkValidity() === false;
929
930                    } else {
931                      // If the upgraded input compontent rejects the :) text, we got a winner
932                      bool = inputElem.value != smile;
933                    }
934                }
935
936                inputs[ props[i] ] = !!bool;
937            }
938            return inputs;
939        })('search tel url email datetime date month week time datetime-local number range color'.split(' '));
940        /*>>inputtypes*/
941    }
942    /*>>webforms*/
943
944
945    // End of test definitions
946    // -----------------------
947
948
949
950    // Run through all tests and detect their support in the current UA.
951    // todo: hypothetically we could be doing an array of tests and use a basic loop here.
952    for ( var feature in tests ) {
953        if ( hasOwnProp(tests, feature) ) {
954            // run the test, throw the return value into the Modernizr,
955            //   then based on that boolean, define an appropriate className
956            //   and push it into an array of classes we'll join later.
957            featureName  = feature.toLowerCase();
958            Modernizr[featureName] = tests[feature]();
959
960            classes.push((Modernizr[featureName] ? '' : 'no-') + featureName);
961        }
962    }
963
964    /*>>webforms*/
965    // input tests need to run.
966    Modernizr.input || webforms();
967    /*>>webforms*/
968
969
970    /**
971     * addTest allows the user to define their own feature tests
972     * the result will be added onto the Modernizr object,
973     * as well as an appropriate className set on the html element
974     *
975     * @param feature - String naming the feature
976     * @param test - Function returning true if feature is supported, false if not
977     */
978     Modernizr.addTest = function ( feature, test ) {
979       if ( typeof feature == 'object' ) {
980         for ( var key in feature ) {
981           if ( hasOwnProp( feature, key ) ) {
982             Modernizr.addTest( key, feature[ key ] );
983           }
984         }
985       } else {
986
987         feature = feature.toLowerCase();
988
989         if ( Modernizr[feature] !== undefined ) {
990           // we're going to quit if you're trying to overwrite an existing test
991           // if we were to allow it, we'd do this:
992           //   var re = new RegExp("\\b(no-)?" + feature + "\\b");
993           //   docElement.className = docElement.className.replace( re, '' );
994           // but, no rly, stuff 'em.
995           return Modernizr;
996         }
997
998         test = typeof test == 'function' ? test() : test;
999
1000         if (typeof enableClasses !== "undefined" && enableClasses) {
1001           docElement.className += ' ' + (test ? '' : 'no-') + feature;
1002         }
1003         Modernizr[feature] = test;
1004
1005       }
1006
1007       return Modernizr; // allow chaining.
1008     };
1009
1010
1011    // Reset modElem.cssText to nothing to reduce memory footprint.
1012    setCss('');
1013    modElem = inputElem = null;
1014
1015    /*>>shiv*/
1016    /*

1016! HTML5 Shiv v3.6.1 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed */
1017    ;(function(window, document) {
1018    /*jshint evil:true */
1019      /** Preset options */
1020      var options = window.html5 || {};
1021
1022      /** Used to skip problem elements */
1023      var reSkip = /^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i;
1024
1025      /** Not all elements can be cloned in IE **/
1026      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;
1027
1028      /** Detect whether the browser supports default html5 styles */
1029      var supportsHtml5Styles;
1030
1031      /** Name of the expando, to work with multiple documents or to re-shiv one document */
1032      var expando = '_html5shiv';
1033
1034      /** The id for the the documents expando */
1035      var expanID = 0;
1036
1037      /** Cached data for each document */
1038      var expandoData = {};
1039
1040      /** Detect whether the browser supports unknown elements */
1041      var supportsUnknownElements;
1042
1043      (function() {
1044        try {
1045            var a = document.createElement('a');
1046            a.innerHTML = '<xyz></xyz>';
1047            //if the hidden property is implemented we can assume, that the browser supports basic HTML5 Styles
1048            supportsHtml5Styles = ('hidden' in a);
1049
1050            supportsUnknownElements = a.childNodes.length == 1 || (function() {
1051              // assign a false positive if unable to shiv
1052              (document.createElement)('a');
1053              var frag = document.createDocumentFragment();
1054              return (
1055                typeof frag.cloneNode == 'undefined' ||
1056                typeof frag.createDocumentFragment == 'undefined' ||
1057                typeof frag.createElement == 'undefined'
1058              );
1059            }());
1060        } catch(e) {
1061          supportsHtml5Styles = true;
1062          supportsUnknownElements = true;
1063        }
1064
1065      }());
1066
1067      /*--------------------------------------------------------------------------*/
1068
1069      /**
1070       * Creates a style sheet with the given CSS text and adds it to the document.
1071       * @private
1072       * @param {Document} ownerDocument The document.
1073       * @param {String} cssText The CSS text.
1074       * @returns {StyleSheet} The style element.
1075       */
1076      function addStyleSheet(ownerDocument, cssText) {
1077        var p = ownerDocument.createElement('p'),
1078            parent = ownerDocument.getElementsByTagName('head')[0] || ownerDocument.documentElement;
1079
1080        p.innerHTML = 'x<style>' + cssText + '</style>';
1081        return parent.insertBefore(p.lastChild, parent.firstChild);
1082      }
1083
1084      /**
1085       * Returns the value of `html5.elements` as an array.

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