activationDistance || toast.velocityX > 1;
// Remove toast
if (shouldBeDismissed) {
toast.wasSwiped = true;
toast.dismiss();
// Animate toast back to original position
}
else {
toast.el.style.transition = 'transform .2s, opacity .2s';
toast.el.style.transform = '';
toast.el.style.opacity = '';
}
Toast._draggedToast = null;
}
}
static _xPos(e) {
if (e.type.startsWith("touch") && e.targetTouches.length >= 1) {
return e.targetTouches[0].clientX;
}
// mouse event
return e.clientX;
}
/**
* dismiss all toasts.
*/
static dismissAll() {
for (let toastIndex in Toast._toasts) {
Toast._toasts[toastIndex].dismiss();
}
}
_createToast() {
let toast = this.options.toastId
? document.getElementById(this.options.toastId)
: document.createElement('div');
if (toast instanceof HTMLTemplateElement) {
const node = toast.content.cloneNode(true);
toast = node.firstElementChild;
}
toast.classList.add('toast');
toast.setAttribute('role', 'alert');
toast.setAttribute('aria-live', 'assertive');
toast.setAttribute('aria-atomic', 'true');
// Add custom classes onto toast
if (this.options.classes.length > 0) {
toast.classList.add(...this.options.classes.split(' '));
}
if (this.message)
toast.innerText = this.message;
Toast._container.appendChild(toast);
return toast;
}
_animateIn() {
// Animate toast in
this.el.style.display = "";
this.el.style.opacity = '0';
// easeOutCubic
this.el.style.transition = `
top ${this.options.inDuration}ms ease,
opacity ${this.options.inDuration}ms ease
`;
setTimeout(() => {
this.el.style.top = '0';
this.el.style.opacity = '1';
}, 1);
}
/**
* Create setInterval which automatically removes toast when timeRemaining >= 0
* has been reached.
*/
_setTimer() {
if (this.timeRemaining !== Infinity) {
this.counterInterval = setInterval(() => {
// If toast is not being dragged, decrease its time remaining
if (!this.panning) {
this.timeRemaining -= 20;
}
// Animate toast out
if (this.timeRemaining <= 0) {
this.dismiss();
}
}, 20);
}
}
/**
* Dismiss toast with animation.
*/
dismiss() {
window.clearInterval(this.counterInterval);
let activationDistance = this.el.offsetWidth * this.options.activationPercent;
if (this.wasSwiped) {
this.el.style.transition = 'transform .05s, opacity .05s';
this.el.style.transform = `translateX(${activationDistance}px)`;
this.el.style.opacity = '0';
}
// easeOutExpo
this.el.style.transition = `
margin ${this.options.outDuration}ms ease,
opacity ${this.options.outDuration}ms ease`;
setTimeout(() => {
this.el.style.opacity = '0';
this.el.style.marginTop = '-40px';
}, 1);
setTimeout(() => {
// Call the optional callback
if (typeof this.options.completeCallback === 'function') {
this.options.completeCallback();
}
// Remove toast from DOM
if (this.el.id != this.options.toastId) {
this.el.remove();
Toast._toasts.splice(Toast._toasts.indexOf(this), 1);
if (Toast._toasts.length === 0) {
Toast._removeContainer();
}
}
}, this.options.outDuration);
}
}
exports.Toast = Toast;
(() => {
Toast._toasts = [];
Toast._container = null;
Toast._draggedToast = null;
})();
/***/ }),
/***/ "./src/tooltip.ts":
/*!************************!*\
!*** ./src/tooltip.ts ***!
\************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Tooltip = void 0;
const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
const component_1 = __webpack_require__(/*! ./component */ "./src/component.ts");
const _defaults = {
exitDelay: 200,
enterDelay: 0,
text: '',
margin: 5,
inDuration: 250,
outDuration: 200,
position: 'bottom',
transitionMovement: 10,
opacity: 1
};
class Tooltip extends component_1.Component {
constructor(el, options) {
super(el, options, Tooltip);
/**
* Show tooltip.
*/
this.open = (isManual) => {
if (this.isOpen)
return;
isManual = isManual === undefined ? true : undefined; // Default value true
this.isOpen = true;
// Update tooltip content with HTML attribute options
this.options = Object.assign(Object.assign({}, this.options), this._getAttributeOptions());
this._updateTooltipContent();
this._setEnterDelayTimeout(isManual);
};
/**
* Hide tooltip.
*/
this.close = () => {
if (!this.isOpen)
return;
this.isHovered = false;
this.isFocused = false;
this.isOpen = false;
this._setExitDelayTimeout();
};
this._handleMouseEnter = () => {
this.isHovered = true;
this.isFocused = false; // Allows close of tooltip when opened by focus.
this.open(false);
};
this._handleMouseLeave = () => {
this.isHovered = false;
this.isFocused = false; // Allows close of tooltip when opened by focus.
this.close();
};
this._handleFocus = () => {
if (utils_1.Utils.tabPressed) {
this.isFocused = true;
this.open(false);
}
};
this._handleBlur = () => {
this.isFocused = false;
this.close();
};
this.el.M_Tooltip = this;
this.options = Object.assign(Object.assign(Object.assign({}, Tooltip.defaults), this._getAttributeOptions()), options);
this.isOpen = false;
this.isHovered = false;
this.isFocused = false;
this._appendTooltipEl();
this._setupEventHandlers();
}
static get defaults() {
return _defaults;
}
/**
* Initializes instances of Tooltip.
* @param els HTML elements.
* @param options Component options.
*/
static init(els, options = {}) {
return super.init(els, options, Tooltip);
}
static getInstance(el) {
return el.M_Tooltip;
}
destroy() {
this.tooltipEl.remove();
this._removeEventHandlers();
this.el.M_Tooltip = undefined;
}
_appendTooltipEl() {
this.tooltipEl = document.createElement('div');
this.tooltipEl.classList.add('material-tooltip');
const tooltipContentEl = this.options.tooltipId
? document.getElementById(this.options.tooltipId)
: document.createElement('div');
this.tooltipEl.append(tooltipContentEl);
tooltipContentEl.style.display = "";
tooltipContentEl.classList.add('tooltip-content');
this._setTooltipContent(tooltipContentEl);
this.tooltipEl.appendChild(tooltipContentEl);
document.body.appendChild(this.tooltipEl);
}
_setTooltipContent(tooltipContentEl) {
if (this.options.tooltipId)
return;
tooltipContentEl.innerText = this.options.text;
}
_updateTooltipContent() {
this._setTooltipContent(this.tooltipEl.querySelector('.tooltip-content'));
}
_setupEventHandlers() {
this.el.addEventListener('mouseenter', this._handleMouseEnter);
this.el.addEventListener('mouseleave', this._handleMouseLeave);
this.el.addEventListener('focus', this._handleFocus, true);
this.el.addEventListener('blur', this._handleBlur, true);
}
_removeEventHandlers() {
this.el.removeEventListener('mouseenter', this._handleMouseEnter);
this.el.removeEventListener('mouseleave', this._handleMouseLeave);
this.el.removeEventListener('focus', this._handleFocus, true);
this.el.removeEventListener('blur', this._handleBlur, true);
}
_setExitDelayTimeout() {
clearTimeout(this._exitDelayTimeout);
this._exitDelayTimeout = setTimeout(() => {
if (this.isHovered || this.isFocused)
return;
this._animateOut();
}, this.options.exitDelay);
}
_setEnterDelayTimeout(isManual) {
clearTimeout(this._enterDelayTimeout);
this._enterDelayTimeout = setTimeout(() => {
if (!this.isHovered && !this.isFocused && !isManual)
return;
this._animateIn();
}, this.options.enterDelay);
}
_positionTooltip() {
const tooltip = this.tooltipEl;
const origin = this.el, originHeight = origin.offsetHeight, originWidth = origin.offsetWidth, tooltipHeight = tooltip.offsetHeight, tooltipWidth = tooltip.offsetWidth, margin = this.options.margin;
(this.xMovement = 0), (this.yMovement = 0);
let targetTop = origin.getBoundingClientRect().top + utils_1.Utils.getDocumentScrollTop();
let targetLeft = origin.getBoundingClientRect().left + utils_1.Utils.getDocumentScrollLeft();
if (this.options.position === 'top') {
targetTop += -tooltipHeight - margin;
targetLeft += originWidth / 2 - tooltipWidth / 2;
this.yMovement = -this.options.transitionMovement;
}
else if (this.options.position === 'right') {
targetTop += originHeight / 2 - tooltipHeight / 2;
targetLeft += originWidth + margin;
this.xMovement = this.options.transitionMovement;
}
else if (this.options.position === 'left') {
targetTop += originHeight / 2 - tooltipHeight / 2;
targetLeft += -tooltipWidth - margin;
this.xMovement = -this.options.transitionMovement;
}
else {
targetTop += originHeight + margin;
targetLeft += originWidth / 2 - tooltipWidth / 2;
this.yMovement = this.options.transitionMovement;
}
const newCoordinates = this._repositionWithinScreen(targetLeft, targetTop, tooltipWidth, tooltipHeight);
tooltip.style.top = newCoordinates.y + 'px';
tooltip.style.left = newCoordinates.x + 'px';
}
_repositionWithinScreen(x, y, width, height) {
const scrollLeft = utils_1.Utils.getDocumentScrollLeft();
const scrollTop = utils_1.Utils.getDocumentScrollTop();
let newX = x - scrollLeft;
let newY = y - scrollTop;
const bounding = {
left: newX,
top: newY,
width: width,
height: height
};
const offset = this.options.margin + this.options.transitionMovement;
const edges = utils_1.Utils.checkWithinContainer(document.body, bounding, offset);
if (edges.left) {
newX = offset;
}
else if (edges.right) {
newX -= newX + width - window.innerWidth;
}
if (edges.top) {
newY = offset;
}
else if (edges.bottom) {
newY -= newY + height - window.innerHeight;
}
return {
x: newX + scrollLeft,
y: newY + scrollTop
};
}
_animateIn() {
this._positionTooltip();
this.tooltipEl.style.visibility = 'visible';
const duration = this.options.inDuration;
// easeOutCubic
this.tooltipEl.style.transition = `
transform ${duration}ms ease-out,
opacity ${duration}ms ease-out`;
setTimeout(() => {
this.tooltipEl.style.transform = `translateX(${this.xMovement}px) translateY(${this.yMovement}px)`;
this.tooltipEl.style.opacity = (this.options.opacity || 1).toString();
}, 1);
}
_animateOut() {
const duration = this.options.outDuration;
// easeOutCubic
this.tooltipEl.style.transition = `
transform ${duration}ms ease-out,
opacity ${duration}ms ease-out`;
setTimeout(() => {
this.tooltipEl.style.transform = `translateX(0px) translateY(0px)`;
this.tooltipEl.style.opacity = '0';
}, 1);
/*
anim.remove(this.tooltipEl);
anim({
targets: this.tooltipEl,
opacity: 0,
translateX: 0,
translateY: 0,
duration: this.options.outDuration,
easing: 'easeOutCubic'
});
*/
}
_getAttributeOptions() {
let attributeOptions = {};
const tooltipTextOption = this.el.getAttribute('data-tooltip');
const tooltipId = this.el.getAttribute('data-tooltip-id');
const positionOption = this.el.getAttribute('data-position');
if (tooltipTextOption) {
attributeOptions.text = tooltipTextOption;
}
if (positionOption) {
attributeOptions.position = positionOption;
}
if (tooltipId) {
attributeOptions.tooltipId = tooltipId;
}
return attributeOptions;
}
}
exports.Tooltip = Tooltip;
/***/ }),
/***/ "./src/utils.ts":
/*!**********************!*\
!*** ./src/utils.ts ***!
\**********************/
/***/ (function(__unused_webpack_module, exports) {
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Utils = void 0;
/**
* Class with utilitary functions for global usage.
*/
class Utils {
/**
* Detects when a key is pressed.
* @param e Event instance.
*/
static docHandleKeydown(e) {
Utils.keyDown = true;
if ([...Utils.keys.TAB, ...Utils.keys.ARROW_DOWN, ...Utils.keys.ARROW_UP].includes(e.key)) {
Utils.tabPressed = true;
}
}
/**
* Detects when a key is released.
* @param e Event instance.
*/
static docHandleKeyup(e) {
Utils.keyDown = false;
if ([...Utils.keys.TAB, ...Utils.keys.ARROW_DOWN, ...Utils.keys.ARROW_UP].includes(e.key)) {
Utils.tabPressed = false;
}
}
/**
* Detects when document is focused.
* @param e Event instance.
*/
static docHandleFocus(e) {
if (Utils.keyDown) {
document.body.classList.add('keyboard-focused');
}
}
/**
* Detects when document is not focused.
* @param e Event instance.
*/
static docHandleBlur(e) {
document.body.classList.remove('keyboard-focused');
}
/**
* Generates a unique string identifier.
*/
static guid() {
const s4 = () => {
return Math.floor((1 + Math.random()) * 0x10000)
.toString(16)
.substring(1);
};
return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
}
/**
* Checks for exceeded edges
* @param container Container element.
* @param bounding Bounding rect.
* @param offset Element offset.
*/
static checkWithinContainer(container, bounding, offset) {
let edges = {
top: false,
right: false,
bottom: false,
left: false
};
let containerRect = container.getBoundingClientRect();
// If body element is smaller than viewport, use viewport height instead.
let containerBottom = container === document.body
? Math.max(containerRect.bottom, window.innerHeight)
: containerRect.bottom;
let scrollLeft = container.scrollLeft;
let scrollTop = container.scrollTop;
let scrolledX = bounding.left - scrollLeft;
let scrolledY = bounding.top - scrollTop;
// Check for container and viewport for each edge
if (scrolledX < containerRect.left + offset || scrolledX < offset) {
edges.left = true;
}
if (scrolledX + bounding.width > containerRect.right - offset ||
scrolledX + bounding.width > window.innerWidth - offset) {
edges.right = true;
}
if (scrolledY < containerRect.top + offset || scrolledY < offset) {
edges.top = true;
}
if (scrolledY + bounding.height > containerBottom - offset ||
scrolledY + bounding.height > window.innerHeight - offset) {
edges.bottom = true;
}
return edges;
}
/**
* Checks if element can be aligned in multiple directions.
* @param el Element to be inspected.
* @param container Container element.
* @param bounding Bounding rect.
* @param offset Element offset.
*/
static checkPossibleAlignments(el, container, bounding, offset) {
let canAlign = {
top: true,
right: true,
bottom: true,
left: true,
spaceOnTop: null,
spaceOnRight: null,
spaceOnBottom: null,
spaceOnLeft: null
};
let containerAllowsOverflow = getComputedStyle(container).overflow === 'visible';
let containerRect = container.getBoundingClientRect();
let containerHeight = Math.min(containerRect.height, window.innerHeight);
let containerWidth = Math.min(containerRect.width, window.innerWidth);
let elOffsetRect = el.getBoundingClientRect();
let scrollLeft = container.scrollLeft;
let scrollTop = container.scrollTop;
let scrolledX = bounding.left - scrollLeft;
let scrolledYTopEdge = bounding.top - scrollTop;
let scrolledYBottomEdge = bounding.top + elOffsetRect.height - scrollTop;
// Check for container and viewport for left
canAlign.spaceOnRight = !containerAllowsOverflow
? containerWidth - (scrolledX + bounding.width)
: window.innerWidth - (elOffsetRect.left + bounding.width);
if (canAlign.spaceOnRight < 0) {
canAlign.left = false;
}
// Check for container and viewport for Right
canAlign.spaceOnLeft = !containerAllowsOverflow
? scrolledX - bounding.width + elOffsetRect.width
: elOffsetRect.right - bounding.width;
if (canAlign.spaceOnLeft < 0) {
canAlign.right = false;
}
// Check for container and viewport for Top
canAlign.spaceOnBottom = !containerAllowsOverflow
? containerHeight - (scrolledYTopEdge + bounding.height + offset)
: window.innerHeight - (elOffsetRect.top + bounding.height + offset);
if (canAlign.spaceOnBottom < 0) {
canAlign.top = false;
}
// Check for container and viewport for Bottom
canAlign.spaceOnTop = !containerAllowsOverflow
? scrolledYBottomEdge - (bounding.height - offset)
: elOffsetRect.bottom - (bounding.height + offset);
if (canAlign.spaceOnTop < 0) {
canAlign.bottom = false;
}
return canAlign;
}
/**
* Retrieves target element id from trigger.
* @param trigger Trigger element.
*/
static getIdFromTrigger(trigger) {
let id = trigger.dataset.target;
if (!id) {
id = trigger.getAttribute('href');
return id ? id.slice(1) : '';
}
return id;
}
/**
* Retrieves document scroll postion from top.
*/
static getDocumentScrollTop() {
return window.scrollY || document.documentElement.scrollTop || document.body.scrollTop || 0;
}
;
/**
* Retrieves document scroll postion from left.
*/
static getDocumentScrollLeft() {
return window.scrollX || document.documentElement.scrollLeft || document.body.scrollLeft || 0;
}
/**
* Fires the given function after a certain ammount of time.
* @param func Function to be fired.
* @param wait Wait time.
* @param options Additional options.
*/
static throttle(func, wait, options = null) {
let context, args, result;
let timeout = null;
let previous = 0;
options || (options = {});
let later = function () {
previous = options.leading === false ? 0 : new Date().getTime();
timeout = null;
result = func.apply(context, args);
context = args = null;
};
return function () {
let now = new Date().getTime();
if (!previous && options.leading === false)
previous = now;
let remaining = wait - (now - previous);
context = this;
args = arguments;
if (remaining <= 0) {
clearTimeout(timeout);
timeout = null;
previous = now;
result = func.apply(context, args);
context = args = null;
}
else if (!timeout && options.trailing !== false) {
timeout = setTimeout(later, remaining);
}
return result;
};
}
}
exports.Utils = Utils;
/** Specifies wether tab is pressed or not. */
Utils.tabPressed = false;
/** Specifies wether there is a key pressed. */
Utils.keyDown = false;
/**
* Key maps.
*/
Utils.keys = {
TAB: ['Tab'],
ENTER: ['Enter'],
ESC: ['Escape', 'Esc'],
BACKSPACE: ['Backspace'],
ARROW_UP: ['ArrowUp', 'Up'],
ARROW_DOWN: ['ArrowDown', 'Down'],
ARROW_LEFT: ['ArrowLeft', 'Left'],
ARROW_RIGHT: ['ArrowRight', 'Right'],
DELETE: ['Delete', 'Del'],
};
/***/ }),
/***/ "./src/waves.ts":
/*!**********************!*\
!*** ./src/waves.ts ***!
\**********************/
/***/ (function(__unused_webpack_module, exports) {
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Waves = void 0;
class Waves {
static _offset(el) {
const box = el.getBoundingClientRect();
const docElem = document.documentElement;
return {
top: box.top + window.pageYOffset - docElem.clientTop,
left: box.left + window.pageXOffset - docElem.clientLeft
};
}
// https://phoenix-dx.com/css-techniques-for-material-ripple-effect/
static renderWaveEffect(targetElement, position = null, color = null) {
const isCentered = position === null;
const duration = 500;
let animationFrame, animationStart;
const animationStep = function (timestamp) {
if (!animationStart) {
animationStart = timestamp;
}
const frame = timestamp - animationStart;
if (frame < duration) {
const easing = (frame / duration) * (2 - (frame / duration));
const circle = isCentered ? 'circle at 50% 50%' : `circle at ${position.x}px ${position.y}px`;
const waveColor = `rgba(${(color === null || color === void 0 ? void 0 : color.r) || 0}, ${(color === null || color === void 0 ? void 0 : color.g) || 0}, ${(color === null || color === void 0 ? void 0 : color.b) || 0}, ${0.3 * (1 - easing)})`;
const stop = 90 * easing + "%";
targetElement.style.backgroundImage = "radial-gradient(" + circle + ", " + waveColor + " " + stop + ", transparent " + stop + ")";
animationFrame = window.requestAnimationFrame(animationStep);
}
else {
targetElement.style.backgroundImage = 'none';
window.cancelAnimationFrame(animationFrame);
}
};
animationFrame = window.requestAnimationFrame(animationStep);
}
static Init() {
document.addEventListener("DOMContentLoaded", () => {
document.body.addEventListener('click', e => {
const trigger = e.target;
const el = trigger.closest('.waves-effect');
if (el && el.contains(trigger)) {
const isCircular = el.classList.contains('waves-circle');
const x = e.pageX - Waves._offset(el).left;
const y = e.pageY - Waves._offset(el).top;
let color = null;
if (el.classList.contains('waves-light'))
color = { r: 255, g: 255, b: 255 };
Waves.renderWaveEffect(el, isCircular ? null : { x, y }, color);
}
});
});
}
}
exports.Waves = Waves;
/***/ })
/******/ });
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/************************************************************************/
var __webpack_exports__ = {};
// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
!function() {
var exports = __webpack_exports__;
/*!***********************!*\
!*** ./src/global.ts ***!
\***********************/
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.M = void 0;
const autocomplete_1 = __webpack_require__(/*! ./autocomplete */ "./src/autocomplete.ts");
const buttons_1 = __webpack_require__(/*! ./buttons */ "./src/buttons.ts");
const cards_1 = __webpack_require__(/*! ./cards */ "./src/cards.ts");
const carousel_1 = __webpack_require__(/*! ./carousel */ "./src/carousel.ts");
const characterCounter_1 = __webpack_require__(/*! ./characterCounter */ "./src/characterCounter.ts");
const chips_1 = __webpack_require__(/*! ./chips */ "./src/chips.ts");
const collapsible_1 = __webpack_require__(/*! ./collapsible */ "./src/collapsible.ts");
const datepicker_1 = __webpack_require__(/*! ./datepicker */ "./src/datepicker.ts");
const dropdown_1 = __webpack_require__(/*! ./dropdown */ "./src/dropdown.ts");
const forms_1 = __webpack_require__(/*! ./forms */ "./src/forms.ts");
const materialbox_1 = __webpack_require__(/*! ./materialbox */ "./src/materialbox.ts");
const modal_1 = __webpack_require__(/*! ./modal */ "./src/modal.ts");
const parallax_1 = __webpack_require__(/*! ./parallax */ "./src/parallax.ts");
const pushpin_1 = __webpack_require__(/*! ./pushpin */ "./src/pushpin.ts");
const scrollspy_1 = __webpack_require__(/*! ./scrollspy */ "./src/scrollspy.ts");
const select_1 = __webpack_require__(/*! ./select */ "./src/select.ts");
const sidenav_1 = __webpack_require__(/*! ./sidenav */ "./src/sidenav.ts");
const slider_1 = __webpack_require__(/*! ./slider */ "./src/slider.ts");
const tabs_1 = __webpack_require__(/*! ./tabs */ "./src/tabs.ts");
const tapTarget_1 = __webpack_require__(/*! ./tapTarget */ "./src/tapTarget.ts");
const timepicker_1 = __webpack_require__(/*! ./timepicker */ "./src/timepicker.ts");
const toasts_1 = __webpack_require__(/*! ./toasts */ "./src/toasts.ts");
const tooltip_1 = __webpack_require__(/*! ./tooltip */ "./src/tooltip.ts");
const waves_1 = __webpack_require__(/*! ./waves */ "./src/waves.ts");
const range_1 = __webpack_require__(/*! ./range */ "./src/range.ts");
const utils_1 = __webpack_require__(/*! ./utils */ "./src/utils.ts");
class M {
/**
* Automatically initialize components.
* @param context Root element to initialize. Defaults to `document.body`.
*/
static AutoInit(context = document.body) {
let registry = {
Autocomplete: context.querySelectorAll('.autocomplete:not(.no-autoinit)'),
Carousel: context.querySelectorAll('.carousel:not(.no-autoinit)'),
Chips: context.querySelectorAll('.chips:not(.no-autoinit)'),
Collapsible: context.querySelectorAll('.collapsible:not(.no-autoinit)'),
Datepicker: context.querySelectorAll('.datepicker:not(.no-autoinit)'),
Dropdown: context.querySelectorAll('.dropdown-trigger:not(.no-autoinit)'),
Materialbox: context.querySelectorAll('.materialboxed:not(.no-autoinit)'),
Modal: context.querySelectorAll('.modal:not(.no-autoinit)'),
Parallax: context.querySelectorAll('.parallax:not(.no-autoinit)'),
Pushpin: context.querySelectorAll('.pushpin:not(.no-autoinit)'),
ScrollSpy: context.querySelectorAll('.scrollspy:not(.no-autoinit)'),
FormSelect: context.querySelectorAll('select:not(.no-autoinit)'),
Sidenav: context.querySelectorAll('.sidenav:not(.no-autoinit)'),
Tabs: context.querySelectorAll('.tabs:not(.no-autoinit)'),
TapTarget: context.querySelectorAll('.tap-target:not(.no-autoinit)'),
Timepicker: context.querySelectorAll('.timepicker:not(.no-autoinit)'),
Tooltip: context.querySelectorAll('.tooltipped:not(.no-autoinit)'),
FloatingActionButton: context.querySelectorAll('.fixed-action-btn:not(.no-autoinit)'),
};
M.Autocomplete.init(registry.Autocomplete, {});
M.Carousel.init(registry.Carousel, {});
M.Chips.init(registry.Chips, {});
M.Collapsible.init(registry.Collapsible, {});
M.Datepicker.init(registry.Datepicker, {});
M.Dropdown.init(registry.Dropdown, {});
M.Materialbox.init(registry.Materialbox, {});
M.Modal.init(registry.Modal, {});
M.Parallax.init(registry.Parallax, {});
M.Pushpin.init(registry.Pushpin, {});
M.ScrollSpy.init(registry.ScrollSpy, {});
M.FormSelect.init(registry.FormSelect, {});
M.Sidenav.init(registry.Sidenav, {});
M.Tabs.init(registry.Tabs, {});
M.TapTarget.init(registry.TapTarget, {});
M.Timepicker.init(registry.Timepicker, {});
M.Tooltip.init(registry.Tooltip, {});
M.FloatingActionButton.init(registry.FloatingActionButton, {});
}
}
exports.M = M;
M.version = '2.1.0';
M.Autocomplete = autocomplete_1.Autocomplete;
M.Tabs = tabs_1.Tabs;
M.Carousel = carousel_1.Carousel;
M.Dropdown = dropdown_1.Dropdown;
M.FloatingActionButton = buttons_1.FloatingActionButton;
M.Chips = chips_1.Chips;
M.Collapsible = collapsible_1.Collapsible;
M.Datepicker = datepicker_1.Datepicker;
M.CharacterCounter = characterCounter_1.CharacterCounter;
M.Forms = forms_1.Forms;
M.FormSelect = select_1.FormSelect;
M.Modal = modal_1.Modal;
M.Pushpin = pushpin_1.Pushpin;
M.Materialbox = materialbox_1.Materialbox;
M.Parallax = parallax_1.Parallax;
M.Slider = slider_1.Slider;
M.Timepicker = timepicker_1.Timepicker;
/** Creates a toast. */
M.toast = (opt) => new toasts_1.Toast(opt);
M.Tooltip = tooltip_1.Tooltip;
M.Sidenav = sidenav_1.Sidenav;
M.TapTarget = tapTarget_1.TapTarget;
M.ScrollSpy = scrollspy_1.ScrollSpy;
M.Range = range_1.Range;
M.Waves = waves_1.Waves;
M.Utils = utils_1.Utils;
(() => {
document.addEventListener('keydown', utils_1.Utils.docHandleKeydown, true);
document.addEventListener('keyup', utils_1.Utils.docHandleKeyup, true);
document.addEventListener('focus', utils_1.Utils.docHandleFocus, true);
document.addEventListener('blur', utils_1.Utils.docHandleBlur, true);
cards_1.Cards.Init();
forms_1.Forms.Init();
chips_1.Chips.Init();
waves_1.Waves.Init();
range_1.Range.Init();
})();
}();
/******/ return __webpack_exports__;
/******/ })()
;
});