From c534800ab9607642fae4d3d222dd53f0e819646a Mon Sep 17 00:00:00 2001 From: squidfunk Date: Mon, 8 Aug 2016 23:33:06 +0200 Subject: [PATCH] Added search bar to screen header --- .../javascripts/modernizr-30b4746408.js | 1818 +++++++++++++++++ .../javascripts/modernizr-d1e05123d4.js | 1 - .../stylesheets/application-cbf902c7ca.css | 1 + .../stylesheets/application-fe75383308.css | 1 - material/assets/stylesheets/application.css | 2 +- material/base.html | 4 +- material/header.html | 4 + material/manifest.json | 4 +- src/assets/stylesheets/base/_typeset.scss | 32 +- .../stylesheets/extensions/_codehilite.scss | 70 +- .../stylesheets/extensions/_permalinks.scss | 2 +- src/assets/stylesheets/layout/_header.scss | 74 + src/assets/stylesheets/layout/_search.scss | 0 src/header.html | 7 + 14 files changed, 1959 insertions(+), 61 deletions(-) create mode 100644 material/assets/javascripts/modernizr-30b4746408.js delete mode 100644 material/assets/javascripts/modernizr-d1e05123d4.js create mode 100644 material/assets/stylesheets/application-cbf902c7ca.css delete mode 100644 material/assets/stylesheets/application-fe75383308.css create mode 100644 src/assets/stylesheets/layout/_search.scss diff --git a/material/assets/javascripts/modernizr-30b4746408.js b/material/assets/javascripts/modernizr-30b4746408.js new file mode 100644 index 000000000..c309a1b82 --- /dev/null +++ b/material/assets/javascripts/modernizr-30b4746408.js @@ -0,0 +1,1818 @@ +/*! + * modernizr v3.3.1 + * Build http://modernizr.com/download?-contains-csstransforms3d-fontface-supports-target-addtest-fnbind-printshiv-setclasses-testprop-dontmin + * + * Copyright (c) + * Faruk Ates + * Paul Irish + * Alex Sexton + * Ryan Seddon + * Patrick Kettner + * Stu Cox + * Richard Herrera + + * MIT License + */ + +/* + * Modernizr tests which native CSS3 and HTML5 features are available in the + * current UA and makes the results available to you in two ways: as properties on + * a global `Modernizr` object, and as classes on the `` element. This + * information allows you to progressively enhance your pages with a granular level + * of control over the experience. +*/ + +;(function(window, document, undefined){ + var tests = []; + + + /** + * + * ModernizrProto is the constructor for Modernizr + * + * @class + * @access public + */ + + var ModernizrProto = { + // The current version, dummy + _version: '3.3.1', + + // Any settings that don't work as separate modules + // can go in here as configuration. + _config: { + 'classPrefix': '', + 'enableClasses': true, + 'enableJSClass': true, + 'usePrefixes': true + }, + + // Queue of tests + _q: [], + + // Stub these for people who are listening + on: function(test, cb) { + // I don't really think people should do this, but we can + // safe guard it a bit. + // -- NOTE:: this gets WAY overridden in src/addTest for actual async tests. + // This is in case people listen to synchronous tests. I would leave it out, + // but the code to *disallow* sync tests in the real version of this + // function is actually larger than this. + var self = this; + setTimeout(function() { + cb(self[test]); + }, 0); + }, + + addTest: function(name, fn, options) { + tests.push({name: name, fn: fn, options: options}); + }, + + addAsyncTest: function(fn) { + tests.push({name: null, fn: fn}); + } + }; + + + + // Fake some of Object.create so we can force non test results to be non "own" properties. + var Modernizr = function() {}; + Modernizr.prototype = ModernizrProto; + + // Leak modernizr globally when you `require` it rather than force it here. + // Overwrite name so constructor name is nicer :D + Modernizr = new Modernizr(); + + + + var classes = []; + + + /** + * is returns a boolean if the typeof an obj is exactly type. + * + * @access private + * @function is + * @param {*} obj - A thing we want to check the type of + * @param {string} type - A string to compare the typeof against + * @returns {boolean} + */ + + function is(obj, type) { + return typeof obj === type; + } + ; + + /** + * Run through all tests and detect their support in the current UA. + * + * @access private + */ + + function testRunner() { + var featureNames; + var feature; + var aliasIdx; + var result; + var nameIdx; + var featureName; + var featureNameSplit; + + for (var featureIdx in tests) { + if (tests.hasOwnProperty(featureIdx)) { + featureNames = []; + feature = tests[featureIdx]; + // run the test, throw the return value into the Modernizr, + // then based on that boolean, define an appropriate className + // and push it into an array of classes we'll join later. + // + // If there is no name, it's an 'async' test that is run, + // but not directly added to the object. That should + // be done with a post-run addTest call. + if (feature.name) { + featureNames.push(feature.name.toLowerCase()); + + if (feature.options && feature.options.aliases && feature.options.aliases.length) { + // Add all the aliases into the names list + for (aliasIdx = 0; aliasIdx < feature.options.aliases.length; aliasIdx++) { + featureNames.push(feature.options.aliases[aliasIdx].toLowerCase()); + } + } + } + + // Run the test, or use the raw value if it's not a function + result = is(feature.fn, 'function') ? feature.fn() : feature.fn; + + + // Set each of the names on the Modernizr object + for (nameIdx = 0; nameIdx < featureNames.length; nameIdx++) { + featureName = featureNames[nameIdx]; + // Support dot properties as sub tests. We don't do checking to make sure + // that the implied parent tests have been added. You must call them in + // order (either in the test, or make the parent test a dependency). + // + // Cap it to TWO to make the logic simple and because who needs that kind of subtesting + // hashtag famous last words + featureNameSplit = featureName.split('.'); + + if (featureNameSplit.length === 1) { + Modernizr[featureNameSplit[0]] = result; + } else { + // cast to a Boolean, if not one already + /* jshint -W053 */ + if (Modernizr[featureNameSplit[0]] && !(Modernizr[featureNameSplit[0]] instanceof Boolean)) { + Modernizr[featureNameSplit[0]] = new Boolean(Modernizr[featureNameSplit[0]]); + } + + Modernizr[featureNameSplit[0]][featureNameSplit[1]] = result; + } + + classes.push((result ? '' : 'no-') + featureNameSplit.join('-')); + } + } + } + } + ; + + /** + * docElement is a convenience wrapper to grab the root element of the document + * + * @access private + * @returns {HTMLElement|SVGElement} The root element of the document + */ + + var docElement = document.documentElement; + + + /** + * A convenience helper to check if the document we are running in is an SVG document + * + * @access private + * @returns {boolean} + */ + + var isSVG = docElement.nodeName.toLowerCase() === 'svg'; + + + /** + * setClasses takes an array of class names and adds them to the root element + * + * @access private + * @function setClasses + * @param {string[]} classes - Array of class names + */ + + // Pass in an and array of class names, e.g.: + // ['no-webp', 'borderradius', ...] + function setClasses(classes) { + var className = docElement.className; + var classPrefix = Modernizr._config.classPrefix || ''; + + if (isSVG) { + className = className.baseVal; + } + + // Change `no-js` to `js` (independently of the `enableClasses` option) + // Handle classPrefix on this too + if (Modernizr._config.enableJSClass) { + var reJS = new RegExp('(^|\\s)' + classPrefix + 'no-js(\\s|$)'); + className = className.replace(reJS, '$1' + classPrefix + 'js$2'); + } + + if (Modernizr._config.enableClasses) { + // Add the new classes + className += ' ' + classPrefix + classes.join(' ' + classPrefix); + isSVG ? docElement.className.baseVal = className : docElement.className = className; + } + + } + + ; + + /** + * hasOwnProp is a shim for hasOwnProperty that is needed for Safari 2.0 support + * + * @author kangax + * @access private + * @function hasOwnProp + * @param {object} object - The object to check for a property + * @param {string} property - The property to check for + * @returns {boolean} + */ + + // hasOwnProperty shim by kangax needed for Safari 2.0 support + var hasOwnProp; + + (function() { + var _hasOwnProperty = ({}).hasOwnProperty; + /* istanbul ignore else */ + /* we have no way of testing IE 5.5 or safari 2, + * so just assume the else gets hit */ + if (!is(_hasOwnProperty, 'undefined') && !is(_hasOwnProperty.call, 'undefined')) { + hasOwnProp = function(object, property) { + return _hasOwnProperty.call(object, property); + }; + } + else { + hasOwnProp = function(object, property) { /* yes, this can give false positives/negatives, but most of the time we don't care about those */ + return ((property in object) && is(object.constructor.prototype[property], 'undefined')); + }; + } + })(); + + + + + // _l tracks listeners for async tests, as well as tests that execute after the initial run + ModernizrProto._l = {}; + + /** + * Modernizr.on is a way to listen for the completion of async tests. Being + * asynchronous, they may not finish before your scripts run. As a result you + * will get a possibly false negative `undefined` value. + * + * @memberof Modernizr + * @name Modernizr.on + * @access public + * @function on + * @param {string} feature - String name of the feature detect + * @param {function} cb - Callback function returning a Boolean - true if feature is supported, false if not + * @example + * + * ```js + * Modernizr.on('flash', function( result ) { + * if (result) { + * // the browser has flash + * } else { + * // the browser does not have flash + * } + * }); + * ``` + */ + + ModernizrProto.on = function(feature, cb) { + // Create the list of listeners if it doesn't exist + if (!this._l[feature]) { + this._l[feature] = []; + } + + // Push this test on to the listener list + this._l[feature].push(cb); + + // If it's already been resolved, trigger it on next tick + if (Modernizr.hasOwnProperty(feature)) { + // Next Tick + setTimeout(function() { + Modernizr._trigger(feature, Modernizr[feature]); + }, 0); + } + }; + + /** + * _trigger is the private function used to signal test completion and run any + * callbacks registered through [Modernizr.on](#modernizr-on) + * + * @memberof Modernizr + * @name Modernizr._trigger + * @access private + * @function _trigger + * @param {string} feature - string name of the feature detect + * @param {function|boolean} [res] - A feature detection function, or the boolean = + * result of a feature detection function + */ + + ModernizrProto._trigger = function(feature, res) { + if (!this._l[feature]) { + return; + } + + var cbs = this._l[feature]; + + // Force async + setTimeout(function() { + var i, cb; + for (i = 0; i < cbs.length; i++) { + cb = cbs[i]; + cb(res); + } + }, 0); + + // Don't trigger these again + delete this._l[feature]; + }; + + /** + * addTest allows you to define your own feature detects that are not currently + * included in Modernizr (under the covers it's the exact same code Modernizr + * uses for its own [feature detections](https://github.com/Modernizr/Modernizr/tree/master/feature-detects)). Just like the offical detects, the result + * will be added onto the Modernizr object, as well as an appropriate className set on + * the html element when configured to do so + * + * @memberof Modernizr + * @name Modernizr.addTest + * @optionName Modernizr.addTest() + * @optionProp addTest + * @access public + * @function addTest + * @param {string|object} feature - The string name of the feature detect, or an + * object of feature detect names and test + * @param {function|boolean} test - Function returning true if feature is supported, + * false if not. Otherwise a boolean representing the results of a feature detection + * @example + * + * The most common way of creating your own feature detects is by calling + * `Modernizr.addTest` with a string (preferably just lowercase, without any + * punctuation), and a function you want executed that will return a boolean result + * + * ```js + * Modernizr.addTest('itsTuesday', function() { + * var d = new Date(); + * return d.getDay() === 2; + * }); + * ``` + * + * When the above is run, it will set Modernizr.itstuesday to `true` when it is tuesday, + * and to `false` every other day of the week. One thing to notice is that the names of + * feature detect functions are always lowercased when added to the Modernizr object. That + * means that `Modernizr.itsTuesday` will not exist, but `Modernizr.itstuesday` will. + * + * + * Since we only look at the returned value from any feature detection function, + * you do not need to actually use a function. For simple detections, just passing + * in a statement that will return a boolean value works just fine. + * + * ```js + * Modernizr.addTest('hasJquery', 'jQuery' in window); + * ``` + * + * Just like before, when the above runs `Modernizr.hasjquery` will be true if + * jQuery has been included on the page. Not using a function saves a small amount + * of overhead for the browser, as well as making your code much more readable. + * + * Finally, you also have the ability to pass in an object of feature names and + * their tests. This is handy if you want to add multiple detections in one go. + * The keys should always be a string, and the value can be either a boolean or + * function that returns a boolean. + * + * ```js + * var detects = { + * 'hasjquery': 'jQuery' in window, + * 'itstuesday': function() { + * var d = new Date(); + * return d.getDay() === 2; + * } + * } + * + * Modernizr.addTest(detects); + * ``` + * + * There is really no difference between the first methods and this one, it is + * just a convenience to let you write more readable code. + */ + + function addTest(feature, test) { + + if (typeof feature == 'object') { + for (var key in feature) { + if (hasOwnProp(feature, key)) { + addTest(key, feature[ key ]); + } + } + } else { + + feature = feature.toLowerCase(); + var featureNameSplit = feature.split('.'); + var last = Modernizr[featureNameSplit[0]]; + + // Again, we don't check for parent test existence. Get that right, though. + if (featureNameSplit.length == 2) { + last = last[featureNameSplit[1]]; + } + + if (typeof last != 'undefined') { + // we're going to quit if you're trying to overwrite an existing test + // if we were to allow it, we'd do this: + // var re = new RegExp("\\b(no-)?" + feature + "\\b"); + // docElement.className = docElement.className.replace( re, '' ); + // but, no rly, stuff 'em. + return Modernizr; + } + + test = typeof test == 'function' ? test() : test; + + // Set the value (this is the magic, right here). + if (featureNameSplit.length == 1) { + Modernizr[featureNameSplit[0]] = test; + } else { + // cast to a Boolean, if not one already + /* jshint -W053 */ + if (Modernizr[featureNameSplit[0]] && !(Modernizr[featureNameSplit[0]] instanceof Boolean)) { + Modernizr[featureNameSplit[0]] = new Boolean(Modernizr[featureNameSplit[0]]); + } + + Modernizr[featureNameSplit[0]][featureNameSplit[1]] = test; + } + + // Set a single class (either `feature` or `no-feature`) + /* jshint -W041 */ + setClasses([(!!test && test != false ? '' : 'no-') + featureNameSplit.join('-')]); + /* jshint +W041 */ + + // Trigger the event + Modernizr._trigger(feature, test); + } + + return Modernizr; // allow chaining. + } + + // After all the tests are run, add self to the Modernizr prototype + Modernizr._q.push(function() { + ModernizrProto.addTest = addTest; + }); + + + + + /** + * fnBind is a super small [bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind) polyfill. + * + * @access private + * @function fnBind + * @param {function} fn - a function you want to change `this` reference to + * @param {object} that - the `this` you want to call the function with + * @returns {function} The wrapped version of the supplied function + */ + + function fnBind(fn, that) { + return function() { + return fn.apply(that, arguments); + }; + } + + ; + +/** + * @optionName html5printshiv + * @optionProp html5printshiv + */ + + // Take the html5 variable out of the html5shiv scope so we can return it. + var html5; + if (!isSVG) { + + /** + * @preserve HTML5 Shiv 3.7.3 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed + */ + ;(function(window, document) { + /*jshint evil:true */ + /** version */ + var version = '3.7.3'; + + /** Preset options */ + var options = window.html5 || {}; + + /** Used to skip problem elements */ + var reSkip = /^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i; + + /** Not all elements can be cloned in IE **/ + 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; + + /** Detect whether the browser supports default html5 styles */ + var supportsHtml5Styles; + + /** Name of the expando, to work with multiple documents or to re-shiv one document */ + var expando = '_html5shiv'; + + /** The id for the the documents expando */ + var expanID = 0; + + /** Cached data for each document */ + var expandoData = {}; + + /** Detect whether the browser supports unknown elements */ + var supportsUnknownElements; + + (function() { + try { + var a = document.createElement('a'); + a.innerHTML = ''; + //if the hidden property is implemented we can assume, that the browser supports basic HTML5 Styles + supportsHtml5Styles = ('hidden' in a); + + supportsUnknownElements = a.childNodes.length == 1 || (function() { + // assign a false positive if unable to shiv + (document.createElement)('a'); + var frag = document.createDocumentFragment(); + return ( + typeof frag.cloneNode == 'undefined' || + typeof frag.createDocumentFragment == 'undefined' || + typeof frag.createElement == 'undefined' + ); + }()); + } catch(e) { + // assign a false positive if detection fails => unable to shiv + supportsHtml5Styles = true; + supportsUnknownElements = true; + } + + }()); + + /*--------------------------------------------------------------------------*/ + + /** + * Creates a style sheet with the given CSS text and adds it to the document. + * @private + * @param {Document} ownerDocument The document. + * @param {String} cssText The CSS text. + * @returns {StyleSheet} The style element. + */ + function addStyleSheet(ownerDocument, cssText) { + var p = ownerDocument.createElement('p'), + parent = ownerDocument.getElementsByTagName('head')[0] || ownerDocument.documentElement; + + p.innerHTML = 'x'; + return parent.insertBefore(p.lastChild, parent.firstChild); + } + + /** + * Returns the value of `html5.elements` as an array. + * @private + * @returns {Array} An array of shived element node names. + */ + function getElements() { + var elements = html5.elements; + return typeof elements == 'string' ? elements.split(' ') : elements; + } + + /** + * Extends the built-in list of html5 elements + * @memberOf html5 + * @param {String|Array} newElements whitespace separated list or array of new element names to shiv + * @param {Document} ownerDocument The context document. + */ + function addElements(newElements, ownerDocument) { + var elements = html5.elements; + if(typeof elements != 'string'){ + elements = elements.join(' '); + } + if(typeof newElements != 'string'){ + newElements = newElements.join(' '); + } + html5.elements = elements +' '+ newElements; + shivDocument(ownerDocument); + } + + /** + * Returns the data associated to the given document + * @private + * @param {Document} ownerDocument The document. + * @returns {Object} An object of data. + */ + function getExpandoData(ownerDocument) { + var data = expandoData[ownerDocument[expando]]; + if (!data) { + data = {}; + expanID++; + ownerDocument[expando] = expanID; + expandoData[expanID] = data; + } + return data; + } + + /** + * returns a shived element for the given nodeName and document + * @memberOf html5 + * @param {String} nodeName name of the element + * @param {Document} ownerDocument The context document. + * @returns {Object} The shived element. + */ + function createElement(nodeName, ownerDocument, data){ + if (!ownerDocument) { + ownerDocument = document; + } + if(supportsUnknownElements){ + return ownerDocument.createElement(nodeName); + } + if (!data) { + data = getExpandoData(ownerDocument); + } + var node; + + if (data.cache[nodeName]) { + node = data.cache[nodeName].cloneNode(); + } else if (saveClones.test(nodeName)) { + node = (data.cache[nodeName] = data.createElem(nodeName)).cloneNode(); + } else { + node = data.createElem(nodeName); + } + + // Avoid adding some elements to fragments in IE < 9 because + // * Attributes like `name` or `type` cannot be set/changed once an element + // is inserted into a document/fragment + // * Link elements with `src` attributes that are inaccessible, as with + // a 403 response, will cause the tab/window to crash + // * Script elements appended to fragments will execute when their `src` + // or `text` property is set + return node.canHaveChildren && !reSkip.test(nodeName) && !node.tagUrn ? data.frag.appendChild(node) : node; + } + + /** + * returns a shived DocumentFragment for the given document + * @memberOf html5 + * @param {Document} ownerDocument The context document. + * @returns {Object} The shived DocumentFragment. + */ + function createDocumentFragment(ownerDocument, data){ + if (!ownerDocument) { + ownerDocument = document; + } + if(supportsUnknownElements){ + return ownerDocument.createDocumentFragment(); + } + data = data || getExpandoData(ownerDocument); + var clone = data.frag.cloneNode(), + i = 0, + elems = getElements(), + l = elems.length; + for(;i+~])(' + getElements().join('|') + ')(?=[[\\s,>+~#.:]|$)', 'gi'), + replacement = '$1' + shivNamespace + '\\:$2'; + + while (index--) { + pair = parts[index] = parts[index].split('}'); + pair[pair.length - 1] = pair[pair.length - 1].replace(reElements, replacement); + parts[index] = pair.join('}'); + } + return parts.join('{'); + } + + /** + * Removes the given wrappers, leaving the original elements. + * @private + * @params {Array} wrappers An array of printable wrappers. + */ + function removeWrappers(wrappers) { + var index = wrappers.length; + while (index--) { + wrappers[index].removeNode(); + } + } + + /*--------------------------------------------------------------------------*/ + + /** + * Shivs the given document for print. + * @memberOf html5 + * @param {Document} ownerDocument The document to shiv. + * @returns {Document} The shived document. + */ + function shivPrint(ownerDocument) { + var shivedSheet, + wrappers, + data = getExpandoData(ownerDocument), + namespaces = ownerDocument.namespaces, + ownerWindow = ownerDocument.parentWindow; + + if (!supportsShivableSheets || ownerDocument.printShived) { + return ownerDocument; + } + if (typeof namespaces[shivNamespace] == 'undefined') { + namespaces.add(shivNamespace); + } + + function removeSheet() { + clearTimeout(data._removeSheetTimer); + if (shivedSheet) { + shivedSheet.removeNode(true); + } + shivedSheet= null; + } + + ownerWindow.attachEvent('onbeforeprint', function() { + + removeSheet(); + + var imports, + length, + sheet, + collection = ownerDocument.styleSheets, + cssText = [], + index = collection.length, + sheets = Array(index); + + // convert styleSheets collection to an array + while (index--) { + sheets[index] = collection[index]; + } + // concat all style sheet CSS text + while ((sheet = sheets.pop())) { + // IE does not enforce a same origin policy for external style sheets... + // but has trouble with some dynamically created stylesheets + if (!sheet.disabled && reMedia.test(sheet.media)) { + + try { + imports = sheet.imports; + length = imports.length; + } catch(er){ + length = 0; + } + + for (index = 0; index < length; index++) { + sheets.push(imports[index]); + } + + try { + cssText.push(sheet.cssText); + } catch(er){} + } + } + + // wrap all HTML5 elements with printable elements and add the shived style sheet + cssText = shivCssText(cssText.reverse().join('')); + wrappers = addWrappers(ownerDocument); + shivedSheet = addStyleSheet(ownerDocument, cssText); + + }); + + ownerWindow.attachEvent('onafterprint', function() { + // remove wrappers, leaving the original elements, and remove the shived style sheet + removeWrappers(wrappers); + clearTimeout(data._removeSheetTimer); + data._removeSheetTimer = setTimeout(removeSheet, 500); + }); + + ownerDocument.printShived = true; + return ownerDocument; + } + + /*--------------------------------------------------------------------------*/ + + // expose API + html5.type += ' print'; + html5.shivPrint = shivPrint; + + // shiv for print + shivPrint(document); + + if(typeof module == 'object' && module.exports){ + module.exports = html5; + } + + }(typeof window !== "undefined" ? window : this, document)); + } + + ; + + + /** + * contains checks to see if a string contains another string + * + * @access private + * @function contains + * @param {string} str - The string we want to check for substrings + * @param {string} substr - The substring we want to search the first string for + * @returns {boolean} + */ + + function contains(str, substr) { + return !!~('' + str).indexOf(substr); + } + + ; + + /** + * createElement is a convenience wrapper around document.createElement. Since we + * use createElement all over the place, this allows for (slightly) smaller code + * as well as abstracting away issues with creating elements in contexts other than + * HTML documents (e.g. SVG documents). + * + * @access private + * @function createElement + * @returns {HTMLElement|SVGElement} An HTML or SVG element + */ + + function createElement() { + if (typeof document.createElement !== 'function') { + // This is the case in IE7, where the type of createElement is "object". + // For this reason, we cannot call apply() as Object is not a Function. + return document.createElement(arguments[0]); + } else if (isSVG) { + return document.createElementNS.call(document, 'http://www.w3.org/2000/svg', arguments[0]); + } else { + return document.createElement.apply(document, arguments); + } + } + + ; + + /** + * Create our "modernizr" element that we do most feature tests on. + * + * @access private + */ + + var modElem = { + elem: createElement('modernizr') + }; + + // Clean up this element + Modernizr._q.push(function() { + delete modElem.elem; + }); + + + + var mStyle = { + style: modElem.elem.style + }; + + // kill ref for gc, must happen before mod.elem is removed, so we unshift on to + // the front of the queue. + Modernizr._q.unshift(function() { + delete mStyle.style; + }); + + + + /** + * getBody returns the body of a document, or an element that can stand in for + * the body if a real body does not exist + * + * @access private + * @function getBody + * @returns {HTMLElement|SVGElement} Returns the real body of a document, or an + * artificially created element that stands in for the body + */ + + function getBody() { + // After page load injecting a fake body doesn't work so check if body exists + var body = document.body; + + if (!body) { + // Can't use the real body create a fake one. + body = createElement(isSVG ? 'svg' : 'body'); + body.fake = true; + } + + return body; + } + + ; + + /** + * injectElementWithStyles injects an element with style element and some CSS rules + * + * @access private + * @function injectElementWithStyles + * @param {string} rule - String representing a css rule + * @param {function} callback - A function that is used to test the injected element + * @param {number} [nodes] - An integer representing the number of additional nodes you want injected + * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes + * @returns {boolean} + */ + + function injectElementWithStyles(rule, callback, nodes, testnames) { + var mod = 'modernizr'; + var style; + var ret; + var node; + var docOverflow; + var div = createElement('div'); + var body = getBody(); + + if (parseInt(nodes, 10)) { + // In order not to give false positives we create a node for each test + // This also allows the method to scale for unspecified uses + while (nodes--) { + node = createElement('div'); + node.id = testnames ? testnames[nodes] : mod + (nodes + 1); + div.appendChild(node); + } + } + + style = createElement('style'); + style.type = 'text/css'; + style.id = 's' + mod; + + // 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. + // Opera will act all quirky when injecting elements in documentElement when page is served as xml, needs fakebody too. #270 + (!body.fake ? div : body).appendChild(style); + body.appendChild(div); + + if (style.styleSheet) { + style.styleSheet.cssText = rule; + } else { + style.appendChild(document.createTextNode(rule)); + } + div.id = mod; + + if (body.fake) { + //avoid crashing IE8, if background image is used + body.style.background = ''; + //Safari 5.13/5.1.4 OSX stops loading if ::-webkit-scrollbar is used and scrollbars are visible + body.style.overflow = 'hidden'; + docOverflow = docElement.style.overflow; + docElement.style.overflow = 'hidden'; + docElement.appendChild(body); + } + + ret = callback(div, rule); + // If this is done after page load we don't want to remove the body so check if body exists + if (body.fake) { + body.parentNode.removeChild(body); + docElement.style.overflow = docOverflow; + // Trigger layout so kinetic scrolling isn't disabled in iOS6+ + docElement.offsetHeight; + } else { + div.parentNode.removeChild(div); + } + + return !!ret; + + } + + ; + + /** + * domToCSS takes a camelCase string and converts it to kebab-case + * e.g. boxSizing -> box-sizing + * + * @access private + * @function domToCSS + * @param {string} name - String name of camelCase prop we want to convert + * @returns {string} The kebab-case version of the supplied name + */ + + function domToCSS(name) { + return name.replace(/([A-Z])/g, function(str, m1) { + return '-' + m1.toLowerCase(); + }).replace(/^ms-/, '-ms-'); + } + ; + + /** + * nativeTestProps allows for us to use native feature detection functionality if available. + * some prefixed form, or false, in the case of an unsupported rule + * + * @access private + * @function nativeTestProps + * @param {array} props - An array of property names + * @param {string} value - A string representing the value we want to check via @supports + * @returns {boolean|undefined} A boolean when @supports exists, undefined otherwise + */ + + // Accepts a list of property names and a single value + // Returns `undefined` if native detection not available + function nativeTestProps(props, value) { + var i = props.length; + // Start with the JS API: http://www.w3.org/TR/css3-conditional/#the-css-interface + if ('CSS' in window && 'supports' in window.CSS) { + // Try every prefixed variant of the property + while (i--) { + if (window.CSS.supports(domToCSS(props[i]), value)) { + return true; + } + } + return false; + } + // Otherwise fall back to at-rule (for Opera 12.x) + else if ('CSSSupportsRule' in window) { + // Build a condition string for every prefixed variant + var conditionText = []; + while (i--) { + conditionText.push('(' + domToCSS(props[i]) + ':' + value + ')'); + } + conditionText = conditionText.join(' or '); + return injectElementWithStyles('@supports (' + conditionText + ') { #modernizr { position: absolute; } }', function(node) { + return getComputedStyle(node, null).position == 'absolute'; + }); + } + return undefined; + } + ; + + /** + * cssToDOM takes a kebab-case string and converts it to camelCase + * e.g. box-sizing -> boxSizing + * + * @access private + * @function cssToDOM + * @param {string} name - String name of kebab-case prop we want to convert + * @returns {string} The camelCase version of the supplied name + */ + + function cssToDOM(name) { + return name.replace(/([a-z])-([a-z])/g, function(str, m1, m2) { + return m1 + m2.toUpperCase(); + }).replace(/^-/, ''); + } + ; + + // testProps is a generic CSS / DOM property test. + + // In testing support for a given CSS property, it's legit to test: + // `elem.style[styleName] !== undefined` + // If the property is supported it will return an empty string, + // if unsupported it will return undefined. + + // We'll take advantage of this quick test and skip setting a style + // on our modernizr element, but instead just testing undefined vs + // empty string. + + // Property names can be provided in either camelCase or kebab-case. + + function testProps(props, prefixed, value, skipValueTest) { + skipValueTest = is(skipValueTest, 'undefined') ? false : skipValueTest; + + // Try native detect first + if (!is(value, 'undefined')) { + var result = nativeTestProps(props, value); + if (!is(result, 'undefined')) { + return result; + } + } + + // Otherwise do it properly + var afterInit, i, propsLength, prop, before; + + // If we don't have a style element, that means we're running async or after + // the core tests, so we'll need to create our own elements to use + + // inside of an SVG element, in certain browsers, the `style` element is only + // defined for valid tags. Therefore, if `modernizr` does not have one, we + // fall back to a less used element and hope for the best. + var elems = ['modernizr', 'tspan']; + while (!mStyle.style) { + afterInit = true; + mStyle.modElem = createElement(elems.shift()); + mStyle.style = mStyle.modElem.style; + } + + // Delete the objects if we created them. + function cleanElems() { + if (afterInit) { + delete mStyle.style; + delete mStyle.modElem; + } + } + + propsLength = props.length; + for (i = 0; i < propsLength; i++) { + prop = props[i]; + before = mStyle.style[prop]; + + if (contains(prop, '-')) { + prop = cssToDOM(prop); + } + + if (mStyle.style[prop] !== undefined) { + + // If value to test has been passed in, do a set-and-check test. + // 0 (integer) is a valid property value, so check that `value` isn't + // undefined, rather than just checking it's truthy. + if (!skipValueTest && !is(value, 'undefined')) { + + // Needs a try catch block because of old IE. This is slow, but will + // be avoided in most cases because `skipValueTest` will be used. + try { + mStyle.style[prop] = value; + } catch (e) {} + + // If the property value has changed, we assume the value used is + // supported. If `value` is empty string, it'll fail here (because + // it hasn't changed), which matches how browsers have implemented + // CSS.supports() + if (mStyle.style[prop] != before) { + cleanElems(); + return prefixed == 'pfx' ? prop : true; + } + } + // Otherwise just return true, or the property name if this is a + // `prefixed()` call + else { + cleanElems(); + return prefixed == 'pfx' ? prop : true; + } + } + } + cleanElems(); + return false; + } + + ; + + /** + * testProp() investigates whether a given style property is recognized + * Property names can be provided in either camelCase or kebab-case. + * + * @memberof Modernizr + * @name Modernizr.testProp + * @access public + * @optionName Modernizr.testProp() + * @optionProp testProp + * @function testProp + * @param {string} prop - Name of the CSS property to check + * @param {string} [value] - Name of the CSS value to check + * @param {boolean} [useValue] - Whether or not to check the value if @supports isn't supported + * @returns {boolean} + * @example + * + * Just like [testAllProps](#modernizr-testallprops), only it does not check any vendor prefixed + * version of the string. + * + * Note that the property name must be provided in camelCase (e.g. boxSizing not box-sizing) + * + * ```js + * Modernizr.testProp('pointerEvents') // true + * ``` + * + * You can also provide a value as an optional second argument to check if a + * specific value is supported + * + * ```js + * Modernizr.testProp('pointerEvents', 'none') // true + * Modernizr.testProp('pointerEvents', 'penguin') // false + * ``` + */ + + var testProp = ModernizrProto.testProp = function(prop, value, useValue) { + return testProps([prop], undefined, value, useValue); + }; + + + /** + * testStyles injects an element with style element and some CSS rules + * + * @memberof Modernizr + * @name Modernizr.testStyles + * @optionName Modernizr.testStyles() + * @optionProp testStyles + * @access public + * @function testStyles + * @param {string} rule - String representing a css rule + * @param {function} callback - A function that is used to test the injected element + * @param {number} [nodes] - An integer representing the number of additional nodes you want injected + * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes + * @returns {boolean} + * @example + * + * `Modernizr.testStyles` takes a CSS rule and injects it onto the current page + * along with (possibly multiple) DOM elements. This lets you check for features + * that can not be detected by simply checking the [IDL](https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Interface_development_guide/IDL_interface_rules). + * + * ```js + * Modernizr.testStyles('#modernizr { width: 9px; color: papayawhip; }', function(elem, rule) { + * // elem is the first DOM node in the page (by default #modernizr) + * // rule is the first argument you supplied - the CSS rule in string form + * + * addTest('widthworks', elem.style.width === '9px') + * }); + * ``` + * + * If your test requires multiple nodes, you can include a third argument + * indicating how many additional div elements to include on the page. The + * additional nodes are injected as children of the `elem` that is returned as + * the first argument to the callback. + * + * ```js + * Modernizr.testStyles('#modernizr {width: 1px}; #modernizr2 {width: 2px}', function(elem) { + * document.getElementById('modernizr').style.width === '1px'; // true + * document.getElementById('modernizr2').style.width === '2px'; // true + * elem.firstChild === document.getElementById('modernizr2'); // true + * }, 1); + * ``` + * + * By default, all of the additional elements have an ID of `modernizr[n]`, where + * `n` is its index (e.g. the first additional, second overall is `#modernizr2`, + * the second additional is `#modernizr3`, etc.). + * If you want to have more meaningful IDs for your function, you can provide + * them as the fourth argument, as an array of strings + * + * ```js + * Modernizr.testStyles('#foo {width: 10px}; #bar {height: 20px}', function(elem) { + * elem.firstChild === document.getElementById('foo'); // true + * elem.lastChild === document.getElementById('bar'); // true + * }, 2, ['foo', 'bar']); + * ``` + * + */ + + var testStyles = ModernizrProto.testStyles = injectElementWithStyles; + +/*! +{ + "name": "@font-face", + "property": "fontface", + "authors": ["Diego Perini", "Mat Marquis"], + "tags": ["css"], + "knownBugs": [ + "False Positive: WebOS https://github.com/Modernizr/Modernizr/issues/342", + "False Postive: WP7 https://github.com/Modernizr/Modernizr/issues/538" + ], + "notes": [{ + "name": "@font-face detection routine by Diego Perini", + "href": "http://javascript.nwbox.com/CSSSupport/" + },{ + "name": "Filament Group @font-face compatibility research", + "href": "https://docs.google.com/presentation/d/1n4NyG4uPRjAA8zn_pSQ_Ket0RhcWC6QlZ6LMjKeECo0/edit#slide=id.p" + },{ + "name": "Filament Grunticon/@font-face device testing results", + "href": "https://docs.google.com/spreadsheet/ccc?key=0Ag5_yGvxpINRdHFYeUJPNnZMWUZKR2ItMEpRTXZPdUE#gid=0" + },{ + "name": "CSS fonts on Android", + "href": "https://stackoverflow.com/questions/3200069/css-fonts-on-android" + },{ + "name": "@font-face and Android", + "href": "http://archivist.incutio.com/viewlist/css-discuss/115960" + }] +} +!*/ + + var blacklist = (function() { + var ua = navigator.userAgent; + var wkvers = ua.match(/applewebkit\/([0-9]+)/gi) && parseFloat(RegExp.$1); + var webos = ua.match(/w(eb)?osbrowser/gi); + var wppre8 = ua.match(/windows phone/gi) && ua.match(/iemobile\/([0-9])+/gi) && parseFloat(RegExp.$1) >= 9; + var oldandroid = wkvers < 533 && ua.match(/android/gi); + return webos || oldandroid || wppre8; + }()); + if (blacklist) { + Modernizr.addTest('fontface', false); + } else { + testStyles('@font-face {font-family:"font";src:url("https://")}', function(node, rule) { + var style = document.getElementById('smodernizr'); + var sheet = style.sheet || style.styleSheet; + var cssText = sheet ? (sheet.cssRules && sheet.cssRules[0] ? sheet.cssRules[0].cssText : sheet.cssText || '') : ''; + var bool = /src/i.test(cssText) && cssText.indexOf(rule.split(' ')[0]) === 0; + Modernizr.addTest('fontface', bool); + }); + } +; + + /** + * If the browsers follow the spec, then they would expose vendor-specific style as: + * elem.style.WebkitBorderRadius + * instead of something like the following, which would be technically incorrect: + * elem.style.webkitBorderRadius + + * Webkit ghosts their properties in lowercase but Opera & Moz do not. + * Microsoft uses a lowercase `ms` instead of the correct `Ms` in IE8+ + * erik.eae.net/archives/2008/03/10/21.48.10/ + + * More here: github.com/Modernizr/Modernizr/issues/issue/21 + * + * @access private + * @returns {string} The string representing the vendor-specific style properties + */ + + var omPrefixes = 'Moz O ms Webkit'; + + + var cssomPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.split(' ') : []); + ModernizrProto._cssomPrefixes = cssomPrefixes; + + + /** + * List of JavaScript DOM values used for tests + * + * @memberof Modernizr + * @name Modernizr._domPrefixes + * @optionName Modernizr._domPrefixes + * @optionProp domPrefixes + * @access public + * @example + * + * Modernizr._domPrefixes is exactly the same as [_prefixes](#modernizr-_prefixes), but rather + * than kebab-case properties, all properties are their Capitalized variant + * + * ```js + * Modernizr._domPrefixes === [ "Moz", "O", "ms", "Webkit" ]; + * ``` + */ + + var domPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.toLowerCase().split(' ') : []); + ModernizrProto._domPrefixes = domPrefixes; + + + /** + * testDOMProps is a generic DOM property test; if a browser supports + * a certain property, it won't return undefined for it. + * + * @access private + * @function testDOMProps + * @param {array.} props - An array of properties to test for + * @param {object} obj - An object or Element you want to use to test the parameters again + * @param {boolean|object} elem - An Element to bind the property lookup again. Use `false` to prevent the check + */ + function testDOMProps(props, obj, elem) { + var item; + + for (var i in props) { + if (props[i] in obj) { + + // return the property name as a string + if (elem === false) { + return props[i]; + } + + item = obj[props[i]]; + + // let's bind a function + if (is(item, 'function')) { + // bind to obj unless overriden + return fnBind(item, elem || obj); + } + + // return the unbound function or obj or value + return item; + } + } + return false; + } + + ; + + /** + * testPropsAll tests a list of DOM properties we want to check against. + * We specify literally ALL possible (known and/or likely) properties on + * the element including the non-vendor prefixed one, for forward- + * compatibility. + * + * @access private + * @function testPropsAll + * @param {string} prop - A string of the property to test for + * @param {string|object} [prefixed] - An object to check the prefixed properties on. Use a string to skip + * @param {HTMLElement|SVGElement} [elem] - An element used to test the property and value against + * @param {string} [value] - A string of a css value + * @param {boolean} [skipValueTest] - An boolean representing if you want to test if value sticks when set + */ + function testPropsAll(prop, prefixed, elem, value, skipValueTest) { + + var ucProp = prop.charAt(0).toUpperCase() + prop.slice(1), + props = (prop + ' ' + cssomPrefixes.join(ucProp + ' ') + ucProp).split(' '); + + // did they call .prefixed('boxSizing') or are we just testing a prop? + if (is(prefixed, 'string') || is(prefixed, 'undefined')) { + return testProps(props, prefixed, value, skipValueTest); + + // otherwise, they called .prefixed('requestAnimationFrame', window[, elem]) + } else { + props = (prop + ' ' + (domPrefixes).join(ucProp + ' ') + ucProp).split(' '); + return testDOMProps(props, prefixed, elem); + } + } + + // Modernizr.testAllProps() investigates whether a given style property, + // or any of its vendor-prefixed variants, is recognized + // + // Note that the property names must be provided in the camelCase variant. + // Modernizr.testAllProps('boxSizing') + ModernizrProto.testAllProps = testPropsAll; + + + + /** + * testAllProps determines whether a given CSS property is supported in the browser + * + * @memberof Modernizr + * @name Modernizr.testAllProps + * @optionName Modernizr.testAllProps() + * @optionProp testAllProps + * @access public + * @function testAllProps + * @param {string} prop - String naming the property to test (either camelCase or kebab-case) + * @param {string} [value] - String of the value to test + * @param {boolean} [skipValueTest=false] - Whether to skip testing that the value is supported when using non-native detection + * @example + * + * testAllProps determines whether a given CSS property, in some prefixed form, + * is supported by the browser. + * + * ```js + * testAllProps('boxSizing') // true + * ``` + * + * It can optionally be given a CSS value in string form to test if a property + * value is valid + * + * ```js + * testAllProps('display', 'block') // true + * testAllProps('display', 'penguin') // false + * ``` + * + * A boolean can be passed as a third parameter to skip the value check when + * native detection (@supports) isn't available. + * + * ```js + * testAllProps('shapeOutside', 'content-box', true); + * ``` + */ + + function testAllProps(prop, value, skipValueTest) { + return testPropsAll(prop, undefined, undefined, value, skipValueTest); + } + ModernizrProto.testAllProps = testAllProps; + +/*! +{ + "name": "CSS Supports", + "property": "supports", + "caniuse": "css-featurequeries", + "tags": ["css"], + "builderAliases": ["css_supports"], + "notes": [{ + "name": "W3 Spec", + "href": "http://dev.w3.org/csswg/css3-conditional/#at-supports" + },{ + "name": "Related Github Issue", + "href": "github.com/Modernizr/Modernizr/issues/648" + },{ + "name": "W3 Info", + "href": "http://dev.w3.org/csswg/css3-conditional/#the-csssupportsrule-interface" + }] +} +!*/ + + var newSyntax = 'CSS' in window && 'supports' in window.CSS; + var oldSyntax = 'supportsCSS' in window; + Modernizr.addTest('supports', newSyntax || oldSyntax); + +/*! +{ + "name": "CSS Transforms 3D", + "property": "csstransforms3d", + "caniuse": "transforms3d", + "tags": ["css"], + "warnings": [ + "Chrome may occassionally fail this test on some systems; more info: https://code.google.com/p/chromium/issues/detail?id=129004" + ] +} +!*/ + + Modernizr.addTest('csstransforms3d', function() { + var ret = !!testAllProps('perspective', '1px', true); + var usePrefix = Modernizr._config.usePrefixes; + + // Webkit's 3D transforms are passed off to the browser's own graphics renderer. + // It works fine in Safari on Leopard and Snow Leopard, but not in Chrome in + // some conditions. As a result, Webkit typically recognizes the syntax but + // will sometimes throw a false positive, thus we must do a more thorough check: + if (ret && (!usePrefix || 'webkitPerspective' in docElement.style)) { + var mq; + var defaultStyle = '#modernizr{width:0;height:0}'; + // Use CSS Conditional Rules if available + if (Modernizr.supports) { + mq = '@supports (perspective: 1px)'; + } else { + // Otherwise, Webkit allows this media query to succeed only if the feature is enabled. + // `@media (transform-3d),(-webkit-transform-3d){ ... }` + mq = '@media (transform-3d)'; + if (usePrefix) { + mq += ',(-webkit-transform-3d)'; + } + } + + mq += '{#modernizr{width:7px;height:18px;margin:0;padding:0;border:0}}'; + + testStyles(defaultStyle + mq, function(elem) { + ret = elem.offsetWidth === 7 && elem.offsetHeight === 18; + }); + } + + return ret; + }); + +/*! +{ + "name": "CSS :target pseudo-class", + "caniuse": "css-sel3", + "property": "target", + "tags": ["css"], + "notes": [{ + "name": "MDN documentation", + "href": "https://developer.mozilla.org/en-US/docs/Web/CSS/:target" + }], + "authors": ["@zachleat"], + "warnings": ["Opera Mini supports :target but doesn't update the hash for anchor links."] +} +!*/ +/* DOC +Detects support for the ':target' CSS pseudo-class. +*/ + + // querySelector + Modernizr.addTest('target', function() { + var doc = window.document; + if (!('querySelectorAll' in doc)) { + return false; + } + + try { + doc.querySelectorAll(':target'); + return true; + } catch (e) { + return false; + } + }); + +/*! +{ + "name": "ES5 String.prototype.contains", + "property": "contains", + "authors": ["Robert Kowalski"], + "tags": ["es6"] +} +!*/ +/* DOC +Check if browser implements ECMAScript 6 `String.prototype.contains` per specification. +*/ + + Modernizr.addTest('contains', is(String.prototype.contains, 'function')); + + + // Run each test + testRunner(); + + // Remove the "no-js" class if it exists + setClasses(classes); + + delete ModernizrProto.addTest; + delete ModernizrProto.addAsyncTest; + + // Run the things that are supposed to run after the tests + for (var i = 0; i < Modernizr._q.length; i++) { + Modernizr._q[i](); + } + + // Leak Modernizr namespace + window.Modernizr = Modernizr; + + +; + +})(window, document); \ No newline at end of file diff --git a/material/assets/javascripts/modernizr-d1e05123d4.js b/material/assets/javascripts/modernizr-d1e05123d4.js deleted file mode 100644 index d7330594b..000000000 --- a/material/assets/javascripts/modernizr-d1e05123d4.js +++ /dev/null @@ -1 +0,0 @@ -!function(e,t,n){function r(e,t){return typeof e===t}function o(){var e,t,n,o,i,a,s;for(var l in E)if(E.hasOwnProperty(l)){if(e=[],t=E[l],t.name&&(e.push(t.name.toLowerCase()),t.options&&t.options.aliases&&t.options.aliases.length))for(n=0;nu;u++)if(h=e[u],g=N.style[h],l(h,"-")&&(h=m(h)),N.style[h]!==n){if(i||r(o,"undefined"))return a(),"pfx"==t?h:!0;try{N.style[h]=o}catch(y){}if(N.style[h]!=g)return a(),"pfx"==t?h:!0}return a(),!1}function g(e,t,n){var o;for(var i in e)if(e[i]in t)return n===!1?e[i]:(o=t[e[i]],r(o,"function")?s(o,n||t):o);return!1}function v(e,t,n,o,i){var a=e.charAt(0).toUpperCase()+e.slice(1),s=(e+" "+z.join(a+" ")+a).split(" ");return r(t,"string")||r(t,"undefined")?h(s,t,o,i):(s=(e+" "+F.join(a+" ")+a).split(" "),g(s,t,n))}function y(e,t,r){return v(e,n,n,t,r)}var E=[],S={_version:"3.3.1",_config:{classPrefix:"",enableClasses:!0,enableJSClass:!0,usePrefixes:!0},_q:[],on:function(e,t){var n=this;setTimeout(function(){t(n[e])},0)},addTest:function(e,t,n){E.push({name:e,fn:t,options:n})},addAsyncTest:function(e){E.push({name:null,fn:e})}},b=function(){};b.prototype=S,b=new b;var w,C=[],x=t.documentElement,T="svg"===x.nodeName.toLowerCase();!function(){var e={}.hasOwnProperty;w=r(e,"undefined")||r(e.call,"undefined")?function(e,t){return t in e&&r(e.constructor.prototype[t],"undefined")}:function(t,n){return e.call(t,n)}}(),S._l={},S.on=function(e,t){this._l[e]||(this._l[e]=[]),this._l[e].push(t),b.hasOwnProperty(e)&&setTimeout(function(){b._trigger(e,b[e])},0)},S._trigger=function(e,t){if(this._l[e]){var n=this._l[e];setTimeout(function(){var e,r;for(e=0;e",r.insertBefore(n.lastChild,r.firstChild)}function r(){var e=x.elements;return"string"==typeof e?e.split(" "):e}function o(e,t){var n=x.elements;"string"!=typeof n&&(n=n.join(" ")),"string"!=typeof e&&(e=e.join(" ")),x.elements=n+" "+e,c(t)}function i(e){var t=C[e[b]];return t||(t={},w++,e[b]=w,C[w]=t),t}function a(e,n,r){if(n||(n=t),g)return n.createElement(e);r||(r=i(n));var o;return o=r.cache[e]?r.cache[e].cloneNode():S.test(e)?(r.cache[e]=r.createElem(e)).cloneNode():r.createElem(e),!o.canHaveChildren||E.test(e)||o.tagUrn?o:r.frag.appendChild(o)}function s(e,n){if(e||(e=t),g)return e.createDocumentFragment();n=n||i(e);for(var o=n.frag.cloneNode(),a=0,s=r(),l=s.length;l>a;a++)o.createElement(s[a]);return o}function l(e,t){t.cache||(t.cache={},t.createElem=e.createElement,t.createFrag=e.createDocumentFragment,t.frag=t.createFrag()),e.createElement=function(n){return x.shivMethods?a(n,e,t):t.createElem(n)},e.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+r().join().replace(/[\w\-:]+/g,function(e){return t.createElem(e),t.frag.createElement(e),'c("'+e+'")'})+");return n}")(x,t.frag)}function c(e){e||(e=t);var r=i(e);return!x.shivCSS||h||r.hasCSS||(r.hasCSS=!!n(e,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),g||l(e,r),e}function f(e){for(var t,n=e.getElementsByTagName("*"),o=n.length,i=RegExp("^(?:"+r().join("|")+")$","i"),a=[];o--;)t=n[o],i.test(t.nodeName)&&a.push(t.applyElement(u(t)));return a}function u(e){for(var t,n=e.attributes,r=n.length,o=e.ownerDocument.createElement(_+":"+e.nodeName);r--;)t=n[r],t.specified&&o.setAttribute(t.nodeName,t.nodeValue);return o.style.cssText=e.style.cssText,o}function d(e){for(var t,n=e.split("{"),o=n.length,i=RegExp("(^|[\\s,>+~])("+r().join("|")+")(?=[[\\s,>+~#.:]|$)","gi"),a="$1"+_+"\\:$2";o--;)t=n[o]=n[o].split("}"),t[t.length-1]=t[t.length-1].replace(i,a),n[o]=t.join("}");return n.join("{")}function p(e){for(var t=e.length;t--;)e[t].removeNode()}function m(e){function t(){clearTimeout(a._removeSheetTimer),r&&r.removeNode(!0),r=null}var r,o,a=i(e),s=e.namespaces,l=e.parentWindow;return!N||e.printShived?e:("undefined"==typeof s[_]&&s.add(_),l.attachEvent("onbeforeprint",function(){t();for(var i,a,s,l=e.styleSheets,c=[],u=l.length,p=Array(u);u--;)p[u]=l[u];for(;s=p.pop();)if(!s.disabled&&T.test(s.media)){try{i=s.imports,a=i.length}catch(m){a=0}for(u=0;a>u;u++)p.push(i[u]);try{c.push(s.cssText)}catch(m){}}c=d(c.reverse().join("")),o=f(e),r=n(e,c)}),l.attachEvent("onafterprint",function(){p(o),clearTimeout(a._removeSheetTimer),a._removeSheetTimer=setTimeout(t,500)}),e.printShived=!0,e)}var h,g,v="3.7.3",y=e.html5||{},E=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,S=/^(?: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,b="_html5shiv",w=0,C={};!function(){try{var e=t.createElement("a");e.innerHTML="",h="hidden"in e,g=1==e.childNodes.length||function(){t.createElement("a");var e=t.createDocumentFragment();return"undefined"==typeof e.cloneNode||"undefined"==typeof e.createDocumentFragment||"undefined"==typeof e.createElement}()}catch(n){h=!0,g=!0}}();var x={elements:y.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:v,shivCSS:y.shivCSS!==!1,supportsUnknownElements:g,shivMethods:y.shivMethods!==!1,type:"default",shivDocument:c,createElement:a,createDocumentFragment:s,addElements:o};e.html5=x,c(t);var T=/^$|\b(?:all|print)\b/,_="html5shiv",N=!g&&function(){var n=t.documentElement;return!("undefined"==typeof t.namespaces||"undefined"==typeof t.parentWindow||"undefined"==typeof n.applyElement||"undefined"==typeof n.removeNode||"undefined"==typeof e.attachEvent)}();x.type+=" print",x.shivPrint=m,m(t),"object"==typeof module&&module.exports&&(module.exports=x)}("undefined"!=typeof e?e:this,t);var _={elem:c("modernizr")};b._q.push(function(){delete _.elem});var N={style:_.elem.style};b._q.unshift(function(){delete N.style});var j=(S.testProp=function(e,t,r){return h([e],n,t,r)},S.testStyles=u),P=function(){var e=navigator.userAgent,t=e.match(/applewebkit\/([0-9]+)/gi)&&parseFloat(RegExp.$1),n=e.match(/w(eb)?osbrowser/gi),r=e.match(/windows phone/gi)&&e.match(/iemobile\/([0-9])+/gi)&&parseFloat(RegExp.$1)>=9,o=533>t&&e.match(/android/gi);return n||o||r}();P?b.addTest("fontface",!1):j('@font-face {font-family:"font";src:url("https://")}',function(e,n){var r=t.getElementById("smodernizr"),o=r.sheet||r.styleSheet,i=o?o.cssRules&&o.cssRules[0]?o.cssRules[0].cssText:o.cssText||"":"",a=/src/i.test(i)&&0===i.indexOf(n.split(" ")[0]);b.addTest("fontface",a)});var k="Moz O ms Webkit",z=S._config.usePrefixes?k.split(" "):[];S._cssomPrefixes=z;var F=S._config.usePrefixes?k.toLowerCase().split(" "):[];S._domPrefixes=F,S.testAllProps=v,S.testAllProps=y;var $="CSS"in e&&"supports"in e.CSS,A="supportsCSS"in e;b.addTest("supports",$||A),b.addTest("csstransforms3d",function(){var e=!!y("perspective","1px",!0),t=b._config.usePrefixes;if(e&&(!t||"webkitPerspective"in x.style)){var n,r="#modernizr{width:0;height:0}";b.supports?n="@supports (perspective: 1px)":(n="@media (transform-3d)",t&&(n+=",(-webkit-transform-3d)")),n+="{#modernizr{width:7px;height:18px;margin:0;padding:0;border:0}}",j(r+n,function(t){e=7===t.offsetWidth&&18===t.offsetHeight})}return e}),b.addTest("target",function(){var t=e.document;if(!("querySelectorAll"in t))return!1;try{return t.querySelectorAll(":target"),!0}catch(n){return!1}}),b.addTest("contains",r(String.prototype.contains,"function")),o(),i(C),delete S.addTest,delete S.addAsyncTest;for(var q=0;q - + {% for path in extra_css %} {% endfor %} - + diff --git a/material/header.html b/material/header.html index c3b0fe535..3eddad033 100644 --- a/material/header.html +++ b/material/header.html @@ -11,6 +11,10 @@
+
+ + +
diff --git a/material/manifest.json b/material/manifest.json index afc12c110..6b643ea4d 100644 --- a/material/manifest.json +++ b/material/manifest.json @@ -1,6 +1,6 @@ { "assets/images/favicon.ico": "assets/images/favicon-e565ddfa3b.ico", "assets/javascripts/application.js": "assets/javascripts/application-a7f7c32389.js", - "assets/javascripts/modernizr.js": "assets/javascripts/modernizr-d1e05123d4.js", - "assets/stylesheets/application.css": "assets/stylesheets/application-fe75383308.css" + "assets/javascripts/modernizr.js": "assets/javascripts/modernizr-30b4746408.js", + "assets/stylesheets/application.css": "assets/stylesheets/application-cbf902c7ca.css" } \ No newline at end of file diff --git a/src/assets/stylesheets/base/_typeset.scss b/src/assets/stylesheets/base/_typeset.scss index 454a620c2..b6692ea86 100644 --- a/src/assets/stylesheets/base/_typeset.scss +++ b/src/assets/stylesheets/base/_typeset.scss @@ -101,10 +101,10 @@ pre, code { * 2nd level headline */ h2 { + margin-top: 4.0rem; font-size: ms(2); font-weight: 300; line-height: 1.4; - margin-top: 4.0rem; letter-spacing: -.01em; /* @@ -122,10 +122,10 @@ pre, code { * 3rd level headline */ h3 { + margin-top: 3.2rem; font-size: ms(1); font-weight: 400; line-height: 1.5; - margin-top: 3.2rem; letter-spacing: -.01em; /* @@ -150,17 +150,15 @@ pre, code { * 4th, 5th and 6th level headline */ h4 { + margin-top: 1.6rem; font-size: ms(0); font-weight: 700; - margin-top: 1.6rem; letter-spacing: -.01em; /* * Correct anchor offset */ &:before { - position: relative; - z-index: -4; content: " "; display: block; padding-top: (5.6rem + 2.4rem + 0.8rem); @@ -172,9 +170,9 @@ pre, code { * 5th and 6th level headline */ h5, h6 { + margin-top: 1.6rem; font-size: ms(-1); font-weight: 700; - margin-top: 1.6rem; letter-spacing: -.01em; color: $md-color-black--light; @@ -182,8 +180,6 @@ pre, code { * Correct anchor offset */ &:before { - position: relative; - z-index: -5; content: " "; display: block; padding-top: (5.6rem + 2.4rem + 1.0rem); @@ -218,24 +214,24 @@ pre, code { * Inline code blocks */ code { + padding: 0.1rem 0.4rem; font-size: 85%; font-weight: 400; word-break: break-word; - padding: 0.1rem 0.4rem; - background: #f7f7f7; - color: #37474f; + background: #F7F7F7; + color: #37474F; } /* * Formatted code blocks */ pre { - font-size: 85%; - line-height: 1.4; padding: 1.0rem 1.2rem; overflow-x: scroll; - background: #f7f7f7; - color: #37474f; + font-size: 85%; + line-height: 1.4; + background: #F7F7F7; + color: #37474F; } /* @@ -243,13 +239,13 @@ pre, code { */ kbd { display: inline-block; + padding: 0.4rem 0.5rem 0.5rem; + vertical-align: 0.1rem; font-size: 85%; line-height: 1.0rem; word-break: break-word; - padding: 0.4rem 0.5rem 0.5rem; - vertical-align: 0.1rem; - color: #555; background-color: #FCFCFC; + color: #555555; border: px2rem(1px) solid #CCCCCC; border-bottom-color: #BBBBBB; border-radius: px2rem(3px); diff --git a/src/assets/stylesheets/extensions/_codehilite.scss b/src/assets/stylesheets/extensions/_codehilite.scss index 7a7bb7d3c..ac7c4654e 100644 --- a/src/assets/stylesheets/extensions/_codehilite.scss +++ b/src/assets/stylesheets/extensions/_codehilite.scss @@ -33,7 +33,7 @@ /* * Errors */ - .err { color: #a61717; } + .err { color: #A61717; } /* * Operators @@ -44,24 +44,24 @@ * Generics */ .ge { color: #000000; } /* Generic.Emph */ - .gr { color: #aa0000; } /* Generic.Error */ + .gr { color: #AA0000; } /* Generic.Error */ .gh { color: #999999; } /* Generic.Heading */ .go { color: #888888; } /* Generic.Output */ .gp { color: #555555; } /* Generic.Prompt */ .gs { color: inherit; } /* Generic.Strong */ - .gu { color: #aaaaaa; } /* Generic.Subheading */ - .gt { color: #aa0000; } /* Generic.Traceback */ + .gu { color: #AAAAAA; } /* Generic.Subheading */ + .gt { color: #AA0000; } /* Generic.Traceback */ /* * Keywords */ - .k { color: #a71d5d; } /* Keyword */ - .kc { color: #a71d5d; } /* Keyword.Constant */ - .kd { color: #a71d5d; } /* Keyword.Declaration */ - .kn { color: #a71d5d; } /* Keyword.Namespace */ - .kp { color: #a71d5d; } /* Keyword.Pseudo */ - .kr { color: #0086b3; } /* Keyword.Reserved */ - .kt { color: #0086b3; } /* Keyword.Type */ + .k { color: #A71D5D; } /* Keyword */ + .kc { color: #A71D5D; } /* Keyword.Constant */ + .kd { color: #A71D5D; } /* Keyword.Declaration */ + .kn { color: #A71D5D; } /* Keyword.Namespace */ + .kp { color: #A71D5D; } /* Keyword.Pseudo */ + .kr { color: #0086B3; } /* Keyword.Reserved */ + .kt { color: #0086B3; } /* Keyword.Type */ /* * Comments @@ -75,34 +75,34 @@ /* * Names */ - .na { color: #795da3; } /* Name.Attribute */ - .na { color: #795da3; } /* Name.Attribute */ - .nb { color: #795da3; } /* Name.Builtin */ - .bp { color: #795da3; } /* Name.Builtin.Pseudo */ - .nc { color: #795da3; } /* Name.Class */ - .no { color: #795da3; } /* Name.Constant */ - .nd { color: #795da3; } /* Name.Decorator */ - .ni { color: #795da3; } /* Name.Entity */ - .ne { color: #795da3; } /* Name.Exception */ - .nf { color: #795da3; } /* Name.Function */ - .nl { color: #795da3; } /* Name.Label */ - .nn { color: #795da3; } /* Name.Namespace */ - .nt { color: #795da3; } /* Name.Tag */ - .nv { color: #795da3; } /* Name.Variable */ - .vc { color: #795da3; } /* Name.Variable.Class */ - .vg { color: #795da3; } /* Name.Variable.Global */ - .vi { color: #795da3; } /* Name.Variable.Instance */ + .na { color: #795DA3; } /* Name.Attribute */ + .na { color: #795DA3; } /* Name.Attribute */ + .nb { color: #795DA3; } /* Name.Builtin */ + .bp { color: #795DA3; } /* Name.Builtin.Pseudo */ + .nc { color: #795DA3; } /* Name.Class */ + .no { color: #795DA3; } /* Name.Constant */ + .nd { color: #795DA3; } /* Name.Decorator */ + .ni { color: #795DA3; } /* Name.Entity */ + .ne { color: #795DA3; } /* Name.Exception */ + .nf { color: #795DA3; } /* Name.Function */ + .nl { color: #795DA3; } /* Name.Label */ + .nn { color: #795DA3; } /* Name.Namespace */ + .nt { color: #795DA3; } /* Name.Tag */ + .nv { color: #795DA3; } /* Name.Variable */ + .vc { color: #795DA3; } /* Name.Variable.Class */ + .vg { color: #795DA3; } /* Name.Variable.Global */ + .vi { color: #795DA3; } /* Name.Variable.Instance */ .ow { color: inherit; } /* Operator.Word */ /* * Numbers */ - .m { color: #0086b3; } /* Literal.Number */ - .mf { color: #0086b3; } /* Literal.Number.Float */ - .mh { color: #0086b3; } /* Literal.Number.Hex */ - .mi { color: #0086b3; } /* Literal.Number.Integer */ - .mo { color: #0086b3; } /* Literal.Number.Oct */ - .il { color: #0086b3; } /* Literal.Number.Integer.Long */ + .m { color: #0086B3; } /* Literal.Number */ + .mf { color: #0086B3; } /* Literal.Number.Float */ + .mh { color: #0086B3; } /* Literal.Number.Hex */ + .mi { color: #0086B3; } /* Literal.Number.Integer */ + .mo { color: #0086B3; } /* Literal.Number.Oct */ + .il { color: #0086B3; } /* Literal.Number.Integer.Long */ /* * Strings @@ -117,7 +117,7 @@ .si { color: #183691; } /* Literal.String.Interpol */ .sx { color: #183691; } /* Literal.String.Other */ .sr { color: #009926; } /* Literal.String.Regex */ - .s1 { color: #d01040; } /* Literal.String.Single */ + .s1 { color: #D01040; } /* Literal.String.Single */ .ss { color: #990073; } /* Literal.String.Symbol */ /* diff --git a/src/assets/stylesheets/extensions/_permalinks.scss b/src/assets/stylesheets/extensions/_permalinks.scss index f3c8caefd..a8437a2dd 100644 --- a/src/assets/stylesheets/extensions/_permalinks.scss +++ b/src/assets/stylesheets/extensions/_permalinks.scss @@ -44,7 +44,7 @@ } /* - * Only show permalinks in hover state + * Only show permalinks in active state */ h1, h2, h3, h4, h5, h6 { &:hover .headerlink { diff --git a/src/assets/stylesheets/layout/_header.scss b/src/assets/stylesheets/layout/_header.scss index 009fcad25..c09974011 100644 --- a/src/assets/stylesheets/layout/_header.scss +++ b/src/assets/stylesheets/layout/_header.scss @@ -63,6 +63,17 @@ &:active { background: $md-color-white--lightest; } + + /* [tablet portrait +]: Hide the search icon */ + @include break-from-device(tablet landscape) { + + /* + * Search icon + */ + &.md-icon--search { + display: none; + } + } } /* @@ -74,4 +85,67 @@ line-height: 4.8rem; } } + + /* + * Search bar within header + */ + &-search { + position: relative; + margin: 0.6rem 0.4rem 0.6rem 0; + + /* + * Icon + */ + &__icon { + position: absolute; + top: 0.6rem; + left: 1.2rem; + font-size: 2.4rem; + transition: color .25s; + cursor: pointer; + } + + /* + * Search field - the float is a hack for non-jittery transitions + */ + &__input { + width: 23.0rem; + height: 3.6rem; + padding-left: 4.4rem; + padding-right: 0.8rem; + float: right; + font-size: ms(0); + background: $md-color-primary--dark; + color: $md-color-white; + border-radius: px2rem(2px); + transition: color .25s, + background-color .25s, + width .25s cubic-bezier(0.1, 0.7, 0.1, 1); + + /* + * Placeholder color + */ + &::placeholder { + color: $md-color-white--light; + transition: color .25s; + } + + /* + * Active search field + */ + &:focus { + background: $md-color-white; + color: $md-color-black; + width: 40rem; + + /* + * Placeholder and icon color in active state + */ + + .md-header-search__icon, + &::placeholder { + color: $md-color-black--light; + } + } + } + } } \ No newline at end of file diff --git a/src/assets/stylesheets/layout/_search.scss b/src/assets/stylesheets/layout/_search.scss new file mode 100644 index 000000000..e69de29bb diff --git a/src/header.html b/src/header.html index f4a9ec52f..76119827e 100644 --- a/src/header.html +++ b/src/header.html @@ -44,6 +44,13 @@
+
+ + +