react-md/dist/umd/react-md-with-font-icons.development.js

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('react-dom')) :
	typeof define === 'function' && define.amd ? define(['exports', 'react', 'react-dom'], factory) :
	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactMD = {}, global.React, global.ReactDOM));
}(this, (function (exports, React, ReactDOM) { 'use strict';

	var React__default = 'default' in React ? React['default'] : React;
	var ReactDOM__default = 'default' in ReactDOM ? ReactDOM['default'] : ReactDOM;

	function createCommonjsModule(fn, basedir, module) {
		return module = {
		  path: basedir,
		  exports: {},
		  require: function (path, base) {
	      return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
	    }
		}, fn(module, module.exports), module.exports;
	}

	function commonjsRequire () {
		throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
	}

	var classnames = createCommonjsModule(function (module) {
	/*!
	  Copyright (c) 2017 Jed Watson.
	  Licensed under the MIT License (MIT), see
	  http://jedwatson.github.io/classnames
	*/
	/* global define */

	(function () {

		var hasOwn = {}.hasOwnProperty;

		function classNames () {
			var classes = [];

			for (var i = 0; i < arguments.length; i++) {
				var arg = arguments[i];
				if (!arg) continue;

				var argType = typeof arg;

				if (argType === 'string' || argType === 'number') {
					classes.push(arg);
				} else if (Array.isArray(arg) && arg.length) {
					var inner = classNames.apply(null, arg);
					if (inner) {
						classes.push(inner);
					}
				} else if (argType === 'object') {
					for (var key in arg) {
						if (hasOwn.call(arg, key) && arg[key]) {
							classes.push(key);
						}
					}
				}
			}

			return classes.join(' ');
		}

		if ( module.exports) {
			classNames.default = classNames;
			module.exports = classNames;
		} else {
			window.classNames = classNames;
		}
	}());
	});

	/**
	 * A utility function to get the current container for the portal.  For SSR, the
	 * container will always be `null` since portals don't work server side.
	 *
	 * @param into The element to portal into
	 * @param intoId An id for an element to portal into
	 * @return the portal container element or null
	 */
	function getContainer(into, intoId) {
	    if (typeof document === "undefined") {
	        return null;
	    }
	    var container = null;
	    if (typeof into === "undefined" && typeof intoId === "undefined") {
	        container = document.body;
	    }
	    else if (typeof intoId === "string") {
	        container = document.getElementById(intoId);
	    }
	    else if (typeof into === "string") {
	        container = document.querySelector(into);
	    }
	    else if (typeof into === "function") {
	        container = into();
	    }
	    else if (into) {
	        container = into;
	    }
	    return container;
	}

	/**
	 * This component is a simple wrapper for the `createPortal` API from ReactDOM
	 * that will just ensure that `null` is always returned for server side
	 * rendering as well as a "nice" way to choose specific portal targets or just
	 * falling back to the `document.body`.
	 */
	function Portal(_a) {
	    var into = _a.into, intoId = _a.intoId, children = _a.children;
	    var _b = React.useState(null), container = _b[0], setContainer = _b[1];
	    // setting the container via useEffect instead of immediately in the render
	    // just so that it doesn't throw an error immediately if the dom hasn't fully
	    // painted after a SSR
	    React.useEffect(function () {
	        var nextContainer = getContainer(into, intoId);
	        if (container !== nextContainer) {
	            setContainer(nextContainer);
	        }
	    }, [into, intoId, container]);
	    if (!container) {
	        return null;
	    }
	    return ReactDOM.createPortal(children, container);
	}
	{
	    try {
	        var PropTypes = require("prop-types");
	        Portal.propTypes = {
	            into: PropTypes.oneOfType([
	                PropTypes.string,
	                PropTypes.func,
	                PropTypes.object,
	            ]),
	            intoId: PropTypes.string,
	            children: PropTypes.node,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * This is a very simple component that is used in other places within react-md
	 * to conditionally render the children within a portal or not based on general
	 * portal config props.
	 */
	function ConditionalPortal(_a) {
	    var portal = _a.portal, portalInto = _a.portalInto, portalIntoId = _a.portalIntoId, children = _a.children;
	    if (!portal && !portalInto && !portalIntoId) {
	        return children;
	    }
	    return (React__default.createElement(Portal, { into: portalInto, intoId: portalIntoId }, children));
	}
	{
	    try {
	        var PropTypes$1 = require("prop-types");
	        ConditionalPortal.propTypes = {
	            portal: PropTypes$1.bool,
	            portalInto: PropTypes$1.oneOfType([
	                PropTypes$1.string,
	                PropTypes$1.func,
	                PropTypes$1.object,
	            ]),
	            portalIntoId: PropTypes$1.string,
	            children: PropTypes$1.node,
	        };
	    }
	    catch (e) { }
	}

	var SHORTHAND_REGEX = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
	var VERBOSE_REGEX = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i;
	/**
	 * Converts a hex string into an rgb value. This is useful for deteching color
	 * contrast ratios and other stuff.
	 *
	 * @param hex The hex string to convert
	 * @return an object containing the r, g, b values for the color.
	 */
	function hexToRGB(hex) {
	    if (
	        !SHORTHAND_REGEX.test(hex) &&
	        !VERBOSE_REGEX.test(hex)) {
	        throw new TypeError("Invalid color string.");
	    }
	    hex = hex.replace(SHORTHAND_REGEX, function (_m, r, g, b) { return "" + r + r + g + g + b + b; });
	    var result = hex.match(VERBOSE_REGEX) || [];
	    var r = parseInt(result[1] || "", 16) || 0;
	    var g = parseInt(result[2] || "", 16) || 0;
	    var b = parseInt(result[3] || "", 16) || 0;
	    return [r, g, b];
	}

	var RED_MULTIPLIER = 0.2126;
	var GREEN_MULTIPLIER = 0.7152;
	var BLUE_MULTIPLIER = 0.0722;
	/**
	 * I really couldn't figure out how to name these "magic" numbers since the
	 * formula doesn't really describe it much:
	 *
	 * @see https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
	 * @private
	 */
	function get8BitColor(color) {
	    color /= 255;
	    if (color <= 0.03928) {
	        return color / 12.92;
	    }
	    return Math.pow(((color + 0.055) / 1.055), 2.4);
	}
	/**
	 * A number closest to 0 should be closest to black while a number closest to 1
	 * should be closest to white.
	 *
	 * @see https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
	 * @private
	 */
	function getLuminance(color) {
	    var _a = hexToRGB(color), r = _a[0], g = _a[1], b = _a[2];
	    var red = get8BitColor(r) * RED_MULTIPLIER;
	    var green = get8BitColor(g) * GREEN_MULTIPLIER;
	    var blue = get8BitColor(b) * BLUE_MULTIPLIER;
	    return red + green + blue;
	}

	/**
	 * Gets the contrast ratio between a background color and a foreground color.
	 *
	 * @see https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
	 *
	 * @param background The background color
	 * @param foreground The foreground color. This is normally the `color` css
	 * value.
	 * @return the contrast ratio between the background and foreground colors.
	 */
	function getContrastRatio(background, foreground) {
	    var backgroundLuminance = getLuminance(background) + 0.05;
	    var foregroundLuminance = getLuminance(foreground) + 0.05;
	    return (Math.max(backgroundLuminance, foregroundLuminance) /
	        Math.min(backgroundLuminance, foregroundLuminance));
	}

	/**
	 * The contrast ratio that can be used for large text where large text is
	 * considered 18pt or 14pt bold.
	 */
	var LARGE_TEXT_CONTRAST_RATIO = 3;
	/**
	 * The contrast ratio that can be used for normal text.
	 */
	var NORMAL_TEXT_CONTRAST_RATIO = 4.5;
	/**
	 * The AAA contrast ratio for passing WGAC 2.0 color contrast ratios.
	 */
	var AAA_CONTRAST_RATIO = 7;
	/**
	 * Checks if there is an acceptable contrast ratio between the background and
	 * foreground colors based on the provided compliance level.
	 *
	 * @param background The background color to check against
	 * @param foreground The foreground color to check against
	 * @param compliance The compliance level to use or a custom number as a ratio.
	 * @return true if there is enough contrast between the foreground and
	 * background colors for the provided compliance level.
	 */
	function isContrastCompliant(background, foreground, compliance) {
	    if (compliance === void 0) { compliance = "normal"; }
	    var ratio;
	    switch (compliance) {
	        case "large":
	            ratio = LARGE_TEXT_CONTRAST_RATIO;
	            break;
	        case "normal":
	            ratio = NORMAL_TEXT_CONTRAST_RATIO;
	            break;
	        case "AAA":
	            ratio = AAA_CONTRAST_RATIO;
	            break;
	        default:
	            ratio = compliance;
	    }
	    return getContrastRatio(background, foreground) >= ratio;
	}

	/* eslint-disable import/no-mutable-exports, getter-return */
	var noop = function () { };
	var isSupported = false;
	/**
	 * Checks if the browser supports passive events. This shouldn't really be used
	 * outside of this file, but you can always check again if needed.
	 */
	function update() {
	    if (typeof window === "undefined") {
	        return false;
	    }
	    var isPassiveEventsSupported = false;
	    var opts = Object.defineProperty({}, "passive", {
	        get: function () {
	            isPassiveEventsSupported = true;
	        },
	    });
	    window.addEventListener("testSupportsPassive", noop, opts);
	    window.removeEventListener("testSupportsPassive", noop, opts);
	    isSupported = isPassiveEventsSupported;
	    return isPassiveEventsSupported;
	}
	// invoke immediately
	update();

	var passiveEvents = /*#__PURE__*/Object.freeze({
		__proto__: null,
		update: update,
		get isSupported () { return isSupported; }
	});

	var delegatedEvents = [];
	/* eslint-disable @typescript-eslint/explicit-function-return-type */
	/**
	 * Creates the delegated event handler that will run all the callbacks once an
	 * event happens. The callbacks' invocation can also be throttled for event
	 * types that trigger rapidly for additional performance.
	 *
	 * The `<K extends keyof WindowEventMap` is a nice thing I found while looking
	 * through the `lib.d.ts` implementation of `addEventListener` that will allow
	 * you to get the "correct" event type when using the `add` and `remove`
	 * functions once you have created this event handler. Otherwise there'd be ts
	 * errors trying to do `MouseEvent` or `KeyboardEvent` in your listeners.
	 */
	function createEventHandler(throttle, callbacks) {
	    var running = false;
	    var runCallbacks = function (event) { return function () {
	        for (var i = 0; i < callbacks.length; i += 1) {
	            callbacks[i](event);
	        }
	        running = false;
	    }; };
	    return function eventHandler(event) {
	        if (!throttle) {
	            runCallbacks(event)();
	            return;
	        }
	        if (running) {
	            return;
	        }
	        running = true;
	        window.requestAnimationFrame(runCallbacks(event));
	    };
	}
	/* eslint-enable @typescript-eslint/explicit-function-return-type */
	/**
	 * Creates a throttled event handler for the provided event type and event
	 * target.
	 */
	function createDelegatedEventHandler(eventType, eventTarget, throttle, options) {
	    if (eventTarget === void 0) { eventTarget = window; }
	    if (throttle === void 0) { throttle = false; }
	    var callbacks = [];
	    var handler = createEventHandler(throttle, callbacks);
	    return {
	        /**
	         * Attempts to add the provided callback to the list of callbacks for the
	         * throttled event. If this is the first callback to be added, the throttled
	         * event will also be started.
	         */
	        add: function (callback) {
	            if (!callbacks.length) {
	                eventTarget.addEventListener(eventType, handler, options);
	            }
	            if (callbacks.indexOf(callback) === -1) {
	                callbacks.push(callback);
	            }
	        },
	        /**
	         * Attempts to remove the provided callback from the lsit of callbacks for
	         * the throttled event. If this is the last callback that was removed, the
	         * throttled event will also be stopped.
	         */
	        remove: function (callback) {
	            var i = callbacks.indexOf(callback);
	            if (i >= 0) {
	                callbacks.splice(i, 1);
	                if (!callbacks.length) {
	                    eventTarget.removeEventListener(eventType, handler, options);
	                }
	            }
	        },
	    };
	}
	/**
	 * Creates a delegated event listener using custom events. Most of this code
	 * comes from the MDN about resize listeners.
	 *
	 * This will return an object for adding or removing event handlers for the
	 * provided `eventType` since only one base throttled event listener will be
	 * created. Each callback that is added will be called with the event each time
	 * the event is triggered. This does mean that you will manually need to remove
	 * your callback like normal or else it can be called when no longer in use.
	 * This also means that it doesn't "hurt" to call this function without
	 * immediately calling the `add` function since the event won't start until
	 * there is at least 1 callback.
	 *
	 * @see https://developer.mozilla.org/en-US/docs/Web/Events/resize#Examples
	 * @param eventType One of the event types that should be used to create a
	 * delegated event for. This should be things like resize, click, scroll, etc.
	 * @param eventTarget The target that should have the delegated event handler
	 * attached to. This is normally the window, but can be any element as needed.
	 * @param throttle Boolean if the event should be throttled or not. Normally
	 * only event types like resize or scroll should be throttled for performance
	 * boosts, but anything can be.
	 * @return The delegated event handler that allows you to add or remove
	 * `EventListener`s to that event.
	 */
	function delegateEvent(eventType, eventTarget, throttle, options) {
	    if (eventTarget === void 0) { eventTarget = window; }
	    if (throttle === void 0) { throttle = eventType === "resize" || eventType === "scroll"; }
	    var index = delegatedEvents.findIndex(function (event) {
	        return event.type === eventType &&
	            event.target === eventTarget &&
	            event.options === options &&
	            event.throttle === throttle;
	    });
	    if (index === -1) {
	        delegatedEvents.push({
	            type: eventType,
	            target: eventTarget,
	            options: options,
	            throttle: throttle,
	            handler: createDelegatedEventHandler(eventType, eventTarget, throttle, options),
	        });
	        index = delegatedEvents.length - 1;
	    }
	    return delegatedEvents[index].handler;
	}

	var __assign = (undefined && undefined.__assign) || function () {
	    __assign = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign.apply(this, arguments);
	};
	/**
	 * A helper function for manually setting touch events on elements when they
	 * cannot be directly added with a React event listener. This will attempt to
	 * create a passive event if the browser supports passive events so there is
	 * better scroll performance.
	 */
	function setTouchEvent(
	/**
	 * Boolean if the event should be added or removed.
	 */
	add, 
	/**
	 * The element to add the touch event to.
	 */
	el, 
	/**
	 * One of the touch types to modify.
	 */
	eventType, 
	/**
	 * The touch event callback function to use.
	 */
	callback, 
	/**
	 * Boolean if the event should be captured if the browser does not support
	 * passive events.
	 */
	capture, 
	/**
	 * Any additional options to provide to the passive event.
	 */
	options) {
	    if (capture === void 0) { capture = false; }
	    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
	    // @ts-ignore
	    el[(add ? "add" : "remove") + "EventListener"]("touch" + eventType, callback, isSupported ? __assign({ passive: true, capture: capture }, options) : capture);
	}
	/**
	 * A simple wrapper for the `setTouchEvent` to just always add events.
	 */
	function addTouchEvent(
	/**
	 * The element to add the touch event to.
	 */
	el, 
	/**
	 * One of the touch types to modify.
	 */
	eventType, 
	/**
	 * The touch event callback function to use.
	 */
	callback, 
	/**
	 * Boolean if the event should be captured if the browser does not support
	 * passive events.
	 */
	capture, 
	/**
	 * Any additional options to provide to the passive event.
	 */
	options) {
	    if (capture === void 0) { capture = false; }
	    setTouchEvent(true, el, eventType, callback, capture, options);
	}
	/**
	 * A simple wrapper for the `setTouchEvent` to just always remove events.
	 *
	 * @param el The element to add the touch event to.
	 * @param eventType One of the touch types to modify.
	 */
	function removeTouchEvent(el, eventType, 
	/**
	 * The touch event callback function to use.
	 */
	callback, 
	/**
	 * Boolean if the event should be captured if the browser does not support
	 * passive events.
	 */
	capture, 
	/**
	 * Any additional options to provide to the passive event.
	 */
	options) {
	    if (capture === void 0) { capture = false; }
	    setTouchEvent(false, el, eventType, callback, capture, options);
	}

	/**
	 * This hook allows you to provide anything that should be "cached" and puts it
	 * into a ref that'll be updated each render. This is pretty overkill for most
	 * places, but it's really nice when you want to create event handlers that
	 * shouldn't update if the developer used arrow functions to define callbacks.
	 * (A great example is for ref callbacks that *shouldn't* be triggered each
	 * render. But that might just be a programming error instead).
	 *
	 * @param cacheable The cacheable thing that gets updated after each render.
	 * @return a mutable ref object containing the current cache.
	 */
	function useRefCache(cacheable) {
	    var ref = React.useRef(cacheable);
	    React.useEffect(function () {
	        ref.current = cacheable;
	    });
	    return ref;
	}

	/**
	 * This hook will create a performant scroll listener by enabling passive events
	 * if it's supported by the browser and delegating the event as needed.
	 */
	function useScrollListener(_a) {
	    var _b = _a.enabled, enabled = _b === void 0 ? true : _b, onScroll = _a.onScroll, element = _a.element, _c = _a.options, options = _c === void 0 ? isSupported ? { passive: true } : false : _c;
	    var callback = useRefCache(onScroll);
	    React.useEffect(function () {
	        if (!enabled) {
	            return;
	        }
	        var eventHandler = delegateEvent("scroll", element || window, true, options);
	        var handler = function (event) { return callback.current(event); };
	        eventHandler.add(handler);
	        return function () {
	            eventHandler.remove(handler);
	        };
	        // disabled since useRefCache
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [enabled, element, options]);
	}

	/**
	 * This is a simple component wrapper for the `useScrollListener` hook.
	 */
	function ScrollListener(props) {
	    useScrollListener(props);
	    return null;
	}

	/**
	 * This hook will apply the current mode class name to the `document.body` so
	 * that the specific mode style mixins work as expected.
	 *
	 * @private
	 */
	function useModeClassName(mode) {
	    React.useEffect(function () {
	        var className = "rmd-utils--" + mode;
	        document.body.classList.add(className);
	        return function () {
	            document.body.classList.remove(className);
	        };
	    }, [mode]);
	}

	var DEFAULT_TOUCH_TIMEOUT = 1200;
	/**
	 * This is a small hook that is used to determine if the app is currently being
	 * used by a touch device or not. All this really does is switch between
	 * mousemove and touchstart events to determine which mode you are in.  This
	 * also tracks the `contextmenu` appearance since long touches can trigger the
	 * context menu on mobile devices. When the context menu appears after a touch,
	 * the mode will still be considered "touch" instead of swapping to mouse.
	 *
	 * @param touchTimeout This is the amount of time that can occur between a
	 * touchstart and mousemove event but still be considered part of a "touch" user
	 * mode. This should probably be kept at the default value, but if the touch
	 * mode isn't updating as you would expect, you can try increasing or decreasing
	 * this value until it does.
	 * @return true if the app is in touch mode.
	 * @private
	 */
	function useTouchDetection(touchTimeout) {
	    if (touchTimeout === void 0) { touchTimeout = DEFAULT_TOUCH_TIMEOUT; }
	    var _a = React.useState(0), lastTouchTime = _a[0], setTouchTime = _a[1];
	    var touchRef = useRefCache(lastTouchTime);
	    var contextMenuRef = React.useRef(false);
	    var updateTouchTime = React.useCallback(function () {
	        setTouchTime(Date.now());
	        contextMenuRef.current = false;
	    }, []);
	    var resetTouchTime = React.useCallback(function () {
	        var lastTouchTime = touchRef.current;
	        if (contextMenuRef.current || Date.now() - lastTouchTime < touchTimeout) {
	            contextMenuRef.current = false;
	            return;
	        }
	        setTouchTime(0);
	        // disabled since useRefCache for touchRef
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [touchTimeout]);
	    React.useEffect(function () {
	        window.addEventListener("touchstart", updateTouchTime, true);
	        return function () {
	            window.removeEventListener("touchstart", updateTouchTime, true);
	        };
	    }, [updateTouchTime]);
	    React.useEffect(function () {
	        if (lastTouchTime === 0) {
	            contextMenuRef.current = false;
	            return;
	        }
	        var updateContextMenu = function () {
	            contextMenuRef.current = true;
	        };
	        window.addEventListener("mousemove", resetTouchTime, true);
	        window.addEventListener("contextmenu", updateContextMenu, true);
	        return function () {
	            window.removeEventListener("mousemove", resetTouchTime, true);
	            window.removeEventListener("contextmenu", updateContextMenu, true);
	        };
	    }, [lastTouchTime, resetTouchTime]);
	    return lastTouchTime !== 0;
	}

	/**
	 * This hooks provides an easy way to toggle a boolean flag for React
	 * components.  The main use case for this will be toggling the visibility of
	 * something. All the provided actions are guaranteed to never change.
	 *
	 * @param defaultToggled Boolean if the visibility should be enabled first
	 * render.
	 * @return an array containing the toggled state, an enable function, a disable
	 * function, a toggle function, and then a manual set toggle function.
	 */
	function useToggle(defaultToggled) {
	    var _a = React.useState(defaultToggled), toggled = _a[0], setToggled = _a[1];
	    var previous = useRefCache(toggled);
	    var enable = React.useCallback(function () {
	        if (!previous.current) {
	            setToggled(true);
	        }
	        // disabled since useRefCache
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    var disable = React.useCallback(function () {
	        if (previous.current) {
	            setToggled(false);
	        }
	        // disabled since useRefCache
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    var toggle = React.useCallback(function () {
	        setToggled(function (prevVisible) { return !prevVisible; });
	    }, []);
	    return [toggled, enable, disable, toggle, setToggled];
	}

	/**
	 * A small hook for checking if the app is currently being interacted with by a
	 * keyboard.
	 *
	 * @return true if the app is in keyboard mode
	 * @private
	 */
	function useKeyboardDetection() {
	    var _a = useToggle(false), enabled = _a[0], enable = _a[1], disable = _a[2];
	    React.useEffect(function () {
	        if (enabled) {
	            return;
	        }
	        window.addEventListener("keydown", enable, true);
	        return function () {
	            window.removeEventListener("keydown", enable, true);
	        };
	    }, [enabled, enable]);
	    React.useEffect(function () {
	        if (!enabled) {
	            return;
	        }
	        window.addEventListener("mousedown", disable, true);
	        window.addEventListener("touchstart", disable, true);
	        return function () {
	            window.removeEventListener("mousedown", disable, true);
	            window.removeEventListener("touchstart", disable, true);
	        };
	    }, [enabled, disable]);
	    return enabled;
	}

	/**
	 * This hook combines the touch and keyboard detection hooks and returns a
	 * string of the current interaction mode of the app/user.
	 *
	 * @private
	 */
	function useModeDetection() {
	    var touch = useTouchDetection();
	    var keyboard = useKeyboardDetection();
	    if (touch) {
	        return "touch";
	    }
	    if (keyboard) {
	        return "keyboard";
	    }
	    return "mouse";
	}

	var InteractionMode = React.createContext("mouse");
	var ParentContext = React.createContext(false);
	/**
	 * Gets the current interaction mode of the user.
	 */
	function useUserInteractionMode() {
	    return React.useContext(InteractionMode);
	}
	/**
	 * Checks if the provided user interaction mode matches the current interaction
	 * mode within the app.
	 *
	 * @param mode The mode to check against.
	 * @return true if the mode matches.
	 */
	function useIsUserInteractionMode(mode) {
	    return useUserInteractionMode() === mode;
	}
	/**
	 * A component that should be mounted once in your app near the top of the tree
	 * to determine the current interaction mode for your app.
	 */
	function InteractionModeListener(_a) {
	    var children = _a.children;
	    if (React.useContext(ParentContext)) {
	        throw new Error("Nested `InteractionModeListener` components");
	    }
	    var mode = useModeDetection();
	    useModeClassName(mode);
	    return (React__default.createElement(InteractionMode.Provider, { value: mode },
	        React__default.createElement(ParentContext.Provider, { value: true }, children)));
	}
	{
	    try {
	        var PropTypes$2 = require("prop-types");
	        InteractionModeListener.propTypes = {
	            children: PropTypes$2.node.isRequired,
	        };
	    }
	    catch (e) { }
	}

	function modify(base, modifier) {
	    if (!modifier) {
	        return base;
	    }
	    var hasOwn = Object.prototype.hasOwnProperty;
	    return Object.keys(modifier).reduce(function (s, mod) {
	        if (hasOwn.call(modifier, mod) && modifier[mod]) {
	            s = s + " " + base + "--" + mod;
	        }
	        return s;
	    }, base);
	}
	/**
	 * Applies the BEM styled class name to an element.
	 *
	 * @see https://en.bem.info/methodology/css/
	 * @param base The base class to use
	 * @return a function to call that generates the full class name
	 */
	function bem(base) {
	    {
	        if (!base) {
	            throw new Error("bem requires a base block class but none were provided.");
	        }
	    }
	    /**
	     * Creates the full class name from the base block name. This can be called
	     * without any arguments which will just return the base block name (kind of
	     * worthless), or you can provide a child element name and modifiers.
	     *
	     * @param elementOrModifier This is either the child element name or an object
	     * of modifiers to apply. This **must** be a string if the second argument is
	     * provided.
	     * @param modifier Any optional modifiers to apply to the block and optional
	     * element.
	     * @return the full class name
	     */
	    return function block(elementOrModifier, modifier) {
	        {
	            if (typeof elementOrModifier !== "string" && modifier) {
	                throw new TypeError("bem does not support having two modifier arguments.");
	            }
	        }
	        if (!elementOrModifier) {
	            return base;
	        }
	        if (typeof elementOrModifier !== "string") {
	            return modify(base, elementOrModifier);
	        }
	        return modify(base + "__" + elementOrModifier, modifier);
	    };
	}

	var DEFAULT_DESKTOP_MIN_WIDTH = 1025 / 16 + "em";
	var DEFAULT_TABLET_MIN_WIDTH = 768 / 16 + "em";
	var DEFAULT_TABLET_MAX_WIDTH = 1024 / 16 + "em";
	var DEFAULT_PHONE_MAX_WIDTH = 767 / 16 + "em";
	var DEFAULT_DESKTOP_LARGE_MIN_WIDTH = 1280 / 16 + "em";

	/**
	 * A helper hook that is used to create a memoized media query tester for
	 * `window.matchMedia`.
	 *
	 * Note: This is a **client side only** hook as it requires the `window` to
	 * attach a resize event listener to.
	 *
	 * @param query The media query to use
	 * @param defaultValue The default value for if this media query matches. When
	 * this is `undefined`, it will default to `false` unless the `window` is
	 * defined and the `checkImmediately` param was not set to `false`. Otherwise,
	 * it will check the media query matches on mount and use that value.
	 * @param disabled Boolean if the media query checking should be disabled.
	 * @param checkImmediately Boolean if the media query should be checked
	 * immediately on mount. When omittied, it will default to checking when the
	 * window is defined.
	 * @return true if the media query is a match.
	 */
	function useMediaQuery(query, defaultValue, disabled, checkImmediately) {
	    if (disabled === void 0) { disabled = false; }
	    if (checkImmediately === void 0) { checkImmediately = typeof window !== "undefined"; }
	    var _a = React.useState(function () {
	        if (typeof defaultValue !== "undefined") {
	            return defaultValue;
	        }
	        if (!disabled && checkImmediately && typeof window !== "undefined") {
	            return window.matchMedia(query).matches;
	        }
	        return false;
	    }), matches = _a[0], setMatches = _a[1];
	    React.useEffect(function () {
	        if (typeof window === "undefined" || disabled) {
	            return;
	        }
	        var mq = window.matchMedia(query);
	        var updater = function (_a) {
	            var matches = _a.matches;
	            return setMatches(matches);
	        };
	        mq.addListener(updater);
	        if (mq.matches !== matches) {
	            setMatches(mq.matches);
	        }
	        return function () { return mq.removeListener(updater); };
	    }, [disabled, matches, query]);
	    return matches;
	}

	/**
	 * This is a small helper that will create a media query block based on the
	 * provided width value.
	 */
	var toWidthPart = function (v, prefix) {
	    var type = typeof v;
	    if (type === "undefined") {
	        return "";
	    }
	    var value = type === "number" ? v + "px" : v;
	    return "(" + prefix + "-width: " + value + ")";
	};
	/**
	 * This is a simple hoo that will create a memoized media query string with the
	 * provided min anx max values.
	 *
	 * @param min An optional min value to use
	 * @param max An optional max value to use
	 * @return a boolean if the current media query is a match.
	 */
	function useWidthMediaQuery(_a) {
	    var min = _a.min, max = _a.max;
	    var query = React.useMemo(function () {
	        var parts = [toWidthPart(min, "min"), toWidthPart(max, "max")]
	            .filter(Boolean)
	            .join(" and ");
	        return "screen and " + parts;
	    }, [min, max]);
	    return useMediaQuery(query);
	}

	/**
	 * An extremely simple "pollyfill" for the `window.screen.orientation` just for
	 * the `type` value that is required for the `useOrientation` hook.
	 */
	var getOrientationType = function () {
	    var _a;
	    var screenOrientation = (_a = window.screen.orientation) === null || _a === void 0 ? void 0 : _a.type;
	    if (typeof screenOrientation === "string") {
	        return screenOrientation;
	    }
	    var _b = window.screen, availHeight = _b.availHeight, availWidth = _b.availWidth;
	    return availHeight > availWidth ? "portrait-primary" : "landscape-primary";
	};
	/**
	 * This media query is used to determine the current orientation of the app
	 * based on the `window.screen.orientation.type`. This will always be
	 * `"landscape-primary"` server side unless a default value is provided.
	 *
	 * @param defaultValue an optional default value to use. When this is omitted,
	 * it will default to `"landscape-primary"` unless the `window` is defined. If
	 * the `window` is defined, it will immediately check the orientation type on
	 * mount.
	 * @return the orientation type value.
	 */
	function useOrientation(defaultValue) {
	    var _a = React.useState(function () {
	        if (defaultValue) {
	            return defaultValue;
	        }
	        if (typeof window !== "undefined") {
	            return getOrientationType();
	        }
	        return "landscape-primary";
	    }), value = _a[0], setValue = _a[1];
	    React.useEffect(function () {
	        if (typeof window === "undefined") {
	            return;
	        }
	        var handler = function () {
	            setValue(getOrientationType());
	        };
	        window.addEventListener("orientationchange", handler);
	        return function () { return window.removeEventListener("orientationchange", handler); };
	    }, []);
	    return value;
	}

	var DEFAULT_APP_SIZE = {
	    isPhone: false,
	    isTablet: false,
	    isDesktop: true,
	    isLargeDesktop: false,
	    isLandscape: true,
	};
	/**
	 * This hook is used to determine the current application size based on the
	 * provided query sizes. When you want to render your app server side, you will
	 * need to provide a custom `defaultSize` that implements your logic to
	 * determine the type of device requesting a page. Once the app has been
	 * rendered in the DOM, this hook will attach event listeners to automatically
	 * update the app size when the page is resized.
	 *
	 * @private
	 */
	function useAppSizeMedia(_a) {
	    var _b = _a === void 0 ? {} : _a, _c = _b.phoneMaxWidth, phoneMaxWidth = _c === void 0 ? DEFAULT_PHONE_MAX_WIDTH : _c, _d = _b.tabletMinWidth, tabletMinWidth = _d === void 0 ? DEFAULT_TABLET_MIN_WIDTH : _d, _e = _b.tabletMaxWidth, tabletMaxWidth = _e === void 0 ? DEFAULT_TABLET_MAX_WIDTH : _e, _f = _b.desktopMinWidth, desktopMinWidth = _f === void 0 ? DEFAULT_DESKTOP_MIN_WIDTH : _f, _g = _b.desktopLargeMinWidth, desktopLargeMinWidth = _g === void 0 ? DEFAULT_DESKTOP_LARGE_MIN_WIDTH : _g, _h = _b.defaultSize, defaultSize = _h === void 0 ? DEFAULT_APP_SIZE : _h;
	    /* eslint-disable react-hooks/rules-of-hooks */
	    // disabled since this is conditionally applied for SSR
	    if (typeof window === "undefined") {
	        return defaultSize;
	    }
	    var matchesDesktop = useWidthMediaQuery({ min: desktopMinWidth });
	    var matchesLargeDesktop = useWidthMediaQuery({ min: desktopLargeMinWidth });
	    var matchesTablet = useWidthMediaQuery({
	        min: tabletMinWidth,
	        max: tabletMaxWidth,
	    });
	    var matchesPhone = useWidthMediaQuery({ max: phoneMaxWidth });
	    var isDesktop = matchesDesktop;
	    var isTablet = !matchesDesktop && matchesTablet;
	    var isPhone = !isTablet && !isDesktop && matchesPhone;
	    var isLandscape = useOrientation().includes("landscape");
	    var isLargeDesktop = matchesLargeDesktop;
	    var _j = React.useState(defaultSize), appSize = _j[0], setAppSize = _j[1];
	    React.useEffect(function () {
	        if (appSize.isPhone === isPhone &&
	            appSize.isTablet === isTablet &&
	            appSize.isDesktop === isDesktop &&
	            appSize.isLargeDesktop === isLargeDesktop &&
	            appSize.isLandscape === isLandscape) {
	            return;
	        }
	        // for some reason, it's sometimes possible to fail every single matchMedia
	        // value when you are resizing the browser a lot. this is an "invalid" event
	        // so skip it. It normally happens between 760px-768px
	        if (!isPhone && !isTablet && !isDesktop && !isLargeDesktop) {
	            return;
	        }
	        setAppSize({ isPhone: isPhone, isTablet: isTablet, isDesktop: isDesktop, isLargeDesktop: isLargeDesktop, isLandscape: isLandscape });
	    }, [isPhone, isTablet, isDesktop, isLargeDesktop, isLandscape, appSize]);
	    return appSize;
	}

	var __assign$1 = (undefined && undefined.__assign) || function () {
	    __assign$1 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1.apply(this, arguments);
	};
	var __rest = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * @private
	 */
	var AppSizeContext = React.createContext(__assign$1(__assign$1({}, DEFAULT_APP_SIZE), { __initialized: false }));
	/**
	 * Gets the current app size.
	 *
	 * @return the current AppSize
	 */
	function useAppSize() {
	    var _a = React.useContext(AppSizeContext), __initialized = _a.__initialized, context = __rest(_a, ["__initialized"]);
	    if (!__initialized) {
	        throw new Error("Attempted to use the current `AppSizeContext` without mounting the `AppSizeListener` component beforehand.");
	    }
	    return context;
	}

	var __assign$2 = (undefined && undefined.__assign) || function () {
	    __assign$2 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2.apply(this, arguments);
	};
	var __rest$1 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block = bem("rmd-grid");
	var GridCell = React.forwardRef(function GridCell(_a, ref) {
	    var _b, _c, _d, _e, _f, _g, _h;
	    var style = _a.style, className = _a.className, clone = _a.clone, children = _a.children, propColSpan = _a.colSpan, propColStart = _a.colStart, propColEnd = _a.colEnd, propRowSpan = _a.rowSpan, propRowStart = _a.rowStart, propRowEnd = _a.rowEnd, phone = _a.phone, tablet = _a.tablet, desktop = _a.desktop, largeDesktop = _a.largeDesktop, props = __rest$1(_a, ["style", "className", "clone", "children", "colSpan", "colStart", "colEnd", "rowSpan", "rowStart", "rowEnd", "phone", "tablet", "desktop", "largeDesktop"]);
	    var _j = useAppSize(), isPhone = _j.isPhone, isTablet = _j.isTablet, isDesktop = _j.isDesktop, isLargeDesktop = _j.isLargeDesktop;
	    var colSpan = propColSpan;
	    var colStart = propColStart;
	    var colEnd = propColEnd;
	    var rowSpan = propRowSpan;
	    var rowStart = propRowStart;
	    var rowEnd = propRowEnd;
	    var media = (isPhone && phone) ||
	        (isTablet && tablet) ||
	        (isDesktop && desktop) ||
	        (isLargeDesktop && largeDesktop);
	    if (media) {
	        (_b = media.rowSpan, rowSpan = _b === void 0 ? propRowSpan : _b, _c = media.rowStart, rowStart = _c === void 0 ? propRowStart : _c, _d = media.rowEnd, rowEnd = _d === void 0 ? propRowEnd : _d, _e = media.colSpan, colSpan = _e === void 0 ? propColSpan : _e, _f = media.colStart, colStart = _f === void 0 ? propColStart : _f, _g = media.colEnd, colEnd = _g === void 0 ? propColEnd : _g);
	    }
	    var cellStyle = __assign$2({ gridColumnStart: colStart, gridColumnEnd: colEnd, gridRowStart: rowStart, gridRowEnd: rowSpan ? "span " + rowSpan : rowEnd }, style);
	    var cellClassName = classnames(block("cell", (_h = {},
	        _h["" + colSpan] = colSpan,
	        _h)), className);
	    if (clone && React.isValidElement(children)) {
	        var child = React.Children.only(children);
	        return React.cloneElement(child, {
	            style: __assign$2(__assign$2({}, child.props.style), cellStyle),
	            className: classnames(cellClassName, child.props.className),
	        });
	    }
	    return (React__default.createElement("div", __assign$2({}, props, { ref: ref, style: cellStyle, className: cellClassName }), children));
	});
	{
	    try {
	        var PropTypes$3 = require("prop-types");
	        var gridCSSProperties = PropTypes$3.shape({
	            rowSpan: PropTypes$3.number,
	            rowStart: PropTypes$3.oneOfType([PropTypes$3.number, PropTypes$3.string]),
	            rowEnd: PropTypes$3.oneOfType([PropTypes$3.number, PropTypes$3.string]),
	            colSpan: PropTypes$3.number,
	            colStart: PropTypes$3.oneOfType([PropTypes$3.number, PropTypes$3.string]),
	            colEnd: PropTypes$3.oneOfType([PropTypes$3.number, PropTypes$3.string]),
	        });
	        GridCell.propTypes = {
	            style: PropTypes$3.object,
	            className: PropTypes$3.string,
	            clone: PropTypes$3.bool,
	            rowSpan: PropTypes$3.number,
	            rowStart: PropTypes$3.oneOfType([PropTypes$3.number, PropTypes$3.string]),
	            rowEnd: PropTypes$3.oneOfType([PropTypes$3.number, PropTypes$3.string]),
	            colSpan: PropTypes$3.number,
	            colStart: PropTypes$3.oneOfType([PropTypes$3.number, PropTypes$3.string]),
	            colEnd: PropTypes$3.oneOfType([PropTypes$3.number, PropTypes$3.string]),
	            phone: gridCSSProperties,
	            tablet: gridCSSProperties,
	            desktop: gridCSSProperties,
	            largeDesktop: gridCSSProperties,
	            children: PropTypes$3.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$3 = (undefined && undefined.__assign) || function () {
	    __assign$3 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3.apply(this, arguments);
	};
	var __rest$2 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This CSS Variable allows you to override the number of columns that should be
	 * displayed in the grid. This is automatically updated with media queries with
	 * the default grid implementation, but is used here to add additional
	 * inline-style overrides.
	 *
	 * @private
	 */
	var GRID_COLUMNS_VAR = "--rmd-grid-cols";
	/**
	 * This CSS Variable allows you to override the gutter (grid-gap) between each
	 * cell in the grid.
	 *
	 * @private
	 */
	var GRID_GUTTER_VAR = "--rmd-grid-gutter";
	var block$1 = bem("rmd-grid");
	/**
	 * The grid component is generally used for a base layout in your app to provide
	 * nice padding and spacing between each item.
	 *
	 * Note: This component relies on the `AppSizeListener` as a parent component to
	 * work and will throw an error if it does not exist as a parent.
	 */
	var Grid = React.forwardRef(function Grid(_a, ref) {
	    var _b;
	    var style = _a.style, className = _a.className, children = _a.children, _c = _a.clone, clone = _c === void 0 ? false : _c, _d = _a.wrapOnly, wrapOnly = _d === void 0 ? false : _d, columns = _a.columns, phoneColumns = _a.phoneColumns, tabletColumns = _a.tabletColumns, desktopColumns = _a.desktopColumns, largeDesktopColumns = _a.largeDesktopColumns, padding = _a.padding, gutter = _a.gutter, minCellWidth = _a.minCellWidth, props = __rest$2(_a, ["style", "className", "children", "clone", "wrapOnly", "columns", "phoneColumns", "tabletColumns", "desktopColumns", "largeDesktopColumns", "padding", "gutter", "minCellWidth"]);
	    var _e = useAppSize(), isPhone = _e.isPhone, isTablet = _e.isTablet, isDesktop = _e.isDesktop, isLargeDesktop = _e.isLargeDesktop;
	    var mergedStyle = __assign$3(__assign$3({ padding: (padding !== 0 && padding) || undefined, gridTemplateColumns: minCellWidth
	            ? "repeat(auto-fill, minmax(" + minCellWidth + ", 1fr))"
	            : undefined }, style), (_b = {}, _b[GRID_COLUMNS_VAR] = (isPhone && phoneColumns) ||
	        (isTablet && tabletColumns) ||
	        (isLargeDesktop && largeDesktopColumns) ||
	        (isDesktop && desktopColumns) ||
	        columns, _b[GRID_GUTTER_VAR] = gutter, _b));
	    var content = children;
	    if (clone || wrapOnly) {
	        content = React.Children.map(children, function (child) { return child && React__default.createElement(GridCell, { clone: clone }, child); });
	    }
	    return (React__default.createElement("div", __assign$3({}, props, { ref: ref, style: mergedStyle, className: classnames(block$1({ "no-padding": padding === 0 }), className) }), content));
	});
	{
	    try {
	        var PropTypes$4 = require("prop-types");
	        Grid.propTypes = {
	            style: PropTypes$4.object,
	            className: PropTypes$4.string,
	            clone: PropTypes$4.bool,
	            wrapOnly: PropTypes$4.bool,
	            columns: PropTypes$4.number,
	            phoneColumns: PropTypes$4.number,
	            tabletColumns: PropTypes$4.number,
	            desktopColumns: PropTypes$4.number,
	            largeDesktopColumns: PropTypes$4.number,
	            padding: PropTypes$4.oneOfType([PropTypes$4.number, PropTypes$4.string]),
	            gutter: PropTypes$4.string,
	            children: PropTypes$4.node,
	            minCellWidth: PropTypes$4.string,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * A small utility function that allows me to apply a passed in ref along with
	 * my own custom ref logic.
	 *
	 * @param instance The DOM Node instance
	 * @param ref The prop ref
	 */
	function applyRef(instance, ref) {
	    if (!ref) {
	        return;
	    }
	    if (typeof ref === "function") {
	        ref(instance);
	    }
	    else if (typeof ref === "object") {
	        ref.current = instance;
	    }
	}

	/**
	 * A collection of shims that provide minimal functionality of the ES6 collections.
	 *
	 * These implementations are not meant to be used outside of the ResizeObserver
	 * modules as they cover only a limited range of use cases.
	 */
	/* eslint-disable require-jsdoc, valid-jsdoc */
	var MapShim = (function () {
	    if (typeof Map !== 'undefined') {
	        return Map;
	    }
	    /**
	     * Returns index in provided array that matches the specified key.
	     *
	     * @param {Array<Array>} arr
	     * @param {*} key
	     * @returns {number}
	     */
	    function getIndex(arr, key) {
	        var result = -1;
	        arr.some(function (entry, index) {
	            if (entry[0] === key) {
	                result = index;
	                return true;
	            }
	            return false;
	        });
	        return result;
	    }
	    return /** @class */ (function () {
	        function class_1() {
	            this.__entries__ = [];
	        }
	        Object.defineProperty(class_1.prototype, "size", {
	            /**
	             * @returns {boolean}
	             */
	            get: function () {
	                return this.__entries__.length;
	            },
	            enumerable: true,
	            configurable: true
	        });
	        /**
	         * @param {*} key
	         * @returns {*}
	         */
	        class_1.prototype.get = function (key) {
	            var index = getIndex(this.__entries__, key);
	            var entry = this.__entries__[index];
	            return entry && entry[1];
	        };
	        /**
	         * @param {*} key
	         * @param {*} value
	         * @returns {void}
	         */
	        class_1.prototype.set = function (key, value) {
	            var index = getIndex(this.__entries__, key);
	            if (~index) {
	                this.__entries__[index][1] = value;
	            }
	            else {
	                this.__entries__.push([key, value]);
	            }
	        };
	        /**
	         * @param {*} key
	         * @returns {void}
	         */
	        class_1.prototype.delete = function (key) {
	            var entries = this.__entries__;
	            var index = getIndex(entries, key);
	            if (~index) {
	                entries.splice(index, 1);
	            }
	        };
	        /**
	         * @param {*} key
	         * @returns {void}
	         */
	        class_1.prototype.has = function (key) {
	            return !!~getIndex(this.__entries__, key);
	        };
	        /**
	         * @returns {void}
	         */
	        class_1.prototype.clear = function () {
	            this.__entries__.splice(0);
	        };
	        /**
	         * @param {Function} callback
	         * @param {*} [ctx=null]
	         * @returns {void}
	         */
	        class_1.prototype.forEach = function (callback, ctx) {
	            if (ctx === void 0) { ctx = null; }
	            for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {
	                var entry = _a[_i];
	                callback.call(ctx, entry[1], entry[0]);
	            }
	        };
	        return class_1;
	    }());
	})();

	/**
	 * Detects whether window and document objects are available in current environment.
	 */
	var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;

	// Returns global object of a current environment.
	var global$1 = (function () {
	    if (typeof global !== 'undefined' && global.Math === Math) {
	        return global;
	    }
	    if (typeof self !== 'undefined' && self.Math === Math) {
	        return self;
	    }
	    if (typeof window !== 'undefined' && window.Math === Math) {
	        return window;
	    }
	    // eslint-disable-next-line no-new-func
	    return Function('return this')();
	})();

	/**
	 * A shim for the requestAnimationFrame which falls back to the setTimeout if
	 * first one is not supported.
	 *
	 * @returns {number} Requests' identifier.
	 */
	var requestAnimationFrame$1 = (function () {
	    if (typeof requestAnimationFrame === 'function') {
	        // It's required to use a bounded function because IE sometimes throws
	        // an "Invalid calling object" error if rAF is invoked without the global
	        // object on the left hand side.
	        return requestAnimationFrame.bind(global$1);
	    }
	    return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };
	})();

	// Defines minimum timeout before adding a trailing call.
	var trailingTimeout = 2;
	/**
	 * Creates a wrapper function which ensures that provided callback will be
	 * invoked only once during the specified delay period.
	 *
	 * @param {Function} callback - Function to be invoked after the delay period.
	 * @param {number} delay - Delay after which to invoke callback.
	 * @returns {Function}
	 */
	function throttle (callback, delay) {
	    var leadingCall = false, trailingCall = false, lastCallTime = 0;
	    /**
	     * Invokes the original callback function and schedules new invocation if
	     * the "proxy" was called during current request.
	     *
	     * @returns {void}
	     */
	    function resolvePending() {
	        if (leadingCall) {
	            leadingCall = false;
	            callback();
	        }
	        if (trailingCall) {
	            proxy();
	        }
	    }
	    /**
	     * Callback invoked after the specified delay. It will further postpone
	     * invocation of the original function delegating it to the
	     * requestAnimationFrame.
	     *
	     * @returns {void}
	     */
	    function timeoutCallback() {
	        requestAnimationFrame$1(resolvePending);
	    }
	    /**
	     * Schedules invocation of the original function.
	     *
	     * @returns {void}
	     */
	    function proxy() {
	        var timeStamp = Date.now();
	        if (leadingCall) {
	            // Reject immediately following calls.
	            if (timeStamp - lastCallTime < trailingTimeout) {
	                return;
	            }
	            // Schedule new call to be in invoked when the pending one is resolved.
	            // This is important for "transitions" which never actually start
	            // immediately so there is a chance that we might miss one if change
	            // happens amids the pending invocation.
	            trailingCall = true;
	        }
	        else {
	            leadingCall = true;
	            trailingCall = false;
	            setTimeout(timeoutCallback, delay);
	        }
	        lastCallTime = timeStamp;
	    }
	    return proxy;
	}

	// Minimum delay before invoking the update of observers.
	var REFRESH_DELAY = 20;
	// A list of substrings of CSS properties used to find transition events that
	// might affect dimensions of observed elements.
	var transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];
	// Check if MutationObserver is available.
	var mutationObserverSupported = typeof MutationObserver !== 'undefined';
	/**
	 * Singleton controller class which handles updates of ResizeObserver instances.
	 */
	var ResizeObserverController = /** @class */ (function () {
	    /**
	     * Creates a new instance of ResizeObserverController.
	     *
	     * @private
	     */
	    function ResizeObserverController() {
	        /**
	         * Indicates whether DOM listeners have been added.
	         *
	         * @private {boolean}
	         */
	        this.connected_ = false;
	        /**
	         * Tells that controller has subscribed for Mutation Events.
	         *
	         * @private {boolean}
	         */
	        this.mutationEventsAdded_ = false;
	        /**
	         * Keeps reference to the instance of MutationObserver.
	         *
	         * @private {MutationObserver}
	         */
	        this.mutationsObserver_ = null;
	        /**
	         * A list of connected observers.
	         *
	         * @private {Array<ResizeObserverSPI>}
	         */
	        this.observers_ = [];
	        this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);
	        this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
	    }
	    /**
	     * Adds observer to observers list.
	     *
	     * @param {ResizeObserverSPI} observer - Observer to be added.
	     * @returns {void}
	     */
	    ResizeObserverController.prototype.addObserver = function (observer) {
	        if (!~this.observers_.indexOf(observer)) {
	            this.observers_.push(observer);
	        }
	        // Add listeners if they haven't been added yet.
	        if (!this.connected_) {
	            this.connect_();
	        }
	    };
	    /**
	     * Removes observer from observers list.
	     *
	     * @param {ResizeObserverSPI} observer - Observer to be removed.
	     * @returns {void}
	     */
	    ResizeObserverController.prototype.removeObserver = function (observer) {
	        var observers = this.observers_;
	        var index = observers.indexOf(observer);
	        // Remove observer if it's present in registry.
	        if (~index) {
	            observers.splice(index, 1);
	        }
	        // Remove listeners if controller has no connected observers.
	        if (!observers.length && this.connected_) {
	            this.disconnect_();
	        }
	    };
	    /**
	     * Invokes the update of observers. It will continue running updates insofar
	     * it detects changes.
	     *
	     * @returns {void}
	     */
	    ResizeObserverController.prototype.refresh = function () {
	        var changesDetected = this.updateObservers_();
	        // Continue running updates if changes have been detected as there might
	        // be future ones caused by CSS transitions.
	        if (changesDetected) {
	            this.refresh();
	        }
	    };
	    /**
	     * Updates every observer from observers list and notifies them of queued
	     * entries.
	     *
	     * @private
	     * @returns {boolean} Returns "true" if any observer has detected changes in
	     *      dimensions of it's elements.
	     */
	    ResizeObserverController.prototype.updateObservers_ = function () {
	        // Collect observers that have active observations.
	        var activeObservers = this.observers_.filter(function (observer) {
	            return observer.gatherActive(), observer.hasActive();
	        });
	        // Deliver notifications in a separate cycle in order to avoid any
	        // collisions between observers, e.g. when multiple instances of
	        // ResizeObserver are tracking the same element and the callback of one
	        // of them changes content dimensions of the observed target. Sometimes
	        // this may result in notifications being blocked for the rest of observers.
	        activeObservers.forEach(function (observer) { return observer.broadcastActive(); });
	        return activeObservers.length > 0;
	    };
	    /**
	     * Initializes DOM listeners.
	     *
	     * @private
	     * @returns {void}
	     */
	    ResizeObserverController.prototype.connect_ = function () {
	        // Do nothing if running in a non-browser environment or if listeners
	        // have been already added.
	        if (!isBrowser || this.connected_) {
	            return;
	        }
	        // Subscription to the "Transitionend" event is used as a workaround for
	        // delayed transitions. This way it's possible to capture at least the
	        // final state of an element.
	        document.addEventListener('transitionend', this.onTransitionEnd_);
	        window.addEventListener('resize', this.refresh);
	        if (mutationObserverSupported) {
	            this.mutationsObserver_ = new MutationObserver(this.refresh);
	            this.mutationsObserver_.observe(document, {
	                attributes: true,
	                childList: true,
	                characterData: true,
	                subtree: true
	            });
	        }
	        else {
	            document.addEventListener('DOMSubtreeModified', this.refresh);
	            this.mutationEventsAdded_ = true;
	        }
	        this.connected_ = true;
	    };
	    /**
	     * Removes DOM listeners.
	     *
	     * @private
	     * @returns {void}
	     */
	    ResizeObserverController.prototype.disconnect_ = function () {
	        // Do nothing if running in a non-browser environment or if listeners
	        // have been already removed.
	        if (!isBrowser || !this.connected_) {
	            return;
	        }
	        document.removeEventListener('transitionend', this.onTransitionEnd_);
	        window.removeEventListener('resize', this.refresh);
	        if (this.mutationsObserver_) {
	            this.mutationsObserver_.disconnect();
	        }
	        if (this.mutationEventsAdded_) {
	            document.removeEventListener('DOMSubtreeModified', this.refresh);
	        }
	        this.mutationsObserver_ = null;
	        this.mutationEventsAdded_ = false;
	        this.connected_ = false;
	    };
	    /**
	     * "Transitionend" event handler.
	     *
	     * @private
	     * @param {TransitionEvent} event
	     * @returns {void}
	     */
	    ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {
	        var _b = _a.propertyName, propertyName = _b === void 0 ? '' : _b;
	        // Detect whether transition may affect dimensions of an element.
	        var isReflowProperty = transitionKeys.some(function (key) {
	            return !!~propertyName.indexOf(key);
	        });
	        if (isReflowProperty) {
	            this.refresh();
	        }
	    };
	    /**
	     * Returns instance of the ResizeObserverController.
	     *
	     * @returns {ResizeObserverController}
	     */
	    ResizeObserverController.getInstance = function () {
	        if (!this.instance_) {
	            this.instance_ = new ResizeObserverController();
	        }
	        return this.instance_;
	    };
	    /**
	     * Holds reference to the controller's instance.
	     *
	     * @private {ResizeObserverController}
	     */
	    ResizeObserverController.instance_ = null;
	    return ResizeObserverController;
	}());

	/**
	 * Defines non-writable/enumerable properties of the provided target object.
	 *
	 * @param {Object} target - Object for which to define properties.
	 * @param {Object} props - Properties to be defined.
	 * @returns {Object} Target object.
	 */
	var defineConfigurable = (function (target, props) {
	    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {
	        var key = _a[_i];
	        Object.defineProperty(target, key, {
	            value: props[key],
	            enumerable: false,
	            writable: false,
	            configurable: true
	        });
	    }
	    return target;
	});

	/**
	 * Returns the global object associated with provided element.
	 *
	 * @param {Object} target
	 * @returns {Object}
	 */
	var getWindowOf = (function (target) {
	    // Assume that the element is an instance of Node, which means that it
	    // has the "ownerDocument" property from which we can retrieve a
	    // corresponding global object.
	    var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;
	    // Return the local global object if it's not possible extract one from
	    // provided element.
	    return ownerGlobal || global$1;
	});

	// Placeholder of an empty content rectangle.
	var emptyRect = createRectInit(0, 0, 0, 0);
	/**
	 * Converts provided string to a number.
	 *
	 * @param {number|string} value
	 * @returns {number}
	 */
	function toFloat(value) {
	    return parseFloat(value) || 0;
	}
	/**
	 * Extracts borders size from provided styles.
	 *
	 * @param {CSSStyleDeclaration} styles
	 * @param {...string} positions - Borders positions (top, right, ...)
	 * @returns {number}
	 */
	function getBordersSize(styles) {
	    var positions = [];
	    for (var _i = 1; _i < arguments.length; _i++) {
	        positions[_i - 1] = arguments[_i];
	    }
	    return positions.reduce(function (size, position) {
	        var value = styles['border-' + position + '-width'];
	        return size + toFloat(value);
	    }, 0);
	}
	/**
	 * Extracts paddings sizes from provided styles.
	 *
	 * @param {CSSStyleDeclaration} styles
	 * @returns {Object} Paddings box.
	 */
	function getPaddings(styles) {
	    var positions = ['top', 'right', 'bottom', 'left'];
	    var paddings = {};
	    for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {
	        var position = positions_1[_i];
	        var value = styles['padding-' + position];
	        paddings[position] = toFloat(value);
	    }
	    return paddings;
	}
	/**
	 * Calculates content rectangle of provided SVG element.
	 *
	 * @param {SVGGraphicsElement} target - Element content rectangle of which needs
	 *      to be calculated.
	 * @returns {DOMRectInit}
	 */
	function getSVGContentRect(target) {
	    var bbox = target.getBBox();
	    return createRectInit(0, 0, bbox.width, bbox.height);
	}
	/**
	 * Calculates content rectangle of provided HTMLElement.
	 *
	 * @param {HTMLElement} target - Element for which to calculate the content rectangle.
	 * @returns {DOMRectInit}
	 */
	function getHTMLElementContentRect(target) {
	    // Client width & height properties can't be
	    // used exclusively as they provide rounded values.
	    var clientWidth = target.clientWidth, clientHeight = target.clientHeight;
	    // By this condition we can catch all non-replaced inline, hidden and
	    // detached elements. Though elements with width & height properties less
	    // than 0.5 will be discarded as well.
	    //
	    // Without it we would need to implement separate methods for each of
	    // those cases and it's not possible to perform a precise and performance
	    // effective test for hidden elements. E.g. even jQuery's ':visible' filter
	    // gives wrong results for elements with width & height less than 0.5.
	    if (!clientWidth && !clientHeight) {
	        return emptyRect;
	    }
	    var styles = getWindowOf(target).getComputedStyle(target);
	    var paddings = getPaddings(styles);
	    var horizPad = paddings.left + paddings.right;
	    var vertPad = paddings.top + paddings.bottom;
	    // Computed styles of width & height are being used because they are the
	    // only dimensions available to JS that contain non-rounded values. It could
	    // be possible to utilize the getBoundingClientRect if only it's data wasn't
	    // affected by CSS transformations let alone paddings, borders and scroll bars.
	    var width = toFloat(styles.width), height = toFloat(styles.height);
	    // Width & height include paddings and borders when the 'border-box' box
	    // model is applied (except for IE).
	    if (styles.boxSizing === 'border-box') {
	        // Following conditions are required to handle Internet Explorer which
	        // doesn't include paddings and borders to computed CSS dimensions.
	        //
	        // We can say that if CSS dimensions + paddings are equal to the "client"
	        // properties then it's either IE, and thus we don't need to subtract
	        // anything, or an element merely doesn't have paddings/borders styles.
	        if (Math.round(width + horizPad) !== clientWidth) {
	            width -= getBordersSize(styles, 'left', 'right') + horizPad;
	        }
	        if (Math.round(height + vertPad) !== clientHeight) {
	            height -= getBordersSize(styles, 'top', 'bottom') + vertPad;
	        }
	    }
	    // Following steps can't be applied to the document's root element as its
	    // client[Width/Height] properties represent viewport area of the window.
	    // Besides, it's as well not necessary as the <html> itself neither has
	    // rendered scroll bars nor it can be clipped.
	    if (!isDocumentElement(target)) {
	        // In some browsers (only in Firefox, actually) CSS width & height
	        // include scroll bars size which can be removed at this step as scroll
	        // bars are the only difference between rounded dimensions + paddings
	        // and "client" properties, though that is not always true in Chrome.
	        var vertScrollbar = Math.round(width + horizPad) - clientWidth;
	        var horizScrollbar = Math.round(height + vertPad) - clientHeight;
	        // Chrome has a rather weird rounding of "client" properties.
	        // E.g. for an element with content width of 314.2px it sometimes gives
	        // the client width of 315px and for the width of 314.7px it may give
	        // 314px. And it doesn't happen all the time. So just ignore this delta
	        // as a non-relevant.
	        if (Math.abs(vertScrollbar) !== 1) {
	            width -= vertScrollbar;
	        }
	        if (Math.abs(horizScrollbar) !== 1) {
	            height -= horizScrollbar;
	        }
	    }
	    return createRectInit(paddings.left, paddings.top, width, height);
	}
	/**
	 * Checks whether provided element is an instance of the SVGGraphicsElement.
	 *
	 * @param {Element} target - Element to be checked.
	 * @returns {boolean}
	 */
	var isSVGGraphicsElement = (function () {
	    // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement
	    // interface.
	    if (typeof SVGGraphicsElement !== 'undefined') {
	        return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };
	    }
	    // If it's so, then check that element is at least an instance of the
	    // SVGElement and that it has the "getBBox" method.
	    // eslint-disable-next-line no-extra-parens
	    return function (target) { return (target instanceof getWindowOf(target).SVGElement &&
	        typeof target.getBBox === 'function'); };
	})();
	/**
	 * Checks whether provided element is a document element (<html>).
	 *
	 * @param {Element} target - Element to be checked.
	 * @returns {boolean}
	 */
	function isDocumentElement(target) {
	    return target === getWindowOf(target).document.documentElement;
	}
	/**
	 * Calculates an appropriate content rectangle for provided html or svg element.
	 *
	 * @param {Element} target - Element content rectangle of which needs to be calculated.
	 * @returns {DOMRectInit}
	 */
	function getContentRect(target) {
	    if (!isBrowser) {
	        return emptyRect;
	    }
	    if (isSVGGraphicsElement(target)) {
	        return getSVGContentRect(target);
	    }
	    return getHTMLElementContentRect(target);
	}
	/**
	 * Creates rectangle with an interface of the DOMRectReadOnly.
	 * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly
	 *
	 * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.
	 * @returns {DOMRectReadOnly}
	 */
	function createReadOnlyRect(_a) {
	    var x = _a.x, y = _a.y, width = _a.width, height = _a.height;
	    // If DOMRectReadOnly is available use it as a prototype for the rectangle.
	    var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;
	    var rect = Object.create(Constr.prototype);
	    // Rectangle's properties are not writable and non-enumerable.
	    defineConfigurable(rect, {
	        x: x, y: y, width: width, height: height,
	        top: y,
	        right: x + width,
	        bottom: height + y,
	        left: x
	    });
	    return rect;
	}
	/**
	 * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.
	 * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit
	 *
	 * @param {number} x - X coordinate.
	 * @param {number} y - Y coordinate.
	 * @param {number} width - Rectangle's width.
	 * @param {number} height - Rectangle's height.
	 * @returns {DOMRectInit}
	 */
	function createRectInit(x, y, width, height) {
	    return { x: x, y: y, width: width, height: height };
	}

	/**
	 * Class that is responsible for computations of the content rectangle of
	 * provided DOM element and for keeping track of it's changes.
	 */
	var ResizeObservation = /** @class */ (function () {
	    /**
	     * Creates an instance of ResizeObservation.
	     *
	     * @param {Element} target - Element to be observed.
	     */
	    function ResizeObservation(target) {
	        /**
	         * Broadcasted width of content rectangle.
	         *
	         * @type {number}
	         */
	        this.broadcastWidth = 0;
	        /**
	         * Broadcasted height of content rectangle.
	         *
	         * @type {number}
	         */
	        this.broadcastHeight = 0;
	        /**
	         * Reference to the last observed content rectangle.
	         *
	         * @private {DOMRectInit}
	         */
	        this.contentRect_ = createRectInit(0, 0, 0, 0);
	        this.target = target;
	    }
	    /**
	     * Updates content rectangle and tells whether it's width or height properties
	     * have changed since the last broadcast.
	     *
	     * @returns {boolean}
	     */
	    ResizeObservation.prototype.isActive = function () {
	        var rect = getContentRect(this.target);
	        this.contentRect_ = rect;
	        return (rect.width !== this.broadcastWidth ||
	            rect.height !== this.broadcastHeight);
	    };
	    /**
	     * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data
	     * from the corresponding properties of the last observed content rectangle.
	     *
	     * @returns {DOMRectInit} Last observed content rectangle.
	     */
	    ResizeObservation.prototype.broadcastRect = function () {
	        var rect = this.contentRect_;
	        this.broadcastWidth = rect.width;
	        this.broadcastHeight = rect.height;
	        return rect;
	    };
	    return ResizeObservation;
	}());

	var ResizeObserverEntry = /** @class */ (function () {
	    /**
	     * Creates an instance of ResizeObserverEntry.
	     *
	     * @param {Element} target - Element that is being observed.
	     * @param {DOMRectInit} rectInit - Data of the element's content rectangle.
	     */
	    function ResizeObserverEntry(target, rectInit) {
	        var contentRect = createReadOnlyRect(rectInit);
	        // According to the specification following properties are not writable
	        // and are also not enumerable in the native implementation.
	        //
	        // Property accessors are not being used as they'd require to define a
	        // private WeakMap storage which may cause memory leaks in browsers that
	        // don't support this type of collections.
	        defineConfigurable(this, { target: target, contentRect: contentRect });
	    }
	    return ResizeObserverEntry;
	}());

	var ResizeObserverSPI = /** @class */ (function () {
	    /**
	     * Creates a new instance of ResizeObserver.
	     *
	     * @param {ResizeObserverCallback} callback - Callback function that is invoked
	     *      when one of the observed elements changes it's content dimensions.
	     * @param {ResizeObserverController} controller - Controller instance which
	     *      is responsible for the updates of observer.
	     * @param {ResizeObserver} callbackCtx - Reference to the public
	     *      ResizeObserver instance which will be passed to callback function.
	     */
	    function ResizeObserverSPI(callback, controller, callbackCtx) {
	        /**
	         * Collection of resize observations that have detected changes in dimensions
	         * of elements.
	         *
	         * @private {Array<ResizeObservation>}
	         */
	        this.activeObservations_ = [];
	        /**
	         * Registry of the ResizeObservation instances.
	         *
	         * @private {Map<Element, ResizeObservation>}
	         */
	        this.observations_ = new MapShim();
	        if (typeof callback !== 'function') {
	            throw new TypeError('The callback provided as parameter 1 is not a function.');
	        }
	        this.callback_ = callback;
	        this.controller_ = controller;
	        this.callbackCtx_ = callbackCtx;
	    }
	    /**
	     * Starts observing provided element.
	     *
	     * @param {Element} target - Element to be observed.
	     * @returns {void}
	     */
	    ResizeObserverSPI.prototype.observe = function (target) {
	        if (!arguments.length) {
	            throw new TypeError('1 argument required, but only 0 present.');
	        }
	        // Do nothing if current environment doesn't have the Element interface.
	        if (typeof Element === 'undefined' || !(Element instanceof Object)) {
	            return;
	        }
	        if (!(target instanceof getWindowOf(target).Element)) {
	            throw new TypeError('parameter 1 is not of type "Element".');
	        }
	        var observations = this.observations_;
	        // Do nothing if element is already being observed.
	        if (observations.has(target)) {
	            return;
	        }
	        observations.set(target, new ResizeObservation(target));
	        this.controller_.addObserver(this);
	        // Force the update of observations.
	        this.controller_.refresh();
	    };
	    /**
	     * Stops observing provided element.
	     *
	     * @param {Element} target - Element to stop observing.
	     * @returns {void}
	     */
	    ResizeObserverSPI.prototype.unobserve = function (target) {
	        if (!arguments.length) {
	            throw new TypeError('1 argument required, but only 0 present.');
	        }
	        // Do nothing if current environment doesn't have the Element interface.
	        if (typeof Element === 'undefined' || !(Element instanceof Object)) {
	            return;
	        }
	        if (!(target instanceof getWindowOf(target).Element)) {
	            throw new TypeError('parameter 1 is not of type "Element".');
	        }
	        var observations = this.observations_;
	        // Do nothing if element is not being observed.
	        if (!observations.has(target)) {
	            return;
	        }
	        observations.delete(target);
	        if (!observations.size) {
	            this.controller_.removeObserver(this);
	        }
	    };
	    /**
	     * Stops observing all elements.
	     *
	     * @returns {void}
	     */
	    ResizeObserverSPI.prototype.disconnect = function () {
	        this.clearActive();
	        this.observations_.clear();
	        this.controller_.removeObserver(this);
	    };
	    /**
	     * Collects observation instances the associated element of which has changed
	     * it's content rectangle.
	     *
	     * @returns {void}
	     */
	    ResizeObserverSPI.prototype.gatherActive = function () {
	        var _this = this;
	        this.clearActive();
	        this.observations_.forEach(function (observation) {
	            if (observation.isActive()) {
	                _this.activeObservations_.push(observation);
	            }
	        });
	    };
	    /**
	     * Invokes initial callback function with a list of ResizeObserverEntry
	     * instances collected from active resize observations.
	     *
	     * @returns {void}
	     */
	    ResizeObserverSPI.prototype.broadcastActive = function () {
	        // Do nothing if observer doesn't have active observations.
	        if (!this.hasActive()) {
	            return;
	        }
	        var ctx = this.callbackCtx_;
	        // Create ResizeObserverEntry instance for every active observation.
	        var entries = this.activeObservations_.map(function (observation) {
	            return new ResizeObserverEntry(observation.target, observation.broadcastRect());
	        });
	        this.callback_.call(ctx, entries, ctx);
	        this.clearActive();
	    };
	    /**
	     * Clears the collection of active observations.
	     *
	     * @returns {void}
	     */
	    ResizeObserverSPI.prototype.clearActive = function () {
	        this.activeObservations_.splice(0);
	    };
	    /**
	     * Tells whether observer has active observations.
	     *
	     * @returns {boolean}
	     */
	    ResizeObserverSPI.prototype.hasActive = function () {
	        return this.activeObservations_.length > 0;
	    };
	    return ResizeObserverSPI;
	}());

	// Registry of internal observers. If WeakMap is not available use current shim
	// for the Map collection as it has all required methods and because WeakMap
	// can't be fully polyfilled anyway.
	var observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();
	/**
	 * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation
	 * exposing only those methods and properties that are defined in the spec.
	 */
	var ResizeObserver = /** @class */ (function () {
	    /**
	     * Creates a new instance of ResizeObserver.
	     *
	     * @param {ResizeObserverCallback} callback - Callback that is invoked when
	     *      dimensions of the observed elements change.
	     */
	    function ResizeObserver(callback) {
	        if (!(this instanceof ResizeObserver)) {
	            throw new TypeError('Cannot call a class as a function.');
	        }
	        if (!arguments.length) {
	            throw new TypeError('1 argument required, but only 0 present.');
	        }
	        var controller = ResizeObserverController.getInstance();
	        var observer = new ResizeObserverSPI(callback, controller, this);
	        observers.set(this, observer);
	    }
	    return ResizeObserver;
	}());
	// Expose public methods of ResizeObserver.
	[
	    'observe',
	    'unobserve',
	    'disconnect'
	].forEach(function (method) {
	    ResizeObserver.prototype[method] = function () {
	        var _a;
	        return (_a = observers.get(this))[method].apply(_a, arguments);
	    };
	});

	var index = (function () {
	    // Export existing implementation if available.
	    if (typeof global$1.ResizeObserver !== 'undefined') {
	        return global$1.ResizeObserver;
	    }
	    return ResizeObserver;
	})();

	var __assign$4 = (undefined && undefined.__assign) || function () {
	    __assign$4 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4.apply(this, arguments);
	};
	/**
	 * @private
	 */
	var isRefTarget = function (target) {
	    return !!target &&
	        typeof target.current !==
	            "undefined";
	};
	/**
	 * @private
	 */
	var isFunctionTarget = function (target) {
	    return typeof target === "function";
	};
	/**
	 * A utility function to get the current resize observer element.
	 *
	 * @private
	 */
	function getResizeObserverTarget(target) {
	    if (isRefTarget(target)) {
	        return target.current;
	    }
	    if (isFunctionTarget(target)) {
	        return target();
	    }
	    if (typeof target === "string") {
	        return document.querySelector(target);
	    }
	    return target;
	}
	/**
	 *
	 * @private
	 */
	function isHeightChange(prevSize, nextSize) {
	    return (!prevSize ||
	        prevSize.height !== nextSize.height ||
	        prevSize.scrollHeight !== nextSize.scrollHeight);
	}
	/**
	 *
	 * @private
	 */
	function isWidthChange(prevSize, nextSize) {
	    return (!prevSize ||
	        prevSize.width !== nextSize.width ||
	        prevSize.scrollWidth !== nextSize.scrollWidth);
	}
	/**
	 * A hook that is used to trigger esize events when a target element is resized
	 * via CSS or other changes.
	 *
	 * @param options The resize observer options.
	 */
	function useResizeObserver(_a) {
	    var _b = _a.disableHeight, disableHeight = _b === void 0 ? false : _b, _c = _a.disableWidth, disableWidth = _c === void 0 ? false : _c, onResize = _a.onResize, target = _a.target;
	    React.useEffect(function () {
	        if (disableHeight && disableWidth) {
	            return;
	        }
	        var resizeTarget = getResizeObserverTarget(target);
	        if (!resizeTarget) {
	            return;
	        }
	        var prevSize;
	        var observer = new index(function (entries) {
	            for (var i = 0; i < entries.length; i += 1) {
	                var entry = entries[i];
	                var target_1 = entry.target;
	                var _a = entry.contentRect, height = _a.height, width = _a.width;
	                var scrollHeight = target_1.scrollHeight, scrollWidth = target_1.scrollWidth;
	                var nextSize = {
	                    height: height,
	                    width: width,
	                    scrollHeight: scrollHeight,
	                    scrollWidth: scrollWidth,
	                };
	                var isNewHeight = isHeightChange(prevSize, nextSize);
	                var isNewWidth = isWidthChange(prevSize, nextSize);
	                prevSize = nextSize;
	                if ((isNewHeight && !disableHeight) || (isNewWidth && !disableWidth)) {
	                    onResize(__assign$4(__assign$4({}, nextSize), { element: target_1 }));
	                }
	            }
	        });
	        observer.observe(resizeTarget);
	        return function () {
	            observer.disconnect();
	        };
	    }, [target, onResize, disableHeight, disableWidth]);
	}

	var __assign$5 = (undefined && undefined.__assign) || function () {
	    __assign$5 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5.apply(this, arguments);
	};
	var __rest$3 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$2 = bem("rmd-grid-list");
	var GridListCell = React.forwardRef(function GridListCell(_a, ref) {
	    var className = _a.className, children = _a.children, _b = _a.square, square = _b === void 0 ? false : _b, _c = _a.clone, clone = _c === void 0 ? false : _c, props = __rest$3(_a, ["className", "children", "square", "clone"]);
	    var cellClassName = classnames(block$2("cell", { square: square }), className);
	    if (clone && React.isValidElement(children)) {
	        var child = React.Children.only(children);
	        return React.cloneElement(child, {
	            className: classnames(cellClassName, child.props.className),
	        });
	    }
	    return (React__default.createElement("div", __assign$5({}, props, { ref: ref, className: cellClassName }), children));
	});
	{
	    try {
	        var PropTypes$5 = require("prop-types");
	        GridListCell.propTypes = {
	            clone: PropTypes$5.bool,
	            square: PropTypes$5.bool,
	            className: PropTypes$5.string,
	            children: PropTypes$5.node,
	        };
	    }
	    catch (e) { }
	}

	var cached = {
	    height: undefined,
	    width: undefined,
	};
	/**
	 * This will return the scrollbar size for a specific OS by creating a
	 * temporary element to compare the height/width between it's inner element and
	 * it's own height/width when scrollbars are enabled. This is useful when your
	 * height/width calculations need to exclude scrollbars since they are included
	 * by default but content can't be shown underneath them for for static
	 * elements.
	 *
	 * Note: This will return `0` on Mac OS with the default "Only show scrollbars
	 * when scrolling" which is to be expected. These scrollbars overlay the content
	 * and actually don't take up height/width real estate.
	 *
	 * @see https://stackoverflow.com/a/13382873
	 * @param type Either the string "height" or "width" to determine which size to
	 * get
	 * @param forced Boolean if the scrollbar height/width should be force updated. When
	 * this is false, the "cached" value will be returned immediately instead
	 * @return the current scrollbar width or -1 if running this on the server
	 */
	function scrollbarSize(type, forced) {
	    if (type === void 0) { type = "width"; }
	    if (forced === void 0) { forced = false; }
	    /* istanbul ignore if */
	    if (typeof window === "undefined") {
	        return -1;
	    }
	    var value = cached[type];
	    if (!forced && typeof value === "number") {
	        return value;
	    }
	    var outer = document.createElement("div");
	    outer.style.visibility = "hidden";
	    outer.style.overflow = "scroll";
	    document.body.appendChild(outer);
	    var inner = document.createElement("div");
	    outer.appendChild(inner);
	    var offsetType = type === "width" ? "offsetWidth" : "offsetHeight";
	    // the scrollbar width can be determined by comparing the width of the parent
	    // element that has scrollbars to the child element that does not.
	    value = outer[offsetType] - inner[offsetType];
	    cached[type] = value;
	    document.body.removeChild(outer);
	    return value;
	}

	var __assign$6 = (undefined && undefined.__assign) || function () {
	    __assign$6 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6.apply(this, arguments);
	};
	var __rest$4 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This is the css variable that is used store the current size of each cell.
	 */
	var CELL_SIZE_VAR = "--rmd-cell-size";
	/**
	 * This is the css variable that is used store the current margin of each cell.
	 */
	var CELL_MARGIN_VAR = "--rmd-cell-margin";
	var block$3 = bem("rmd-grid-list");
	var isRenderFunction = function (children) { return typeof children === "function"; };
	/**
	 * The `GridList` component is a different way to render a list of data where
	 * the number of columns is dynamic and based on the max-width for each cell.
	 * Instead of setting a percentage width to each cell based on the number of
	 * columns, this will dynamically add columns to fill up the remaining space and
	 * have each cell grow up to a set max-width. A really good use-case for this is
	 * displaying a list of images or thumbnails and allowing the user to see a full
	 * screen preview once selected/clicked.
	 */
	var GridList = React.forwardRef(function GridList(_a, forwardedRef) {
	    var _b;
	    var style = _a.style, className = _a.className, children = _a.children, _c = _a.clone, clone = _c === void 0 ? false : _c, _d = _a.wrapOnly, wrapOnly = _d === void 0 ? false : _d, cellMargin = _a.cellMargin, defaultSize = _a.defaultSize, _e = _a.maxCellSize, maxCellSize = _e === void 0 ? 150 : _e, _f = _a.containerPadding, containerPadding = _f === void 0 ? 16 : _f, _g = _a.disableHeightObserver, disableHeightObserver = _g === void 0 ? false : _g, _h = _a.disableWidthObserver, disableWidthObserver = _h === void 0 ? false : _h, props = __rest$4(_a, ["style", "className", "children", "clone", "wrapOnly", "cellMargin", "defaultSize", "maxCellSize", "containerPadding", "disableHeightObserver", "disableWidthObserver"]);
	    var _j = React.useState(defaultSize || { columns: -1, cellWidth: maxCellSize }), gridSize = _j[0], setGridSize = _j[1];
	    var ref = React.useRef(null);
	    var recalculate = React.useCallback(function () {
	        if (!ref.current) {
	            return;
	        }
	        // need to use rect instead of offsetWidth since we need decimal precision
	        // for the width since offsetWidth is basically Math.ceil(width). the
	        // calculations for max columns will be off on high-pixel-density monitors
	        // or some zoom levels.
	        var width = ref.current.getBoundingClientRect().width;
	        width -= containerPadding;
	        // just need to see if there is a scrollbar visible and subtract that width.
	        // don't need decimal precision here since both values will be rounded
	        if (ref.current.offsetHeight < ref.current.scrollHeight) {
	            width -= scrollbarSize("width");
	        }
	        var columns = Math.ceil(width / maxCellSize);
	        setGridSize({ cellWidth: width / columns, columns: columns });
	    }, [maxCellSize, containerPadding]);
	    var refHandler = React.useCallback(function (instance) {
	        applyRef(instance, forwardedRef);
	        ref.current = instance;
	        if (instance) {
	            recalculate();
	        }
	    }, [forwardedRef, recalculate]);
	    useResizeObserver({
	        disableHeight: disableHeightObserver,
	        disableWidth: disableWidthObserver,
	        onResize: recalculate,
	        target: ref,
	    });
	    var mergedStyle = __assign$6(__assign$6({}, style), (_b = {}, _b[CELL_SIZE_VAR] = gridSize.cellWidth + "px", _b[CELL_MARGIN_VAR] = cellMargin || undefined, _b));
	    var content = null;
	    if (isRenderFunction(children)) {
	        content = children(gridSize);
	    }
	    else if (clone || wrapOnly) {
	        content = React.Children.map(children, function (child) { return child && React__default.createElement(GridListCell, { clone: clone }, child); });
	    }
	    else {
	        content = children;
	    }
	    return (React__default.createElement("div", __assign$6({}, props, { ref: refHandler, style: mergedStyle, className: classnames(block$3(), className) }), content));
	});
	{
	    try {
	        var PropTypes$6 = require("prop-types");
	        GridList.propTypes = {
	            style: PropTypes$6.object,
	            clone: PropTypes$6.bool,
	            wrapOnly: PropTypes$6.bool,
	            className: PropTypes$6.string,
	            children: PropTypes$6.oneOfType([PropTypes$6.func, PropTypes$6.node]),
	            cellMargin: PropTypes$6.string,
	            maxCellSize: PropTypes$6.number,
	            defaultSize: PropTypes$6.oneOfType([
	                PropTypes$6.shape({
	                    columns: PropTypes$6.number.isRequired,
	                    cellWidth: PropTypes$6.number.isRequired,
	                }),
	                PropTypes$6.func,
	            ]),
	            containerPadding: PropTypes$6.number,
	            disableHeightObserver: PropTypes$6.bool,
	            disableWidthObserver: PropTypes$6.bool,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * Attempts to find the first match index for a list of values that starts with
	 * the provided query string and is within the start and end indexes. If no
	 * matches are found, -1 will be returned instead.
	 *
	 * Since this is normally coming from a keydown event, the query *must* be a
	 * string of all capital letters to work as each value will be converted to
	 * uppercase before checking.
	 *
	 * @param value The current query string to find within the values
	 * @param values The list of values to search within
	 * @param startIndex The start index for the search
	 * @param endIndex The end index for the search
	 * @private
	 */
	function findMatchInRange(value, values, startIndex, endIndex) {
	    value = value.toUpperCase();
	    for (var i = startIndex; i < endIndex; i += 1) {
	        var content = values[i];
	        if (content.toUpperCase().indexOf(value) === 0) {
	            return i;
	        }
	    }
	    return -1;
	}
	/**
	 * A function that is used to find the next match index within a list of values
	 * by comparing the start values ignoring case.
	 *
	 * If a match can not be found from the search string, `-1` will be returned.
	 * The search value is self-matchable by default, but it can be omitted by
	 * disabling the `isSelfMatchable` argument. This will make a self-match return
	 * `-1`.
	 *
	 * @param value The current search value
	 * @param values A list of values to search within
	 * @param startIndex The index within the values list to start the search from
	 * @param isSelfMatchable Boolean if the current index can be included in the
	 * search
	 * @private
	 */
	function findMatchIndex(value, values, startIndex, isSelfMatchable) {
	    if (isSelfMatchable === void 0) { isSelfMatchable = true; }
	    var index = findMatchInRange(value, values, startIndex + 1, values.length);
	    if (index === -1) {
	        var endIndex = startIndex + (isSelfMatchable ? 1 : 0);
	        index = findMatchInRange(value, values, 0, endIndex);
	    }
	    return index;
	}

	var __assign$7 = (undefined && undefined.__assign) || function () {
	    __assign$7 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7.apply(this, arguments);
	};
	/**
	 * This is normally used for reusable shareable configs that have multiple
	 * shared options with default values that should be used. This basically works
	 * just like `defaultProps` in react.
	 *
	 * @internal
	 * @param optional The original object that has the optional/omitted values
	 * @param required The required default values that should be used to fill the
	 * optional object with
	 * @return a new object with both the values of the optional and required
	 * objects but use the optional values if they were defined.
	 */
	function defaults(optional, required) {
	    var keys = Object.keys(required);
	    return keys.reduce(function (result, key) {
	        if (typeof result[key] === "undefined") {
	            result[key] = required[key];
	        }
	        return result;
	    }, __assign$7({}, optional));
	}

	/**
	 * This is a small util that is used to transform a search string with common
	 * patterns.
	 *
	 * @param value The string to transform
	 * @param lowercase Boolean if the value should be lowercased for
	 * case-insensitive searches
	 * @param trim Boolean if the leading and trailing whitespace should be trimmed
	 * @param ignoreWhitespace Boolean if all whitespace should be ignored. This
	 * will take precedence over the `trim` parameter if set to true.
	 * @return The transformed search string
	 * @private
	 */
	function getSearchString(value, lowercase, trim, ignoreWhitespace) {
	    if (lowercase === void 0) { lowercase = false; }
	    if (trim === void 0) { trim = false; }
	    if (ignoreWhitespace === void 0) { ignoreWhitespace = false; }
	    if (lowercase) {
	        value = value.toLowerCase();
	    }
	    if (ignoreWhitespace) {
	        value = value.replace(/\s/g, "");
	    }
	    else if (trim) {
	        value = value.trim();
	    }
	    return value;
	}
	/**
	 * The default implementation of the getItemValue search option that will
	 * attempt to "stringify" any unknown item as a string.
	 *
	 * @param item The current item to transform
	 * @param valueKey The key to use that should hold the value if the item is an
	 * object
	 * @return the item as a string
	 * @private
	 */
	function getItemValue(item, valueKey) {
	    if (valueKey === void 0) { valueKey = "value"; }
	    switch (typeof item) {
	        case "string":
	            return item;
	        case "number":
	            return Number.isNaN(item) ? "" : "" + item;
	        case "function":
	            return getItemValue(item(), valueKey);
	        case "object":
	            return item
	                ? getItemValue(item[valueKey], valueKey)
	                : "";
	        default:
	            return "";
	    }
	}
	var DEFAULT_GET_ITEM_VALUE = getItemValue;
	var DEFAULT_VALUE_KEY = "value";
	var DEFAULT_TRIM = true;
	var DEFAULT_IGNORE_WHITESPACE = false;
	var DEFAULT_SEARCH_RESET_TIME = 500;
	var DEFAULT_SEARCH_OPTIONS = {
	    getItemValue: DEFAULT_GET_ITEM_VALUE,
	    valueKey: DEFAULT_VALUE_KEY,
	    trim: DEFAULT_TRIM,
	    ignoreWhitespace: DEFAULT_IGNORE_WHITESPACE,
	};

	/**
	 * Filters a list by ensuring that all items contain the query string in order
	 * anywhere in it's own value.
	 *
	 * @param query The current query string
	 * @param searchable The list of searchable items that should be filtered
	 * @param options All the search options to use
	 * @return A filtered list of all the searchable items based on the query
	 * string.
	 */
	function caseInsensitiveFilter(query, searchable, options) {
	    if (options === void 0) { options = {}; }
	    var _a = defaults(options, DEFAULT_SEARCH_OPTIONS), getItemValue = _a.getItemValue, valueKey = _a.valueKey, trim = _a.trim, ignoreWhitespace = _a.ignoreWhitespace, _b = _a.startsWith, startsWith = _b === void 0 ? false : _b;
	    query = getSearchString(query, true, trim, ignoreWhitespace);
	    if (!query || !searchable.length) {
	        return searchable;
	    }
	    return searchable.filter(function (item) {
	        var value = getSearchString(getItemValue(item, valueKey), true, trim, ignoreWhitespace);
	        if (startsWith) {
	            return value.indexOf(query) === 0;
	        }
	        return value.indexOf(query) !== -1;
	    });
	}

	/**
	 * Creates an "amazing" regular expression that matches the letters in order and
	 * escapes any letters that could be part of a regex. This should normally be
	 * used in fuzzy filters or determining fuzzy matches.
	 *
	 * @param query The query string to convert into a "fuzzy" regular expression
	 * @return The "fuzzy" regular expression that can be used to determine matches.
	 */
	function getFuzzyRegExp(query) {
	    return new RegExp(("" + query)
	        .split("")
	        .join("\\w*")
	        .replace(/(\(|\||\)|\\(?!w\*)|\[|\|-|\.|\^|\+|\$|\?|^(?!w)\*)/g, "\\$1")
	        // Couldn't get the matching of two '*' working, so replace them here..
	        .replace(/\*\*/g, "*\\*"), "i");
	}

	/**
	 * Filters a list by using a fuzzy search "algorithm" (huge double quotes on
	 * algorithm). The fuzzy search will just ensure that all the letters in the
	 * query string appear in-order for all the remaining items. However, the
	 * letters *do not need to be consecutive*.
	 *
	 * @param query The current query string
	 * @param searchable The list of searchable items that should be filtered
	 * @param options All the search options to use
	 * @return A filtered list of all the searchable items based on the query
	 * string.
	 */
	function fuzzyFilter(query, searchable, options) {
	    if (options === void 0) { options = {}; }
	    var _a = defaults(options, DEFAULT_SEARCH_OPTIONS), getItemValue = _a.getItemValue, valueKey = _a.valueKey, trim = _a.trim, ignoreWhitespace = _a.ignoreWhitespace;
	    query = getSearchString(query, false, trim, ignoreWhitespace);
	    if (!searchable.length || !query) {
	        return searchable;
	    }
	    var queryRegExp = getFuzzyRegExp(query);
	    return searchable.filter(function (item) {
	        var value = getSearchString(getItemValue(item, valueKey), false, trim, ignoreWhitespace);
	        return value.length && value.match(queryRegExp);
	    });
	}

	/**
	 * This is a simple `array.find` implementation that will work for any
	 * searchable item type and return the first item that starts with the current
	 * query string ignoring case.
	 *
	 * @param query The current query string to use to match with
	 * @param searchable The list of searchable items
	 * @param options The additional search options available.
	 * @return the found item in the searchable list or null
	 */
	function findIgnoreCase(query, searchable, options) {
	    if (options === void 0) { options = {}; }
	    var _a = defaults(options, DEFAULT_SEARCH_OPTIONS), getItemValue = _a.getItemValue, valueKey = _a.valueKey, trim = _a.trim, ignoreWhitespace = _a.ignoreWhitespace;
	    query = getSearchString(query, true, trim, ignoreWhitespace);
	    if (!query.length || !searchable.length) {
	        return null;
	    }
	    var found = searchable.find(function (item) {
	        var value = getSearchString(getItemValue(item, valueKey), true, trim, ignoreWhitespace);
	        return value.indexOf(query) === 0;
	    });
	    return typeof found === "number" ? found : found || null;
	}

	/**
	 * Creates a temporary value that gets reset every `x`ms back to the provided
	 * default value. This is useful when doing keyboard searching or other
	 * interactions.
	 *
	 * NOTE: This does not force a re-render when the value changes and instead uses
	 * a ref value instead.
	 *
	 * @typeparam T the type for the value
	 * @param defaultValue The default value to use. Each time the reset timeout is
	 * triggered, this value will be set again.
	 * @param resetTime The amount of time before the value is reset back to the
	 * default value
	 */
	function useTempValue(defaultValue, resetTime) {
	    if (resetTime === void 0) { resetTime = 500; }
	    var value = React.useRef(defaultValue);
	    var timeout = React.useRef();
	    var resetValue = React.useCallback(function () {
	        window.clearTimeout(timeout.current);
	        value.current = defaultValue;
	    }, [defaultValue]);
	    var setValue = React.useCallback(function (nextValue) {
	        value.current = nextValue;
	        window.clearTimeout(timeout.current);
	        timeout.current = window.setTimeout(resetValue, resetTime);
	    }, [resetTime, resetValue]);
	    return [value, setValue, resetValue];
	}

	/**
	 * Adds the accessibility functionality to search a list of items as the user
	 * types to trigger `aria-activedescendant` focus or manual DOM focus events.
	 */
	function useKeyboardSearch(_a) {
	    var items = _a.items, onChange = _a.onChange, onKeyDown = _a.onKeyDown, _b = _a.resetTime, resetTime = _b === void 0 ? DEFAULT_SEARCH_RESET_TIME : _b, searchIndex = _a.searchIndex, _c = _a.valueKey, valueKey = _c === void 0 ? DEFAULT_VALUE_KEY : _c, _d = _a.getItemValue, getItemValue = _d === void 0 ? DEFAULT_GET_ITEM_VALUE : _d, _e = _a.findMatchIndex, findMatchIndex$1 = _e === void 0 ? findMatchIndex : _e;
	    var _f = useTempValue("", resetTime), value = _f[0], setValue = _f[1];
	    var values = React.useMemo(function () { return items.map(function (item) { return getItemValue(item, valueKey); }); }, [items, getItemValue, valueKey]);
	    var handleKeyDown = React.useCallback(function (event) {
	        if (onKeyDown) {
	            onKeyDown(event);
	        }
	        var key = event.key, altKey = event.altKey, ctrlKey = event.ctrlKey, metaKey = event.metaKey;
	        if (altKey ||
	            ctrlKey ||
	            metaKey ||
	            key.length > 1 ||
	            (!value.current && key === " ")) {
	            // might need to change this later if other languages have non-meta keys
	            // that are more than 1 letter
	            return;
	        }
	        var nextValue = key;
	        if (value.current !== key) {
	            nextValue = "" + value.current + key;
	        }
	        setValue(nextValue);
	        var index = findMatchIndex$1(nextValue, values, searchIndex, true);
	        // don't want to trigger change events if the search didn't match anything
	        // since you normally don't really care about failed matches
	        if (index === searchIndex || index === -1) {
	            return;
	        }
	        var data = {
	            index: index,
	            item: items[index],
	            items: items,
	            query: nextValue,
	            target: event.currentTarget,
	        };
	        onChange(data);
	    }, [
	        searchIndex,
	        findMatchIndex$1,
	        items,
	        onChange,
	        onKeyDown,
	        setValue,
	        value,
	        values,
	    ]);
	    return handleKeyDown;
	}

	var __assign$8 = (undefined && undefined.__assign) || function () {
	    __assign$8 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8.apply(this, arguments);
	};
	/**
	 * This component should be mounted near the top of your app as it will keep
	 * track of the current app size based on the provided breakpoint widths.
	 */
	function AppSizeListener(_a) {
	    var children = _a.children, onChange = _a.onChange, _b = _a.phoneMaxWidth, phoneMaxWidth = _b === void 0 ? DEFAULT_PHONE_MAX_WIDTH : _b, _c = _a.tabletMinWidth, tabletMinWidth = _c === void 0 ? DEFAULT_TABLET_MIN_WIDTH : _c, _d = _a.tabletMaxWidth, tabletMaxWidth = _d === void 0 ? DEFAULT_TABLET_MAX_WIDTH : _d, _e = _a.desktopMinWidth, desktopMinWidth = _e === void 0 ? DEFAULT_DESKTOP_MIN_WIDTH : _e, _f = _a.desktopLargeMinWidth, desktopLargeMinWidth = _f === void 0 ? DEFAULT_DESKTOP_LARGE_MIN_WIDTH : _f, _g = _a.defaultSize, defaultSize = _g === void 0 ? DEFAULT_APP_SIZE : _g;
	    var appSize = useAppSizeMedia({
	        phoneMaxWidth: phoneMaxWidth,
	        tabletMaxWidth: tabletMaxWidth,
	        tabletMinWidth: tabletMinWidth,
	        desktopMinWidth: desktopMinWidth,
	        desktopLargeMinWidth: desktopLargeMinWidth,
	        defaultSize: defaultSize,
	    });
	    var lastValue = React.useRef(appSize);
	    React.useEffect(function () {
	        // trigger the onChange prop on mount only if there is a difference between
	        // the defaultSize and the mounted size.
	        if (onChange &&
	            (defaultSize.isPhone !== appSize.isPhone ||
	                defaultSize.isTablet !== appSize.isTablet ||
	                defaultSize.isDesktop !== appSize.isDesktop ||
	                defaultSize.isLargeDesktop !== appSize.isLargeDesktop ||
	                defaultSize.isLandscape !== appSize.isLandscape)) {
	            onChange(appSize, defaultSize);
	        }
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    React.useEffect(function () {
	        if (lastValue.current !== appSize) {
	            if (onChange) {
	                onChange(appSize, lastValue.current);
	            }
	            lastValue.current = appSize;
	        }
	    });
	    var value = React.useMemo(function () { return (__assign$8(__assign$8({}, appSize), { __initialized: true })); }, [appSize]);
	    return (React__default.createElement(AppSizeContext.Provider, { value: value }, children));
	}
	{
	    try {
	        var PropTypes$7 = require("prop-types");
	        var querySize = PropTypes$7.oneOfType([PropTypes$7.string, PropTypes$7.number]);
	        AppSizeListener.propTypes = {
	            children: PropTypes$7.node.isRequired,
	            onChange: PropTypes$7.func,
	            phoneMaxWidth: querySize,
	            tabletMinWidth: querySize,
	            tabletMaxWidth: querySize,
	            desktopMinWidth: querySize,
	            desktopLargeMinWidth: querySize,
	            defaultSize: PropTypes$7.shape({
	                isPhone: PropTypes$7.bool.isRequired,
	                isTablet: PropTypes$7.bool.isRequired,
	                isDesktop: PropTypes$7.bool.isRequired,
	                isLargeDesktop: PropTypes$7.bool.isRequired,
	                isLandscape: PropTypes$7.bool.isRequired,
	            }),
	        };
	    }
	    catch (e) { }
	}

	/**
	 * The resize observer is used to track the size changes for a single element in
	 * a page.  This is a bit different than a normal `ResizeListener` since it does
	 * not rely on entire page size changes.
	 */
	function ResizeObserver$1(_a) {
	    var _b = _a.disableHeight, disableHeight = _b === void 0 ? false : _b, _c = _a.disableWidth, disableWidth = _c === void 0 ? false : _c, className = _a.className, _d = _a.component, Component = _d === void 0 ? "span" : _d, target = _a.target, onResize = _a.onResize;
	    var _e = React.useState(null), element = _e[0], setElement = _e[1];
	    useResizeObserver({
	        disableHeight: disableHeight,
	        disableWidth: disableWidth,
	        target: target || element,
	        onResize: onResize,
	    });
	    var ref = React.useCallback(function (instance) {
	        if (!instance) {
	            setElement(null);
	            return;
	        }
	        setElement(instance.parentElement);
	    }, []);
	    if (target === null || target) {
	        return null;
	    }
	    return React__default.createElement(Component, { className: className, "aria-hidden": "true", ref: ref });
	}
	{
	    try {
	        var PropTypes$8 = require("prop-types");
	        ResizeObserver$1.propTypes = {
	            disableHeight: PropTypes$8.bool,
	            disableWidth: PropTypes$8.bool,
	            className: PropTypes$8.string,
	            component: PropTypes$8.oneOfType([
	                // workaround for Typescript since PropTypes.string throws WeakValidationMap error
	                // but this component only supports string components
	                PropTypes$8.string,
	            ]),
	            target: PropTypes$8.oneOfType([
	                PropTypes$8.string,
	                PropTypes$8.func,
	                PropTypes$8.object,
	            ]),
	        };
	    }
	    catch (e) { }
	}

	/**
	 * This is a simple hook that will attach a throttled resize event listener when
	 * mounted, and detach when it unmounts.
	 *
	 * This hook only works for entire app resize events. If you are looking for
	 * specific element resize events, check out the `ResizeObserver` component or
	 * `useReiszeObserver` hook instead.
	 */
	function useResizeListener(_a) {
	    var onResize = _a.onResize, options = _a.options, immediate = _a.immediate, _b = _a.enabled, enabled = _b === void 0 ? true : _b;
	    var callback = useRefCache(onResize);
	    React.useEffect(function () {
	        if (!enabled) {
	            return;
	        }
	        var eventHandler = delegateEvent("resize", window, true, options);
	        var handler = function (event) { return callback.current(event); };
	        eventHandler.add(handler);
	        if (immediate && typeof window !== "undefined") {
	            window.dispatchEvent(new UIEvent("resize"));
	        }
	        return function () {
	            eventHandler.remove(handler);
	        };
	        // disabled since useRefCache for callback and don't want immediate to
	        // re-trigger it.
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [options, enabled]);
	}

	/**
	 * This is a simple component that will attach a throttled resize event listener
	 * when mounted, and detach when it unmounts.
	 *
	 * This component only works for entire app resize events. If you are looking
	 * for specific element resize events, check out the `ResizeObserver` component
	 * instead.
	 */
	function ResizeListener(_a) {
	    var onResize = _a.onResize, options = _a.options, _b = _a.immediate, immediate = _b === void 0 ? typeof window !== "undefined" : _b;
	    useResizeListener({ onResize: onResize, options: options, immediate: immediate, enabled: true });
	    return null;
	}
	{
	    try {
	        var PropTypes$9 = require("prop-types");
	        ResizeListener.propTypes = {
	            onResize: PropTypes$9.func.isRequired,
	            options: PropTypes$9.object,
	            immediate: PropTypes$9.bool,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * A simple component that will render the children only when the app is
	 * considered in mobile mode via the `AppSizeContext`. A mobile view will be
	 * true for both phones and tablets.
	 */
	var MobileOnly = function (props) {
	    var _a = props, children = _a.children, fallback = _a.fallback;
	    var _b = useAppSize(), isPhone = _b.isPhone, isTablet = _b.isTablet;
	    if (isPhone || isTablet) {
	        return children;
	    }
	    return fallback;
	};
	/**
	 * A simple component that will render the children only when the app is
	 * considered in phone mode via the `AppSizeContext`.
	 */
	var PhoneOnly = function (props) {
	    var _a = props, children = _a.children, fallback = _a.fallback;
	    var isPhone = useAppSize().isPhone;
	    if (isPhone) {
	        return children;
	    }
	    return fallback;
	};
	/**
	 * A simple component that will render the children only when the app is
	 * considered in tablet mode via the `AppSizeContext`.
	 */
	var TabletOnly = function (props) {
	    var _a = props, children = _a.children, fallback = _a.fallback;
	    var isTablet = useAppSize().isTablet;
	    if (isTablet) {
	        return children;
	    }
	    return fallback;
	};
	/**
	 * A simple component that will render the children only when the app is
	 * considered in desktop mode via the `AppSizeContext`.
	 */
	var DesktopOnly = function (props) {
	    var _a = props, children = _a.children, fallback = _a.fallback;
	    var isDesktop = useAppSize().isDesktop;
	    if (isDesktop) {
	        return children;
	    }
	    return fallback;
	};
	var defaultProps = {
	    fallback: null,
	};
	MobileOnly.defaultProps = defaultProps;
	PhoneOnly.defaultProps = defaultProps;
	TabletOnly.defaultProps = defaultProps;
	DesktopOnly.defaultProps = defaultProps;

	/**
	 * Attempts to find a sizing container based on the provided HTMLElement. By default, the sizing
	 * element will just be the provided element unless:
	 * - the item has a known role within react-md that can target known classes
	 * - the item has a `data-sizing-selector` attribute that is a valid query selector for the nested
	 * item.
	 *
	 * NOTE: The `data-sizing-selector` will be run from the current element instead of the `document`.
	 *
	 * @param el The element to find a sizing container for.
	 * @return the sizing container relative to the provided element, or `null` if none
	 * could be found.
	 * @throws This error will be thrown if using the `data-query-selector` and the query
	 * selector does not return an element on the page.
	 */
	function findSizingContainer(el) {
	    if (!el) {
	        return null;
	    }
	    if (/(tree|list)item/.test(el.getAttribute("role") || "")) {
	        var content = el.querySelector(".rmd-tree-item__content, .rmd-item-text");
	        if (content) {
	            return content;
	        }
	    }
	    else if (el.getAttribute("type") === "file") {
	        var label = document.querySelector("[for=\"" + el.id + "\"]");
	        if (label) {
	            return label;
	        }
	    }
	    var data = el.getAttribute("data-sizing-selector");
	    if (data) {
	        var content = el.querySelector(data);
	        if (content) {
	            return content;
	        }
	        {
	            throw new Error("Unable to find a child element using the `data-sizing-selector`");
	        }
	    }
	    return el;
	}

	/**
	 * This is a simple wrapper to get the view width or view hieght.
	 *
	 * @param direction Either the "height" or "width" string to get that dimension
	 * @return the view width or view height.
	 */
	function getViewportSize(direction) {
	    var de = document.documentElement || { clientHeight: 0, clientWidth: 0 };
	    if (direction === "width") {
	        return window.innerWidth || de.clientWidth;
	    }
	    return window.innerHeight || de.clientHeight;
	}

	function applyCoords(coord) {
	    return typeof coord === "number" ? coord + "px" : "";
	}
	/**
	 * This util is used to get the "true" `element.getBoundingClientRect()` that
	 * ensures that transitions using tarnsforms don't mess up the sizing so that
	 * position calculations are easier to do.
	 *
	 * @param element The element to get a rect for.
	 * @param coords An optional object of coordinates to apply to the positioning
	 * styles. This should be used when the coords might resize the element since it
	 * needs to try to fit within the viewport.
	 * @return either a DOMRect or ClientRect for the element
	 * @private
	 */
	function getElementRect(element, coords) {
	    if (coords === void 0) { coords = {}; }
	    var cloned = element.cloneNode(true);
	    // remove the id so there won't be two elements with the same id on the page
	    cloned.removeAttribute("id");
	    // remove the role just in case the role would alert screen readers once added
	    // to the dom
	    cloned.removeAttribute("role");
	    // ensure the cloned node won't shift the page or be visible
	    cloned.style.position = "fixed";
	    cloned.style.visibility = "hidden";
	    // reset positionion to get a "pure" calculation. otherwise this will mess up the
	    // height and width if the element is able to line wrap.
	    cloned.style.left = applyCoords(coords.left);
	    cloned.style.top = applyCoords(coords.top);
	    cloned.style.right = applyCoords(coords.right);
	    cloned.style.bottom = applyCoords(coords.bottom);
	    // reset transforms so that custom animations don't mess with the sizing
	    cloned.style.webkitTransform = "none";
	    cloned.style.transform = "none";
	    var parent = element.parentElement || document.body;
	    parent.appendChild(cloned);
	    var rect = cloned.getBoundingClientRect();
	    parent.removeChild(cloned);
	    return rect;
	}

	/**
	 * Creates the `left` style value for an element that should be fixed to the
	 * (outer) left of the container element. So the right bounds of the fixed
	 * element will be equal to the left bounds of the container element (before the
	 * xMargin is applied).
	 * @private
	 */
	function getLeftCoord(_a) {
	    var xMargin = _a.xMargin, elWidth = _a.elWidth, initialX = _a.initialX, containerRect = _a.containerRect;
	    return (initialX !== null && initialX !== void 0 ? initialX : containerRect.left) - elWidth - xMargin;
	}
	/**
	 * Creates the `left` style value for an element that should be fixed to the
	 * inner-left of the container element. So the left bounds of both the container
	 * and fixed elements will overlap (before the xMargin is applied)
	 * @private
	 */
	function getInnerLeftCoord(_a) {
	    var xMargin = _a.xMargin, initialX = _a.initialX, containerRect = _a.containerRect;
	    return (initialX !== null && initialX !== void 0 ? initialX : containerRect.left) + xMargin;
	}
	/**
	 * Creates the `left` style value for an element that should be fixed to the
	 * center of the container element. So the center point of the fixed element
	 * should be the center point of the container element.
	 *
	 * Note: Unlike all the other horizontal positioning logic, the center position
	 * does not use the xMargin.
	 * @private
	 */
	function getCenterXCoord(_a) {
	    var elWidth = _a.elWidth, initialX = _a.initialX, containerRect = _a.containerRect;
	    var containerCenter = containerRect.width / 2;
	    var elementCenter = elWidth / 2;
	    return (initialX !== null && initialX !== void 0 ? initialX : containerRect.left + containerCenter) - elementCenter;
	}
	/**
	 * Creates the `left` style value for an element that should be fixed to the
	 * inner-right of the container element. So the right bounds for both the
	 * container and fixed elements will overlap (before the xMargin is applied).
	 * @private
	 */
	function getInnerRightCoord(_a) {
	    var xMargin = _a.xMargin, elWidth = _a.elWidth, initialX = _a.initialX, containerRect = _a.containerRect;
	    return ((initialX !== null && initialX !== void 0 ? initialX : containerRect.left + containerRect.width) - elWidth - xMargin);
	}
	/**
	 * Creates the `left` style value for an element that should be fixed to the
	 * (outer) right of the container element. So the left bounds of the fixed
	 * element will overlap with the right bounds of the container element (before
	 * the xMargin is applied).
	 * @private
	 */
	function getRightCoord(_a) {
	    var xMargin = _a.xMargin, initialX = _a.initialX, containerRect = _a.containerRect;
	    return (initialX !== null && initialX !== void 0 ? initialX : containerRect.left + containerRect.width) + xMargin;
	}
	/**
	 * Creates the `top` style value for an element that should be fixed above the
	 * container element. So the bottom bounds of the fixed element will overlap
	 * with the top bounds of the container element (before the yMargin is applied).
	 * @private
	 */
	function getAboveCoord(_a) {
	    var yMargin = _a.yMargin, initialY = _a.initialY, elHeight = _a.elHeight, containerRect = _a.containerRect;
	    return (initialY !== null && initialY !== void 0 ? initialY : containerRect.top) - elHeight - yMargin;
	}
	/**
	 * Creates the `top` style value for an element that should be fixed to the top
	 * of the container element. So the top bounds for both the container and fixed
	 * elements will overlap (before the yMargin is applied).
	 * @private
	 */
	function getTopCoord(_a) {
	    var yMargin = _a.yMargin, initialY = _a.initialY, containerRect = _a.containerRect;
	    return (initialY !== null && initialY !== void 0 ? initialY : containerRect.top) + yMargin;
	}
	/**
	 * Creates the `top` style value for an element that should be fixed vertically
	 * centered relative to the container element. So the vertical center point for
	 * the fixed element should overlap the vertical center point of the container
	 * element.
	 *
	 * Note: Unlike all the other vertical positioning logic, the center position
	 * does not use the yMargin.
	 */
	function getCenterYCoord(_a) {
	    var elHeight = _a.elHeight, initialY = _a.initialY, containerRect = _a.containerRect;
	    var containerCenter = containerRect.height / 2;
	    var elementCenter = elHeight / 2;
	    return (initialY !== null && initialY !== void 0 ? initialY : containerRect.top + containerCenter) - elementCenter;
	}
	/**
	 * Creates the `top` style value for an element that should be fixed to the
	 * bottom of the container element. So the top bounds of the fixed element
	 * should overlap the bottom bounds of the container element (before the yMargin
	 * is applied).
	 * @private
	 */
	function getBottomCoord(_a) {
	    var yMargin = _a.yMargin, initialY = _a.initialY, elHeight = _a.elHeight, containerRect = _a.containerRect;
	    return ((initialY !== null && initialY !== void 0 ? initialY : containerRect.top + containerRect.height) - elHeight - yMargin);
	}
	/**
	 * Creates the `top` style value for an element that should be fixed to the
	 * bottom of the container element. So the bottom bounds of both the container
	 * and fixed elements should overlap (before the yMargin is applied).
	 * @private
	 */
	function getBelowCoord(_a) {
	    var yMargin = _a.yMargin, initialY = _a.initialY, containerRect = _a.containerRect;
	    return (initialY !== null && initialY !== void 0 ? initialY : containerRect.top + containerRect.height) + yMargin;
	}

	/**
	 * Attempts to position the fixed element so that it will appear to the left of
	 * the container element but also within the viewport boundaries. When swapping
	 * is enabled, it will attempt to swap to the right position if it can't fit
	 * within the viewport to the left. If it can't fit in the viewport even after
	 * being swapped to the right or swapping is disabled, it will be positioned to
	 * the viewport left boundary.
	 *
	 * @private
	 */
	function createAnchoredLeft(config) {
	    var vwMargin = config.vwMargin, screenRight = config.screenRight, elWidth = config.elWidth, disableSwapping = config.disableSwapping;
	    var left = getLeftCoord(config);
	    var actualX = "left";
	    if (left >= vwMargin) {
	        return { actualX: actualX, left: left };
	    }
	    var swappedLeft = getRightCoord(config);
	    if (disableSwapping || swappedLeft + elWidth > screenRight) {
	        left = vwMargin;
	    }
	    else {
	        left = swappedLeft;
	        actualX = "right";
	    }
	    return { actualX: actualX, left: left };
	}
	/**
	 * Attempts to position the fixed element so that it will appear to the
	 * inner-left of the container element but also within the viewport boundaries.
	 * When swapping is enabled, it will attempt to swap to the right position if it
	 * can't fit within the viewport to the left. If it can't fit in the viewport
	 * even after being swapped to the right or swapping is disabled, it will be
	 * positioned to the viewport left boundary.
	 *
	 * @private
	 */
	function createAnchoredInnerLeft(config) {
	    var vwMargin = config.vwMargin, screenRight = config.screenRight, elWidth = config.elWidth, disableSwapping = config.disableSwapping;
	    var left = getInnerLeftCoord(config);
	    var actualX = "inner-left";
	    if (left + elWidth <= screenRight) {
	        return { actualX: actualX, left: left };
	    }
	    var swappedLeft = getInnerRightCoord(config);
	    if (disableSwapping || swappedLeft < vwMargin) {
	        left = vwMargin;
	    }
	    else {
	        left = swappedLeft;
	        actualX = "inner-right";
	    }
	    return { actualX: actualX, left: left };
	}
	/**
	 * Attempts to position the fixed element so that it will appear at the center
	 * of the container element but also within the viewport boundaries. If the
	 * centered element can't fit within the viewport, it will use the vwMargin
	 * value if it overflowed to the left, it'll position to the screen right
	 * boundary.
	 *
	 * @private
	 */
	function createAnchoredCenter(config) {
	    var vwMargin = config.vwMargin, screenRight = config.screenRight, elWidth = config.elWidth;
	    var left = getCenterXCoord(config);
	    if (left < vwMargin) {
	        left = vwMargin;
	    }
	    else if (left + elWidth > screenRight || left < vwMargin) {
	        left = screenRight - elWidth;
	    }
	    return { actualX: "center", left: left };
	}
	/**
	 * Attempts to position the fixed element so that it will appear to the
	 * inner-right of the container element but also within the viewport boundaries.
	 * When swapping is enabled, it will attempt to swap to the inner-left position
	 * if it can't fit within the viewport to the right. If it can't fit in the
	 * viewport even after being swapped to the left or swapping is disabled, it
	 * will be positioned to the viewport right boundary.
	 *
	 * @private
	 */
	function createAnchoredInnerRight(config) {
	    var screenRight = config.screenRight, vwMargin = config.vwMargin, elWidth = config.elWidth, disableSwapping = config.disableSwapping;
	    var left = getInnerRightCoord(config);
	    var actualX = "inner-right";
	    if (left >= vwMargin) {
	        return { actualX: actualX, left: left };
	    }
	    var swappedLeft = getInnerLeftCoord(config);
	    if (disableSwapping || swappedLeft + elWidth > screenRight) {
	        left = screenRight - elWidth;
	    }
	    else {
	        left = swappedLeft;
	        actualX = "inner-left";
	    }
	    return { actualX: actualX, left: left };
	}
	/**
	 * Attempts to position the fixed element so that it will appear to the right of
	 * the container element but also within the viewport boundaries. When swapping
	 * is enabled, it will attempt to swap to the left position if it can't fit
	 * within the viewport to the right. If it can't fit in the viewport even after
	 * being swapped to the left or swapping is disabled, it will be positioned to
	 * the viewport right boundary.
	 *
	 * @private
	 */
	function createAnchoredRight(config) {
	    var screenRight = config.screenRight, vwMargin = config.vwMargin, elWidth = config.elWidth, disableSwapping = config.disableSwapping;
	    var left = getRightCoord(config);
	    var actualX = "right";
	    if (left + elWidth <= screenRight) {
	        return { actualX: actualX, left: left };
	    }
	    var swappedLeft = getLeftCoord(config);
	    if (disableSwapping || swappedLeft < vwMargin) {
	        left = screenRight - elWidth;
	    }
	    else {
	        left = swappedLeft;
	        actualX = "left";
	    }
	    return { actualX: actualX, left: left };
	}
	/**
	 * @private
	 */
	function createEqualWidth(_a) {
	    var x = _a.x, vw = _a.vw, elWidth = _a.elWidth, xMargin = _a.xMargin, vwMargin = _a.vwMargin, initialX = _a.initialX, containerRect = _a.containerRect, isMinWidth = _a.isMinWidth;
	    var left = initialX !== null && initialX !== void 0 ? initialX : containerRect.left + xMargin;
	    var width = containerRect.width - xMargin * 2;
	    var minWidth;
	    var right;
	    if (isMinWidth) {
	        minWidth = width;
	        width = undefined;
	        if (left + elWidth > vw - vwMargin) {
	            right = vwMargin;
	        }
	    }
	    // going to assume that the container element is visible in the DOM and just
	    // make the fixed element have the same left and right corners
	    return {
	        left: left,
	        right: right,
	        width: width,
	        minWidth: minWidth,
	        actualX: x,
	    };
	}
	/**
	 * Creates the horizontal position for a fixed element with the provided
	 * options.
	 * @private
	 */
	function createHorizontalPosition(_a) {
	    var x = _a.x, vw = _a.vw, vwMargin = _a.vwMargin, xMargin = _a.xMargin, width = _a.width, elWidth = _a.elWidth, initialX = _a.initialX, containerRect = _a.containerRect, disableSwapping = _a.disableSwapping;
	    if (width === "min" || width === "equal") {
	        return createEqualWidth({
	            x: x,
	            vw: vw,
	            vwMargin: vwMargin,
	            xMargin: xMargin,
	            elWidth: elWidth,
	            initialX: initialX,
	            containerRect: containerRect,
	            isMinWidth: width === "min",
	        });
	    }
	    if (elWidth > vw - vwMargin * 2) {
	        // if the element's width is greater than the viewport's width minus the
	        // margin on both sides, just make the element span the entire viewport with
	        // the margin
	        return {
	            left: vwMargin,
	            right: vwMargin,
	            actualX: x,
	        };
	    }
	    var config = {
	        vwMargin: vwMargin,
	        xMargin: xMargin,
	        elWidth: elWidth,
	        initialX: initialX,
	        screenRight: vw - vwMargin,
	        containerRect: containerRect,
	        disableSwapping: disableSwapping,
	    };
	    switch (x) {
	        case "left":
	            return createAnchoredLeft(config);
	        case "inner-left":
	            return createAnchoredInnerLeft(config);
	        case "center":
	            return createAnchoredCenter(config);
	        case "inner-right":
	            return createAnchoredInnerRight(config);
	        case "right":
	            return createAnchoredRight(config);
	        default:
	            throw new Error("This should never happen");
	    }
	}

	/**
	 * Attempts to position the fixed element so that it will appear completely
	 * above the container element but also within the viewport boundaries. When
	 * swapping is enabled, it will attempt to swap to the below position if it
	 * can't fit within the viewport above the container element. If it can't fit in
	 * the viewport even after being swapped below or swapping is disabled, it will
	 * be positioned to the top viewport boundary.
	 *
	 * @private
	 */
	function createAnchoredAbove(config) {
	    var yMargin = config.yMargin, vhMargin = config.vhMargin, screenBottom = config.screenBottom, elHeight = config.elHeight, containerRect = config.containerRect, preventOverlap = config.preventOverlap, disableSwapping = config.disableSwapping, disableVHBounds = config.disableVHBounds;
	    var top = getAboveCoord(config);
	    var actualY = "above";
	    if (disableVHBounds) {
	        // can't actually allow a top value as a negative number since browsers
	        // won't scroll upwards pas the normal page top
	        return { actualY: actualY, top: Math.max(0, top) };
	    }
	    if (top > vhMargin) {
	        // don't need to do anything else since the top is still in the viewport and
	        // since it's positioned above, we already know it can't overlap the
	        // container element
	        return { actualY: actualY, top: top };
	    }
	    var swappedTop = getBelowCoord(config);
	    if (disableSwapping || swappedTop + elHeight > screenBottom) {
	        top = vhMargin;
	    }
	    else {
	        actualY = "below";
	        top = swappedTop;
	    }
	    var bottom;
	    if (preventOverlap &&
	        // can't overlap if it's positioned below
	        actualY === "above" &&
	        top + elHeight > containerRect.top) {
	        bottom = window.innerHeight - containerRect.top + yMargin;
	    }
	    return { actualY: actualY, top: top, bottom: bottom };
	}
	/**
	 * Attempts to position the fixed element so that it will appear fixed to the
	 * top of the container element but also within the viewport boundaries. When
	 * swapping is enabled, it will attempt to swap to the bottom position if it
	 * can't fit within the viewport. If it can't fit in the viewport even after
	 * being swapped to the bottom position or swapping is disabled, it will be
	 * positioned to the top viewport boundary.
	 *
	 * @private
	 */
	function createAnchoredTop(config) {
	    var vhMargin = config.vhMargin, screenBottom = config.screenBottom, elHeight = config.elHeight, disableSwapping = config.disableSwapping, disableVHBounds = config.disableVHBounds;
	    var top = getTopCoord(config);
	    var actualY = "top";
	    if (disableVHBounds || top + elHeight <= screenBottom) {
	        return { actualY: actualY, top: top };
	    }
	    var swappedTop = getBottomCoord(config);
	    if (disableSwapping || swappedTop < vhMargin) {
	        top = vhMargin;
	    }
	    else {
	        actualY = "bottom";
	        top = swappedTop;
	    }
	    return { actualY: actualY, top: top };
	}
	/**
	 * Attempts to position the fixed element so that it will appear at the center
	 * of the container element but also within the viewport boundaries. If the
	 * entered element can't fit within the viewport, it'll update the top value
	 * to either be the vhMargin or position to the screen bottom boundary
	 *
	 * @private
	 */
	function createAnchoredCenter$1(config) {
	    var vhMargin = config.vhMargin, screenBottom = config.screenBottom, elHeight = config.elHeight, disableVHBounds = config.disableVHBounds;
	    var top = getCenterYCoord(config);
	    var actualY = "center";
	    if (disableVHBounds) {
	        return { actualY: actualY, top: Math.max(0, top) };
	    }
	    top = Math.max(vhMargin, top);
	    if (top + elHeight > screenBottom) {
	        top = screenBottom - elHeight;
	    }
	    return { actualY: actualY, top: top };
	}
	/**
	 * Attempts to position the fixed element so that it will appear fixed to the
	 * bottom of the container element but also within the viewport boundaries. When
	 * swapping is enabled, it will attempt to swap to the top position if it can't
	 * fit within the viewport. If it can't fit in the viewport even after being
	 * swapped to the top position or swapping is disabled, it will be positioned to
	 * the bottom viewport boundary.
	 *
	 * @private
	 */
	function createAnchoredBottom(config) {
	    var vhMargin = config.vhMargin, screenBottom = config.screenBottom, elHeight = config.elHeight, disableSwapping = config.disableSwapping, disableVHBounds = config.disableVHBounds;
	    var top = getBottomCoord(config);
	    var actualY = "bottom";
	    if (disableVHBounds || top > vhMargin) {
	        return { actualY: actualY, top: top };
	    }
	    var swappedTop = getTopCoord(config);
	    if (disableSwapping || swappedTop + elHeight > screenBottom) {
	        top = screenBottom - elHeight;
	    }
	    else {
	        actualY = "top";
	        top = swappedTop;
	    }
	    return { actualY: actualY, top: top };
	}
	/**
	 * Attempts to position the fixed element so that it will appear completely
	 * below the container element but also within the viewport boundaries. When
	 * swapping is enabled, it will attempt to swap to the above position if it
	 * can't fit within the viewport below the container element. If it can't fit in
	 * the viewport even after being swapped above or swapping is disabled, it will
	 * be positioned to the bottom viewport boundary.
	 *
	 * @private
	 */
	function createAnchoredBelow(config) {
	    var yMargin = config.yMargin, vhMargin = config.vhMargin, elHeight = config.elHeight, screenBottom = config.screenBottom, containerRect = config.containerRect, preventOverlap = config.preventOverlap, disableSwapping = config.disableSwapping, disableVHBounds = config.disableVHBounds;
	    var top = getBelowCoord(config);
	    var actualY = "below";
	    if (disableVHBounds || top + elHeight <= screenBottom) {
	        return { actualY: actualY, top: top };
	    }
	    if (preventOverlap) {
	        var availableTop = containerRect.top - yMargin;
	        if (disableSwapping || availableTop < screenBottom - top) {
	            return {
	                actualY: actualY,
	                top: top,
	                bottom: vhMargin,
	            };
	        }
	        return {
	            actualY: "above",
	            top: Math.max(vhMargin, availableTop - elHeight),
	            // this makes it so that the bottom of the fixed element is the top of the container
	            // element. this ensures that it won't ever overlap the container element
	            bottom: getViewportSize("height") - availableTop,
	        };
	    }
	    var swappedTop = getAboveCoord(config);
	    if (disableSwapping || swappedTop < vhMargin) {
	        top = screenBottom - elHeight;
	    }
	    else {
	        actualY = "above";
	        top = swappedTop;
	    }
	    return { actualY: actualY, top: top };
	}
	/**
	 * Creates the vertical position for a fixed element with the provided options.
	 *
	 * @private
	 */
	function createVerticalPosition(_a) {
	    var y = _a.y, vh = _a.vh, vhMargin = _a.vhMargin, yMargin = _a.yMargin, elHeight = _a.elHeight, initialY = _a.initialY, containerRect = _a.containerRect, disableSwapping = _a.disableSwapping, preventOverlap = _a.preventOverlap, disableVHBounds = _a.disableVHBounds;
	    if (!disableVHBounds && !preventOverlap && elHeight > vh - vhMargin * 2) {
	        // the element is too big to be displayed in the viewport, so just span the
	        // full viewport excluding margins
	        return {
	            top: vhMargin,
	            bottom: vhMargin,
	            actualY: "center",
	        };
	    }
	    var config = {
	        vhMargin: vhMargin,
	        yMargin: yMargin,
	        elHeight: elHeight,
	        initialY: initialY,
	        containerRect: containerRect,
	        screenBottom: vh - vhMargin,
	        preventOverlap: preventOverlap,
	        disableSwapping: disableSwapping,
	        disableVHBounds: disableVHBounds,
	    };
	    switch (y) {
	        case "above":
	            return createAnchoredAbove(config);
	        case "top":
	            return createAnchoredTop(config);
	        case "center":
	            return createAnchoredCenter$1(config);
	        case "bottom":
	            return createAnchoredBottom(config);
	        case "below":
	            return createAnchoredBelow(config);
	        default:
	            throw new Error("This should never happen");
	    }
	}

	/**
	 * This is a simple util that'll generate a css `transform-origin` string so
	 * that the fixed element can animate from the correct point based on the
	 * provided anchor.
	 *
	 * @param anchor The anchor that should be used to create the transform origin
	 * for.
	 * @return the transform origin string
	 * @private
	 */
	function getTransformOrigin(anchor) {
	    var x = "0";
	    switch (anchor.x) {
	        case "right":
	        case "inner-left":
	            x = "0";
	            break;
	        case "center":
	            x = "50%";
	            break;
	        case "left":
	        case "inner-right":
	            x = "100%";
	            break;
	        default:
	            x = "0";
	    }
	    var y = "0";
	    switch (anchor.y) {
	        case "above":
	        case "bottom":
	            y = "100%";
	            break;
	        case "center":
	            y = "50%";
	            break;
	        case "below":
	        case "top":
	            y = "0";
	            break;
	        default:
	            y = "0";
	    }
	    return x + " " + y;
	}

	/**
	 * One of the most complicated functions in this project that will attempt to
	 * position an element relative to another container element while still being
	 * visible within the viewport. Below is the logical flow for attempting to fix
	 * the element to the container:
	 *
	 * No Container: If there is no container element, return the provided x and y
	 * positions and no styles since there's nothing we can use to calculate the
	 * position.
	 *
	 * No Element: If the container was provided but the element to position does
	 * not exist, return an style object containing the `left` and `top` values for
	 * the container and apply as many of the positioning options as possible so
	 * that the styles are "as close as possible" before the fixed element is added
	 * to the DOM. This will also return the provided x and y positions since
	 * nothing could be swapped around yet.
	 *
	 * Container and Element: If both the container and fixed element were provided,
	 * apply all the positioning options to the `left` and `top` values of the
	 * container based on the sizes of both elements.
	 *
	 * Now that the `left` and `top` values were applied, check to see if the
	 * element is fully visible within the viewport with the provided positioning
	 * options. If it is fully visible, do nothing else. If it isn't... follow the
	 * next flow:
	 *
	 * First, check the horizontal sizes and make sure that the element is still
	 * within the viewport with the provided viewwidth margin. If it isn't, first
	 * try to swap only to a `right` style instead of left to see if that fixes it,
	 * otherwise keep both the `left` and `right` styles.
	 */
	function getFixedPosition(_a) {
	    var container = _a.container, element = _a.element, _b = _a.anchor, propAnchor = _b === void 0 ? {} : _b, initialX = _a.initialX, initialY = _a.initialY, _c = _a.vwMargin, vwMargin = _c === void 0 ? 16 : _c, _d = _a.vhMargin, vhMargin = _d === void 0 ? 16 : _d, _e = _a.xMargin, xMargin = _e === void 0 ? 0 : _e, _f = _a.yMargin, yMargin = _f === void 0 ? 0 : _f, _g = _a.width, widthType = _g === void 0 ? "auto" : _g, _h = _a.preventOverlap, preventOverlap = _h === void 0 ? false : _h, _j = _a.transformOrigin, transformOrigin = _j === void 0 ? false : _j, _k = _a.disableSwapping, disableSwapping = _k === void 0 ? false : _k, _l = _a.disableVHBounds, disableVHBounds = _l === void 0 ? false : _l;
	    container = findSizingContainer(container);
	    var anchor = {
	        x: propAnchor.x || "center",
	        y: propAnchor.y || "below",
	    };
	    {
	        if (widthType !== "auto" && anchor.x !== "center") {
	            throw new Error('Unable to use a calculated width when the horizontal anchor is not `"center"`.');
	        }
	        if (preventOverlap && anchor.y !== "above" && anchor.y !== "below") {
	            throw new Error('Unable to prevent overlap when the vertical anchor is not `"above"` or `"below"`');
	        }
	    }
	    if (!container || !element) {
	        return {
	            actualX: anchor.x,
	            actualY: anchor.y,
	        };
	    }
	    var containerRect = container.getBoundingClientRect();
	    var vh = getViewportSize("height");
	    var vw = getViewportSize("width");
	    var _m = getElementRect(element), height = _m.height, elWidth = _m.width;
	    if (disableVHBounds) {
	        var dialog = element.closest("[role='dialog']");
	        if (!dialog) {
	            initialY = (initialY !== null && initialY !== void 0 ? initialY : 0) + window.scrollY;
	        }
	    }
	    var _o = createHorizontalPosition({
	        x: anchor.x,
	        vw: vw,
	        vwMargin: vwMargin,
	        xMargin: xMargin,
	        width: widthType,
	        elWidth: elWidth,
	        initialX: initialX,
	        containerRect: containerRect,
	        disableSwapping: disableSwapping,
	    }), left = _o.left, right = _o.right, width = _o.width, minWidth = _o.minWidth, actualX = _o.actualX;
	    var _p = createVerticalPosition({
	        y: anchor.y,
	        vh: vh,
	        vhMargin: vhMargin,
	        yMargin: yMargin,
	        initialY: initialY,
	        elHeight: height,
	        containerRect: containerRect,
	        disableSwapping: disableSwapping,
	        preventOverlap: preventOverlap,
	        disableVHBounds: disableVHBounds,
	    }), top = _p.top, bottom = _p.bottom, actualY = _p.actualY;
	    return {
	        actualX: actualX,
	        actualY: actualY,
	        style: {
	            left: left,
	            top: top,
	            right: right,
	            bottom: bottom,
	            width: width,
	            minWidth: minWidth,
	            position: disableVHBounds ? "absolute" : "fixed",
	            transformOrigin: transformOrigin
	                ? getTransformOrigin({ x: actualX, y: actualY })
	                : undefined,
	        },
	    };
	}

	var ABOVE_LEFT_ANCHOR = {
	    x: "left",
	    y: "above",
	};
	var ABOVE_INNER_LEFT_ANCHOR = {
	    x: "inner-left",
	    y: "above",
	};
	var ABOVE_CENTER_ANCHOR = {
	    x: "center",
	    y: "above",
	};
	var ABOVE_INNER_RIGHT_ANCHOR = {
	    x: "inner-right",
	    y: "above",
	};
	var ABOVE_RIGHT_ANCHOR = {
	    x: "right",
	    y: "above",
	};
	var TOP_LEFT_ANCHOR = {
	    x: "left",
	    y: "top",
	};
	var TOP_INNER_LEFT_ANCHOR = {
	    x: "inner-left",
	    y: "top",
	};
	var TOP_CENTER_ANCHOR = {
	    x: "center",
	    y: "top",
	};
	var TOP_INNER_RIGHT_ANCHOR = {
	    x: "inner-right",
	    y: "top",
	};
	var TOP_RIGHT_ANCHOR = {
	    x: "right",
	    y: "top",
	};
	var CENTER_LEFT_ANCHOR = {
	    x: "left",
	    y: "center",
	};
	var CENTER_INNER_LEFT_ANCHOR = {
	    x: "inner-left",
	    y: "center",
	};
	var CENTER_CENTER_ANCHOR = {
	    x: "center",
	    y: "center",
	};
	var CENTER_INNER_RIGHT_ANCHOR = {
	    x: "inner-right",
	    y: "center",
	};
	var CENTER_RIGHT_ANCHOR = {
	    x: "right",
	    y: "center",
	};
	var BOTTOM_LEFT_ANCHOR = {
	    x: "left",
	    y: "bottom",
	};
	var BOTTOM_INNER_LEFT_ANCHOR = {
	    x: "inner-left",
	    y: "bottom",
	};
	var BOTTOM_CENTER_ANCHOR = {
	    x: "center",
	    y: "bottom",
	};
	var BOTTOM_INNER_RIGHT_ANCHOR = {
	    x: "inner-right",
	    y: "bottom",
	};
	var BOTTOM_RIGHT_ANCHOR = {
	    x: "right",
	    y: "bottom",
	};
	var BELOW_LEFT_ANCHOR = {
	    x: "left",
	    y: "below",
	};
	var BELOW_INNER_LEFT_ANCHOR = {
	    x: "inner-left",
	    y: "below",
	};
	var BELOW_CENTER_ANCHOR = {
	    x: "center",
	    y: "below",
	};
	var BELOW_INNER_RIGHT_ANCHOR = {
	    x: "inner-right",
	    y: "below",
	};
	var BELOW_RIGHT_ANCHOR = {
	    x: "right",
	    y: "below",
	};

	var FOCUSABLE_ELEMENTS = ["BUTTON", "TEXTAREA", "SELECT"];
	var BASE_FOCUSABLE_ELEMENTS = 'a[href],area[href],input:not([disabled]):not([type="hidden"])';
	var BASE_FOCUSABLE_QUERY = FOCUSABLE_ELEMENTS.reduce(function (queryString, element) { return queryString + "," + element + ":not([disabled])"; }, BASE_FOCUSABLE_ELEMENTS);
	/**
	 * A query selector to find elements that are programmatically focusable.
	 *
	 * Example:
	 *
	 * ```ts
	 * const focusableElements = document.querySelectorAll(PROGRAMATICALLY_FOCUSABLE);
	 * // do something with elements
	 * ```
	 */
	var PROGRAMATICALLY_FOCUSABLE = BASE_FOCUSABLE_QUERY + ",[tabindex]";
	/**
	 * A query selector to find elements that are focusable only with tab and shift+tab.
	 *
	 * Example:
	 *
	 * ```ts
	 * const focusableElements = document.querySelectorAll(TAB_FOCUSABLE);
	 * // do something with elements
	 * ```
	 */
	var TAB_FOCUSABLE = PROGRAMATICALLY_FOCUSABLE + ":not([tabindex=\"-1\"])";

	/**
	 * A simple util that will find all the tab focusable elements within a
	 * container element.  The container should normally be a specific HTMLElement,
	 * but it can also be the entire document if you want to find **all** focusable
	 * elements within your page.
	 *
	 * @param container The container element/document to find focusable elements
	 * within.
	 * @param programatic Boolean if programatically focusable elements should be
	 * included instead of only tab focusable.
	 * @return A list of HTMLElements that are focusable within the container.
	 */
	function getFocusableElements(container, programatic) {
	    if (programatic === void 0) { programatic = false; }
	    return Array.from(container.querySelectorAll(programatic ? PROGRAMATICALLY_FOCUSABLE : TAB_FOCUSABLE));
	}

	/**
	 * Attempts to scroll an element into view within another container element if
	 * needed.  If either the container or element are `null`, nothing will happen.
	 *
	 * @param container The container element that should be scrolled if the child
	 * element is not within view.
	 * @param element The element that should be visible within the container
	 * element's scroll area.
	 */
	function scrollIntoView(container, element) {
	    element = findSizingContainer(element);
	    if (!container || !element) {
	        return;
	    }
	    var offsetTop = element.offsetTop;
	    if (element.offsetParent !== container) {
	        offsetTop -= container.offsetTop;
	    }
	    var elementBottom = offsetTop + element.offsetHeight;
	    var containerBottom = container.offsetHeight + container.scrollTop;
	    if (elementBottom > containerBottom) {
	        container.scrollTop = elementBottom - container.offsetHeight;
	    }
	    else if (offsetTop < container.scrollTop) {
	        container.scrollTop = offsetTop;
	    }
	}

	/**
	 * A function that is used to focus an element within the provided node.  This
	 * can either focus the first, last, or a querySelector found element.
	 *
	 * @param container Either an HTMLElement or the document to focus an element
	 * within.
	 * @param focus Either the "first" or "last" string to focus the first or last
	 * focusable element within the container or a query selector string to find a
	 * focusable element within the container.
	 * @param preventScroll Boolean if the focus event should not scroll the element
	 * into view. This should normally remain `false`, but can be useful if the
	 * element gets focused while offscreen during a transition.
	 * @param progamatic Boolean if programatically focusable elements should be
	 * included as well.
	 */
	function focusElementWithin(container, focus, programatic, preventScroll, elements) {
	    if (programatic === void 0) { programatic = false; }
	    if (preventScroll === void 0) { preventScroll = false; }
	    if (!elements || !elements.length) {
	        elements = getFocusableElements(container, programatic);
	    }
	    var el;
	    switch (focus) {
	        case "first":
	            el = elements[0];
	            break;
	        case "last":
	            el = elements[elements.length - 1];
	            break;
	        default:
	            el = container.querySelector(focus);
	    }
	    if (!el) {
	        throw new Error("Unable to find a focusable element");
	    }
	    el.focus({ preventScroll: preventScroll });
	    if (!preventScroll && container !== document) {
	        scrollIntoView(container, el);
	    }
	}

	/**
	 * Simple private util to get the DOM "instance" from either a ref object or an
	 * HTMLElement.
	 *
	 * @param refOrInstance The ref or instance to get an HTMLElement from
	 * @return The HTMLElement or null.
	 * @internal
	 */
	function getInstance(refOrInstance) {
	    var instance = null;
	    if (refOrInstance) {
	        if (refOrInstance instanceof HTMLElement) {
	            instance = refOrInstance;
	        }
	        else {
	            instance = refOrInstance.current;
	        }
	    }
	    return instance;
	}

	/**
	 * This hook is used to focus an element once a component has mounted. To help
	 * with keyboard click events, it will actually wait for an animation frame
	 * before attempting to focus as an enter key might click both elements at the
	 * same time.
	 *
	 * This hook will first focus the HTMLElement (if it is focusable) and then
	 * focus an element based on the defaultFocus prop.
	 *
	 * @param refOrInstance This is either a ref object containing the element to
	 * focus or the element itself.
	 * @param defaultFocus The element to focus within the containing element once
	 * it has been mounted. This can either be "first" or "last" to focus the first
	 * or last focusable elements or a query selector string to find an element to
	 * focus.
	 * @param preventScroll Boolean if the focus events should try to prevent the
	 * default scroll-into-view behavior. This is generally recommended to be kept
	 * as `false`, but can be useful to enable if the component mounts offscreen
	 * during a transition.
	 * @param programatic Boolean if programatically focusable elements should be
	 * included instead of only tab focusable.
	 * @param disabled Boolean if the focus behavior should be disabled.
	 */
	function useFocusOnMount(refOrInstance, defaultFocus, preventScroll, programatic, disabled) {
	    if (preventScroll === void 0) { preventScroll = false; }
	    if (programatic === void 0) { programatic = false; }
	    if (disabled === void 0) { disabled = false; }
	    React.useEffect(function () {
	        if (disabled) {
	            return;
	        }
	        var frame = window.requestAnimationFrame(function () {
	            var instance = getInstance(refOrInstance);
	            if (!instance) {
	                return;
	            }
	            instance.focus({ preventScroll: preventScroll });
	            focusElementWithin(instance, defaultFocus, programatic, preventScroll);
	        });
	        return function () {
	            window.cancelAnimationFrame(frame);
	        };
	    }, [defaultFocus, disabled, refOrInstance, programatic, preventScroll]);
	}

	/**
	 * This hook is used to focus the previous element when a component unmounts.
	 * The default behavior is to store the current activeElement within the
	 * document when the component mounts and then try to focus it again when the
	 * component unmounts.  You can also provide your own HTMLElement to focus when
	 * unmounting.
	 *
	 * During the unmount phase, it will wait for an animation frame before checking
	 * if the fallback element still exists within the page. If it doesn't, it will
	 * use the fallback query/element/function to attempt to find another element to
	 * focus. If the element exists within the page, it will then finally be
	 * focused.
	 *
	 * The animation frame is unfortunately required for keyboard users as pressing
	 * enter key will click the previous element immediately on focus as well.
	 *
	 * @param disabled Boolean if the focus behavior should be disabled.
	 * @param fallback The fallback query, element, or function to use if the
	 * previous element no longer exists in the DOM.
	 * @param previousElement An optional previous element to focus. If this is
	 * omitted, the `document.activeElement` will be used instead.
	 */
	function usePreviousFocus(disabled, fallback, previousElement) {
	    if (fallback === void 0) { fallback = undefined; }
	    if (previousElement === void 0) { previousElement = null; }
	    var options = React.useRef({
	        disabled: disabled,
	        fallback: fallback,
	    });
	    React.useEffect(function () {
	        options.current = {
	            disabled: disabled,
	            fallback: fallback,
	        };
	    });
	    React.useEffect(function () {
	        if (disabled) {
	            return;
	        }
	        var element = previousElement || document.activeElement;
	        // i'll need to think of a better way to handle this flow. There's just a
	        // weird one where if going from a menu to a dialog, we get lost without
	        // specifying a fallback. So if we are in a menu, try to find the
	        // corresponding menu button for this flow to fallback to.
	        var menu = element.closest('[role="menu"]');
	        var menuButton = null;
	        if (menu) {
	            // first try to get the button by using the menu's id minus the trailing
	            // -menu since that's the normal pattern within react-md.
	            menuButton = document.getElementById(menu.id.replace(/-menu$/, ""));
	            if (!menuButton) {
	                // if no menu button, try to see if the `aria-labelledby` points to the
	                // button... but since the `aria-labelledby` is a space-deliminated
	                // string of ids, have to check each one
	                var labelledBy = menu.getAttribute("aria-labelledby") || "";
	                var query = labelledBy
	                    .split(" ")
	                    .map(function (id) { return "#" + id + "[tabindex]"; })
	                    .join(",");
	                menuButton = query ? document.querySelector(query) : null;
	            }
	        }
	        return function () {
	            var _a = options.current, fallback = _a.fallback, disabled = _a.disabled;
	            if (disabled) {
	                // this has been added just for support for scrolling menus out of view.
	                // It is not ideal since keyboard focus is lost at this point, but
	                // _technically_ shouldn't be able to reach this flow with keyboard
	                // movement
	                return;
	            }
	            if (menu &&
	                menuButton &&
	                !previousElement &&
	                !fallback &&
	                !document.contains(element) &&
	                document.contains(menuButton)) {
	                menuButton.focus();
	                return;
	            }
	            var el = element;
	            if (!document.contains(el)) {
	                el =
	                    previousElement && document.contains(previousElement)
	                        ? previousElement
	                        : null;
	            }
	            if (!el && fallback) {
	                switch (typeof fallback) {
	                    case "string":
	                        el = document.querySelector(fallback);
	                        break;
	                    case "function":
	                        el = fallback();
	                        break;
	                    default:
	                        el = fallback;
	                }
	            }
	            if (el && !document.contains(el)) {
	                el = null;
	            }
	            if (el) {
	                el.focus();
	            }
	        };
	        // disabled since useRefCache and don't wnt to update on disabled change
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	}

	/**
	 * Creates an `onKeyDown` event handler to trap keyboard focus within a
	 * container element.
	 *
	 * @typeparam E The HTMLElement type that has the keydown event listener
	 * attached.
	 * @param options All the options for handling tab focus wrapping.
	 * @return The kedown event handler to enforce focus wrapping or the onKeyDown
	 * prop if this functionality is disabled.
	 */
	function useTabFocusWrap(_a) {
	    var _b = _a.disabled, disabled = _b === void 0 ? false : _b, _c = _a.disableFocusCache, disableFocusCache = _c === void 0 ? false : _c, onKeyDown = _a.onKeyDown;
	    var focusables = React.useRef([]);
	    var handleKeyDown = React.useCallback(function (event) {
	        if (onKeyDown) {
	            onKeyDown(event);
	        }
	        if (event.key !== "Tab") {
	            return;
	        }
	        if (disableFocusCache || !focusables.current.length) {
	            focusables.current = getFocusableElements(event.currentTarget);
	        }
	        var elements = focusables.current;
	        var l = elements.length;
	        if (l === 0) {
	            return;
	        }
	        if (l === 1) {
	            event.preventDefault();
	        }
	        else if (elements[0] === event.target && event.shiftKey) {
	            event.preventDefault();
	            elements[l - 1].focus();
	        }
	        else if (elements[l - 1] === event.target && !event.shiftKey) {
	            event.preventDefault();
	            elements[0].focus();
	        }
	    }, [onKeyDown, disableFocusCache]);
	    return disabled ? onKeyDown : handleKeyDown;
	}

	var __assign$9 = (undefined && undefined.__assign) || function () {
	    __assign$9 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9.apply(this, arguments);
	};
	var __rest$5 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * The `FocusContainer` is a wrapper for a few of the accessibility hooks to
	 * maintain focus within an element.
	 */
	var FocusContainer = React.forwardRef(function FocusContainer(_a, forwardedRef) {
	    var children = _a.children, onKeyDown = _a.onKeyDown, _b = _a.component, Component = _b === void 0 ? "div" : _b, _c = _a.defaultFocus, defaultFocus = _c === void 0 ? "first" : _c, _d = _a.disableFocusCache, disableFocusCache = _d === void 0 ? false : _d, _e = _a.disableFocusOnMount, disableFocusOnMount = _e === void 0 ? false : _e, _f = _a.disableFocusOnMountScroll, disableFocusOnMountScroll = _f === void 0 ? false : _f, _g = _a.disableFocusOnUnmount, disableFocusOnUnmount = _g === void 0 ? false : _g, _h = _a.disableTabFocusWrap, disableTabFocusWrap = _h === void 0 ? false : _h, _j = _a.unmountFocusFallback, unmountFocusFallback = _j === void 0 ? "" : _j, props = __rest$5(_a, ["children", "onKeyDown", "component", "defaultFocus", "disableFocusCache", "disableFocusOnMount", "disableFocusOnMountScroll", "disableFocusOnUnmount", "disableTabFocusWrap", "unmountFocusFallback"]);
	    var ref = React.useRef(null);
	    var refHandler = React.useCallback(function (instance) {
	        applyRef(instance, forwardedRef);
	        ref.current = instance;
	    }, [forwardedRef]);
	    usePreviousFocus(disableFocusOnUnmount, unmountFocusFallback);
	    useFocusOnMount(ref, defaultFocus, disableFocusOnMountScroll, false, disableFocusOnMount);
	    var handleKeyDown = useTabFocusWrap({
	        disabled: disableTabFocusWrap,
	        disableFocusCache: disableFocusCache,
	        onKeyDown: onKeyDown,
	    });
	    return (React__default.createElement(Component, __assign$9({}, props, { onKeyDown: handleKeyDown, ref: refHandler }), children));
	});
	{
	    try {
	        var PropTypes$a = require("prop-types");
	        FocusContainer.propTypes = {
	            disableFocusCache: PropTypes$a.bool,
	            disableFocusOnMount: PropTypes$a.bool,
	            disableFocusOnUnmount: PropTypes$a.bool,
	            disableTabFocusWrap: PropTypes$a.bool,
	            defaultFocus: PropTypes$a.oneOfType([
	                PropTypes$a.oneOf(["first", "last"]),
	                PropTypes$a.string,
	            ]),
	            component: PropTypes$a.oneOfType([
	                PropTypes$a.string,
	                PropTypes$a.func,
	                PropTypes$a.object,
	            ]),
	            unmountFocusFallback: PropTypes$a.oneOfType([
	                PropTypes$a.string,
	                PropTypes$a.func,
	                PropTypes$a.object,
	            ]),
	            children: PropTypes$a.node,
	            onKeyDown: PropTypes$a.func,
	            disableFocusOnMountScroll: PropTypes$a.bool,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * The currently supported keyboard movement key combinations that increment or
	 * decrement within a list. This was extracted from the w3.org website about
	 * wia-aria best practices.
	 *
	 * @see https://www.w3.org/TR/wai-aria-practices/
	 */
	(function (IncrementMovementKey) {
	    IncrementMovementKey["ArrowUp"] = "ArrowUp";
	    IncrementMovementKey["ArrowDown"] = "ArrowDown";
	    IncrementMovementKey["ArrowLeft"] = "ArrowLeft";
	    IncrementMovementKey["ArrowRight"] = "ArrowRight";
	    IncrementMovementKey["PageDown"] = "PageDown";
	    IncrementMovementKey["PageUp"] = "PageUp";
	    IncrementMovementKey["ShiftArrowUp"] = "Shift+ArrowUp";
	    IncrementMovementKey["ShiftArrowDown"] = "Shift+ArrowDown";
	    IncrementMovementKey["ShiftArrowLeft"] = "Shift+ArrowLeft";
	    IncrementMovementKey["ShiftArrowRight"] = "Shift+ArrowRight";
	    IncrementMovementKey["AltArrowDown"] = "Alt+ArrowDown";
	    IncrementMovementKey["AltArrowUp"] = "Alt+ArrowUp";
	    IncrementMovementKey["AltArrowLeft"] = "Alt+ArrowLeft";
	    IncrementMovementKey["AltArrowRight"] = "Alt+ArrowRight";
	    IncrementMovementKey["AltPageDown"] = "Alt+PageDown";
	    IncrementMovementKey["AltPageUp"] = "Alt+PageUp";
	    IncrementMovementKey["ControlArrowDown"] = "Control+ArrowDown";
	    IncrementMovementKey["ControlArrowUp"] = "Control+ArrowUp";
	})(exports.IncrementMovementKey || (exports.IncrementMovementKey = {}));
	(function (JumpMovementKey) {
	    JumpMovementKey["Home"] = "Home";
	    JumpMovementKey["End"] = "End";
	    JumpMovementKey["AltHome"] = "Alt+Home";
	    JumpMovementKey["AltEnd"] = "Alt+End";
	    JumpMovementKey["ControlHome"] = "Control+Home";
	    JumpMovementKey["ControlEnd"] = "Control+End";
	    JumpMovementKey["ControlShiftHome"] = "Control+Shift+Home";
	    JumpMovementKey["ControlShiftEnd"] = "Control+Shift+End";
	})(exports.JumpMovementKey || (exports.JumpMovementKey = {}));

	var __assign$a = (undefined && undefined.__assign) || function () {
	    __assign$a = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a.apply(this, arguments);
	};
	/**
	 * A keyboard movement configuration preset for handling vertical menu
	 * movements.
	 */
	var VERTICAL_MENU = {
	    loopable: true,
	    searchable: true,
	    incrementKeys: [exports.IncrementMovementKey.ArrowDown],
	    decrementKeys: [exports.IncrementMovementKey.ArrowUp],
	    jumpToFirstKeys: [exports.JumpMovementKey.Home],
	    jumpToLastKeys: [exports.JumpMovementKey.End],
	};
	/**
	 * A keyboard movement configuration preset for handling horizontal menu
	 * movements.
	 */
	var HORIZONTAL_MENU = __assign$a(__assign$a({}, VERTICAL_MENU), { incrementKeys: [exports.IncrementMovementKey.ArrowRight], decrementKeys: [exports.IncrementMovementKey.ArrowLeft] });
	/**
	 * A keyboard movement configuration preset for handling vertical listbox
	 * movements.
	 */
	var VERTICAL_LISTBOX = __assign$a(__assign$a({}, VERTICAL_MENU), { loopable: false });
	/**
	 * A keyboard movement configuration preset for handling horizontal listbox
	 * movements.
	 */
	var HORIZONTAL_LISTBOX = __assign$a(__assign$a({}, HORIZONTAL_MENU), { loopable: false });
	/**
	 * A keyboard movement configuration preset for handling vertical combobox
	 * movements.
	 */
	var VERTICAL_COMBOBOX = {
	    incrementKeys: [exports.IncrementMovementKey.ArrowDown],
	    decrementKeys: [exports.IncrementMovementKey.ArrowUp],
	    // don't want to be able to jump since home and end should do default behavior
	    // in text field
	    jumpToFirstKeys: [],
	    jumpToLastKeys: [],
	    searchable: false,
	};
	/**
	 * A keyboard movement configuration preset for handling horizontal combobox
	 * movements.
	 */
	var HORIZONTAL_COMBOBOX = {
	    incrementKeys: [exports.IncrementMovementKey.ArrowRight],
	    decrementKeys: [exports.IncrementMovementKey.ArrowLeft],
	    // don't want to be able to jump since home and end should do default behavior
	    // in text field
	    jumpToFirstKeys: [],
	    jumpToLastKeys: [],
	    searchable: false,
	};
	var VERTICAL_TREE = {
	    incrementKeys: [exports.IncrementMovementKey.ArrowDown],
	    decrementKeys: [exports.IncrementMovementKey.ArrowUp],
	    jumpToFirstKeys: [exports.JumpMovementKey.Home, exports.JumpMovementKey.ControlShiftHome],
	    jumpToLastKeys: [exports.JumpMovementKey.End, exports.JumpMovementKey.ControlShiftEnd],
	    loopable: true,
	    searchable: true,
	};
	var HORIZONTAL_TREE = {
	    incrementKeys: [exports.IncrementMovementKey.ArrowRight],
	    decrementKeys: [exports.IncrementMovementKey.ArrowLeft],
	    jumpToFirstKeys: [exports.JumpMovementKey.Home, exports.JumpMovementKey.ControlShiftHome],
	    jumpToLastKeys: [exports.JumpMovementKey.End, exports.JumpMovementKey.ControlShiftEnd],
	    loopable: true,
	    searchable: true,
	};
	var HORIZONTAL_TABS = {
	    incrementKeys: [exports.IncrementMovementKey.ArrowRight],
	    decrementKeys: [exports.IncrementMovementKey.ArrowLeft],
	    jumpToFirstKeys: [exports.JumpMovementKey.Home],
	    jumpToLastKeys: [exports.JumpMovementKey.End],
	    loopable: true,
	    searchable: false,
	};
	var VERTICAL_TABS = {
	    incrementKeys: [exports.IncrementMovementKey.ArrowDown],
	    decrementKeys: [exports.IncrementMovementKey.ArrowUp],
	    jumpToFirstKeys: [exports.JumpMovementKey.Home],
	    jumpToLastKeys: [exports.JumpMovementKey.End],
	    loopable: true,
	    searchable: false,
	};

	var presets = /*#__PURE__*/Object.freeze({
		__proto__: null,
		VERTICAL_MENU: VERTICAL_MENU,
		HORIZONTAL_MENU: HORIZONTAL_MENU,
		VERTICAL_LISTBOX: VERTICAL_LISTBOX,
		HORIZONTAL_LISTBOX: HORIZONTAL_LISTBOX,
		VERTICAL_COMBOBOX: VERTICAL_COMBOBOX,
		HORIZONTAL_COMBOBOX: HORIZONTAL_COMBOBOX,
		VERTICAL_TREE: VERTICAL_TREE,
		HORIZONTAL_TREE: HORIZONTAL_TREE,
		HORIZONTAL_TABS: HORIZONTAL_TABS,
		VERTICAL_TABS: VERTICAL_TABS
	});

	/**
	 * A small util that is used to increment or decrement a number until it reaches
	 * the max value or -1. When that happens, it will loop around to 0 or the max
	 * value respectively. This does not work for different increment numbers or any
	 * values below 0 for now.
	 *
	 * @internal
	 * @param x The number to increment or decrement
	 * @param max The max number that can be set
	 * @param increment Boolean if it should be incremented or decremented
	 * @param minmax Boolean if the loop functionality should be replaced with
	 * min-max behavior instead of allowing looping
	 */
	function loop(x, max, increment, minmax) {
	    if (minmax === void 0) { minmax = false; }
	    var next = x + (increment ? 1 : -1);
	    if (minmax) {
	        next = Math.min(max, Math.max(0, next));
	    }
	    else if (next > max) {
	        next = 0;
	    }
	    else if (next < 0) {
	        next = max;
	    }
	    return next;
	}

	/**
	 * An extremely simple function that is used to generate an id for an item
	 * within a list of other items.  This is generally used with list of items that
	 * should have custom focus with the `aria-activedescendant` flow instead of
	 * native focus.
	 *
	 * @param id The base id for the container element of all the items.
	 * @param i The index of the item within the list. This number will be
	 * incremented by 1 as an id to start from 1 instead of 0.
	 */
	function getItemId(id, i) {
	    if (!id) {
	        throw new Error("The id must be a string with a length greater than 0");
	    }
	    if (i < 0) {
	        throw new RangeError("The provided index must be greater than 0");
	    }
	    return id + "-item-" + (i + 1);
	}
	/**
	 * A small util function to transform a list of key codes into a list of
	 * `KeyConfig` objects. This is useful for how I determine what behavior to
	 * implement after a keydown event.
	 *
	 * @param keys A list of key mappings to convert to a key object. These should
	 * be things like: "Tab", "Alt+Home", "A", "Shift+Alt+ArrowUp"
	 * @param type The keyboard focus type this key should be mapped to
	 * @private
	 */
	function transformKeys(keys, type) {
	    return keys.map(function (key) { return ({
	        shiftKey: key.includes("Shift+"),
	        metaKey: key.includes("Meta+"),
	        ctrlKey: key.includes("Control+"),
	        altKey: key.includes("Alt+"),
	        key: key.replace(/(Shift|Meta|Alt|Control)\+/g, ""),
	        type: type,
	    }); });
	}
	/**
	 * A small util get the `KeyConfig` based on the provided keys and keyboard
	 * event. This ensures that the key, altKey, metaKey, and shiftKey values all
	 * match.
	 *
	 * If a key is not found, `null` will be returned instead.
	 *
	 * @param event The event to get a key mapping type for
	 * @param keys A list of key mappings to attempt to find a valid key event type
	 * from.
	 * @private
	 */
	function getKeyboardConfig(event, keys) {
	    var key = event.key, altKey = event.altKey, ctrlKey = event.ctrlKey, metaKey = event.metaKey, shiftKey = event.shiftKey;
	    return (keys.find(function (k) {
	        return k.key === key &&
	            k.altKey === altKey &&
	            k.ctrlKey === ctrlKey &&
	            k.metaKey === metaKey &&
	            k.shiftKey === shiftKey;
	    }) || null);
	}
	/**
	 * Creates a stringified representation of the configuration so that the config
	 * can be checked in the `onChange` callback for keyboard movement. This is used
	 * as the `query` attribute on the change data.
	 *
	 * @param config The key config to stringify
	 * @private
	 */
	function getStringifiedKeyConfig(config) {
	    var key = config.key, altKey = config.altKey, ctrlKey = config.ctrlKey, metaKey = config.metaKey, shiftKey = config.shiftKey, type = config.type;
	    var suffix = [
	        metaKey && "Meta",
	        ctrlKey && "Control",
	        shiftKey && "Shift",
	        altKey && "Alt",
	        key,
	    ]
	        .filter(Boolean)
	        .join("+");
	    return type + "-" + suffix;
	}

	var __spreadArrays = (undefined && undefined.__spreadArrays) || function () {
	    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	    for (var r = Array(s), k = 0, i = 0; i < il; i++)
	        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
	            r[k] = a[j];
	    return r;
	};
	/**
	 * This is a low-level hook for providing custom keyboard movement based on key
	 * configurations.  This normally shouldn't really be used externally since
	 * you'll most likely want to use the "presets" of `useFocusMovement` and
	 * `useActiveDescendantMovement` that implement the main movement types already
	 * for you.
	 *
	 * The way this works is that it will general a list of mutable item refs that
	 * should be applied to each DOM node for the corresponding `item` within the
	 * `items` list. This list will change and regenerate itself each time the
	 * `items` array changes so it'll always be in-sync with the DOM nodes. This
	 * means that if you have some items that **should not be rendered**, they
	 * should not be included within the items list. The main reason these item refs
	 * are required is so that the `aria-acativedescendant` movement can scroll the
	 * new "focused" element into view if needed while the "true" focus movement can
	 * trigger a `ref.current.focus()` on the new item as needed.
	 *
	 * Finally, this will create a keydown event handler that will merge in the
	 * optionally provided `onKeyDown` prop and check if the pressed key should
	 * trigger a custom keyboard movement event.  If it does, an `onChange` event
	 * will be fired with the matching data and allows for custom movement with
	 * `target.focus()` or updating the `aria-activedescendant` attribute as needed.
	 *
	 * @typeparam D The type of each data item within the items list.
	 * @typeparam CE The HTMLElement type of the container element that handles the
	 * custom keyboard movement.
	 * @typeparam IE The HTMLElement type of each item within the container element
	 * that can be focusable.
	 */
	function useKeyboardMovement(_a) {
	    var onKeyDown = _a.onKeyDown, incrementKeys = _a.incrementKeys, decrementKeys = _a.decrementKeys, jumpToFirstKeys = _a.jumpToFirstKeys, jumpToLastKeys = _a.jumpToLastKeys, _b = _a.stopPropagation, stopPropagation = _b === void 0 ? true : _b, onChange = _a.onChange, items = _a.items, resetTime = _a.resetTime, findMatchIndex = _a.findMatchIndex, focusedIndex = _a.focusedIndex, _c = _a.loopable, loopable = _c === void 0 ? true : _c, _d = _a.searchable, searchable = _d === void 0 ? true : _d, _e = _a.valueKey, valueKey = _e === void 0 ? DEFAULT_VALUE_KEY : _e, _f = _a.getItemValue, getItemValue = _f === void 0 ? DEFAULT_GET_ITEM_VALUE : _f;
	    var keys = React.useMemo(function () { return __spreadArrays(transformKeys(incrementKeys, "increment"), transformKeys(decrementKeys, "decrement"), transformKeys(jumpToFirstKeys, "first"), transformKeys(jumpToLastKeys, "last")); }, [incrementKeys, decrementKeys, jumpToFirstKeys, jumpToLastKeys]);
	    var itemRefs = React.useMemo(function () { return Array.from(items, function () { return ({ current: null }); }); }, [items]);
	    var handleSearch = useKeyboardSearch({
	        items: items,
	        valueKey: valueKey,
	        getItemValue: getItemValue,
	        onChange: function (data) {
	            onChange(data, itemRefs);
	        },
	        searchIndex: focusedIndex,
	        resetTime: resetTime,
	        findMatchIndex: findMatchIndex,
	    });
	    var handleKeyDown = React.useCallback(function (event) {
	        if (searchable) {
	            handleSearch(event);
	        }
	        if (onKeyDown) {
	            onKeyDown(event);
	        }
	        var target = event.target;
	        var keyConfig = getKeyboardConfig(event, keys);
	        if (!keyConfig || !target) {
	            return;
	        }
	        // implementing custom behavior, so prevent default of scrolling or other
	        // things
	        event.preventDefault();
	        if (stopPropagation) {
	            event.stopPropagation();
	        }
	        var type = keyConfig.type;
	        var lastIndex = items.length - 1;
	        var index;
	        switch (type) {
	            case "first":
	                index = 0;
	                break;
	            case "last":
	                index = lastIndex;
	                break;
	            default:
	                index = loop(focusedIndex, lastIndex, type === "increment", !loopable);
	        }
	        if (index === focusedIndex) {
	            return;
	        }
	        var data = {
	            index: index,
	            item: items[index],
	            items: items,
	            query: getStringifiedKeyConfig(keyConfig),
	            target: event.currentTarget,
	        };
	        onChange(data, itemRefs);
	    }, [
	        onKeyDown,
	        stopPropagation,
	        focusedIndex,
	        keys,
	        items,
	        handleSearch,
	        loopable,
	        searchable,
	        onChange,
	        itemRefs,
	    ]);
	    return [itemRefs, handleKeyDown];
	}

	var __assign$b = (undefined && undefined.__assign) || function () {
	    __assign$b = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b.apply(this, arguments);
	};
	var __rest$6 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This hook allows for custom keyboard "focus" movement using the
	 * `aria-activedescendant` movement pattern. This is generally used when the DOM
	 * focus shouldn't actually change from the container element (like listboxes)
	 * but you still need to indicate that another element is "focused" due to a key
	 * press.
	 *
	 * To use this hook, you'll want to update the container element of all the
	 * items to have an `aria-activedescendant={activeId}` attribute and
	 * `onKeyDown={onKeyDown}` that are provided by this hook. The
	 * `aria-activedescendant` will help screen readers known what element is
	 * "focused" since the container element should never really lose focus during
	 * these keyboard movement events.  Finally, you'll want to update each item
	 * have an id that is the result of `getItem(baseId, index)` so that it matches
	 * the `aria-activedescendant` value and then apply `ref={itemRefs[i]}`.
	 * Unfortunately, this means that all the child items **must** either be an
	 * HTMLElement or the ref is forwarded down to the HTMLElement.
	 *
	 * The `itemRefs` **must** be applied so that a new "focused" item can be
	 * scrolled into view as needed.
	 *
	 * @typeparam D The type of each data item within the items list.
	 * @typeparam CE The HTMLElement type of the container element that handles the
	 * custom keyboard movement.
	 * @typeparam IE The HTMLElement type of each item within the container element
	 * that can be focusable.
	 */
	function useActiveDescendantMovement(_a) {
	    var baseId = _a.baseId, _b = _a.getId, getId = _b === void 0 ? getItemId : _b, _c = _a.defaultFocusedIndex, defaultFocusedIndex = _c === void 0 ? -1 : _c, items = _a.items, onChange = _a.onChange, _d = _a.getItemValue, getItemValue = _d === void 0 ? DEFAULT_GET_ITEM_VALUE : _d, _e = _a.valueKey, valueKey = _e === void 0 ? DEFAULT_VALUE_KEY : _e, onKeyDown = _a.onKeyDown, onEnter = _a.onEnter, onSpace = _a.onSpace, options = __rest$6(_a, ["baseId", "getId", "defaultFocusedIndex", "items", "onChange", "getItemValue", "valueKey", "onKeyDown", "onEnter", "onSpace"]);
	    var _f = React.useState(defaultFocusedIndex), focusedIndex = _f[0], setFocusedIndex = _f[1];
	    var activeId = focusedIndex !== -1 ? getId(baseId, focusedIndex) : "";
	    var _g = useKeyboardMovement(__assign$b(__assign$b({}, options), { valueKey: valueKey,
	        getItemValue: getItemValue,
	        focusedIndex: focusedIndex,
	        items: items,
	        onChange: function (data, itemRefs) {
	            if (onChange) {
	                onChange(data, itemRefs);
	            }
	            var index = data.index, target = data.target;
	            var item = itemRefs[index] && itemRefs[index].current;
	            if (item && target && target.scrollHeight > target.offsetHeight) {
	                scrollIntoView(target, item);
	            }
	            setFocusedIndex(index);
	        },
	        onKeyDown: function (event) {
	            if (onKeyDown) {
	                onKeyDown(event);
	            }
	            var ref = (itemRefs[focusedIndex] && itemRefs[focusedIndex].current) || null;
	            if (onEnter && event.key === "Enter") {
	                onEnter(focusedIndex, ref);
	            }
	            else if (onSpace && event.key === " ") {
	                event.preventDefault();
	                onSpace(focusedIndex, ref);
	            }
	        } })), itemRefs = _g[0], handleKeyDown = _g[1];
	    return {
	        activeId: activeId,
	        itemRefs: itemRefs,
	        onKeyDown: handleKeyDown,
	        focusedIndex: focusedIndex,
	        setFocusedIndex: setFocusedIndex,
	    };
	}

	var __assign$c = (undefined && undefined.__assign) || function () {
	    __assign$c = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c.apply(this, arguments);
	};
	var __rest$7 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This hook allows for custom keyboard focus movement using DOM focus behavior
	 * by actually focusing each DOM node.
	 *
	 * To use this hook, you'll want to update the container element of all the
	 * items to have a correct `role` applied as well as the `onKeyDown` event
	 * handler provided by this hook. Then, you'll want to applied a
	 * `ref={itemRefs[i]}` for each item within the items list so that the DOM nodes
	 * can be focused as needed. Unfortunately, this means that all the child items
	 * **must** either be an HTMLElement or the ref is forwarded down to the
	 * HTMLElement.
	 *
	 * @typeparam D The type of each data item within the items list.
	 * @typeparam CE The HTMLElement type of the container element that handles the
	 * custom keyboard movement.
	 * @typeparam IE The HTMLElement type of each item within the container element
	 * that can be focusable.
	 */
	function useFocusMovement(_a) {
	    var _b = _a.defaultFocusedIndex, defaultFocusedIndex = _b === void 0 ? -1 : _b, onChange = _a.onChange, options = __rest$7(_a, ["defaultFocusedIndex", "onChange"]);
	    var _c = React.useState(defaultFocusedIndex), focusedIndex = _c[0], setFocusedIndex = _c[1];
	    var _d = useKeyboardMovement(__assign$c(__assign$c({}, options), { focusedIndex: focusedIndex,
	        onChange: function (data, itemRefs) {
	            if (onChange) {
	                onChange(data, itemRefs);
	            }
	            var index = data.index;
	            if (index === -1) {
	                return;
	            }
	            var item = itemRefs[index] && itemRefs[index].current;
	            if (item) {
	                item.focus();
	            }
	            setFocusedIndex(index);
	        } })), itemRefs = _d[0], handleKeyDown = _d[1];
	    React.useEffect(function () {
	        if (defaultFocusedIndex === -1) {
	            return;
	        }
	        var item = itemRefs[defaultFocusedIndex] && itemRefs[defaultFocusedIndex].current;
	        if (item) {
	            item.focus();
	        }
	        // only want to trigger on mount
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    return [itemRefs, handleKeyDown];
	}

	/**
	 * This is used with the `useScrollLock` effect to determine if the styles were
	 * applied by scroll locking or not in the cleanup stage.
	 */
	var DATA_RMD_NOSCROLL = "data-rmd-noscroll";
	/**
	 * This will enable scroll locking for the provided element. Scroll locking
	 * works by fixing the element within the page and hiding overflow for that
	 * element.
	 *
	 * @param element Either the `<body>` tag or an element within the page to
	 * disable scroll for.
	 * @internal
	 */
	function enable(element) {
	    element.style.overflow = "hidden";
	    element.setAttribute(DATA_RMD_NOSCROLL, "");
	}
	/**
	 * Attempts to disable the scroll locking behavior for an element. If the
	 * element does not have `data-rmd-noscroll`, it will not be modified. This is
	 * really just a safety catch to ensure that pre-existing styles aren't removed
	 * on accident.
	 *
	 * If the `data-rmd-noscroll` attribute exists, overflow style and the
	 * `data-rmd-noscroll` attribute will be removed.
	 *
	 * @param element Either the `<body>` tag or an element within the page to
	 * disable scroll locking for.
	 * @internal
	 */
	function disable(element) {
	    if (element.getAttribute(DATA_RMD_NOSCROLL) === null) {
	        return;
	    }
	    element.style.overflow = "";
	    element.removeAttribute(DATA_RMD_NOSCROLL);
	}
	/**
	 * A hook that is used to dynamically add scroll locking to an element. By
	 * default, this will use the main `<body>` tag for scroll locking, but a query
	 * selector string or an HTML element can also be used instead.
	 *
	 * @param enabled Boolean if the scroll locking behavior should be enabled
	 * @param selectorOrElement Either a query selector string, HTMLElement, or a
	 * function that returns an HTMLElement to apply scroll locking to.
	 */
	function useScrollLock(enabled, selectorOrElement) {
	    React.useEffect(function () {
	        if (!enabled || typeof document === "undefined") {
	            return;
	        }
	        var element = null;
	        if (typeof selectorOrElement === "string") {
	            element = document.querySelector(selectorOrElement);
	        }
	        else if (typeof selectorOrElement === "function") {
	            element = selectorOrElement();
	        }
	        else if (selectorOrElement) {
	            element = selectorOrElement;
	        }
	        else {
	            element = document.body;
	        }
	        if (!element || element.getAttribute(DATA_RMD_NOSCROLL) !== null) {
	            return;
	        }
	        enable(element);
	        return function () {
	            disable(element);
	        };
	    }, [enabled, selectorOrElement]);
	}

	/**
	 * This will conditionally close the dialog when the escape key is pressed.
	 *
	 * @param onRequestClose The function to call to close the dialog.
	 * @param disabled Boolean if the escape key functionality should be disabled
	 * @param onKeyDown An optional keydown event handler to also call.
	 * @return A keydown event handler
	 */
	function useCloseOnEscape(onRequestClose, disabled, onKeyDown) {
	    var handleKeyDown = React.useCallback(function (event) {
	        if (onKeyDown) {
	            onKeyDown(event);
	        }
	        if (event.key === "Escape") {
	            onRequestClose();
	        }
	    }, [onKeyDown, onRequestClose]);
	    return disabled ? onKeyDown : handleKeyDown;
	}

	var removeWhitespace = function (s) { return s.replace(/\s/g, ""); };
	/**
	 * The default function used to extract the text from nodes. This will just
	 * return the textContent by default unless the node has a react-md FontIcon as
	 * a child. If there is a FontIcon child, the node will be cloned without the
	 * FontIcon to return the textContent instead. This is because the FontIcon's
	 * text content would also be returned from the node's text content.
	 *
	 * @param stringOrElement Either a string or an element element to convert
	 * @param fontIconQuerySelector A string to use for finding font icons in the
	 * HTML Element. When this is set to the empty string, the element will not be
	 * checked for font icons which _might_ be a slight performance boost if you are
	 * guarenteed to not use font icons
	 */
	function extractTextContent(stringOrElement, fontIconQuerySelector) {
	    if (fontIconQuerySelector === void 0) { fontIconQuerySelector = ".rmd-icon--font"; }
	    if (typeof stringOrElement === "string") {
	        return removeWhitespace(stringOrElement);
	    }
	    if (fontIconQuerySelector) {
	        var fontIcons = Array.from(stringOrElement.querySelectorAll(fontIconQuerySelector));
	        if (fontIcons.some(function (i) { return !!i.textContent; })) {
	            var cloned = stringOrElement.cloneNode(true);
	            var icon = void 0;
	            do {
	                icon = cloned.querySelector(fontIconQuerySelector);
	                if (icon && icon.parentNode) {
	                    icon.parentNode.removeChild(icon);
	                }
	            } while (icon);
	            return removeWhitespace(cloned.textContent || "");
	        }
	    }
	    return removeWhitespace(stringOrElement.textContent || "");
	}

	/**
	 * I really don't know how to typedef this. It just creates a new object that
	 * has all the values copied over except for any keys that are defined in the
	 * omitKeys param.
	 *
	 * @internal
	 * @param object The object to remove keys from
	 * @param omitKeys The keys to remove.
	 * @return a new object without the specified keys
	 */
	function omit(object, omitKeys) {
	    if (!omitKeys.length) {
	        return object;
	    }
	    return Object.keys(object).reduce(function (updated, key) {
	        if (!omitKeys.includes(key)) {
	            updated[key] = object[key];
	        }
	        return updated;
	    }, {});
	}

	/**
	 * Typeguard that will check if the provided checkable thing is a
	 * MutableRefObject or just an HTMLElement.
	 *
	 * @private
	 */
	var isMutableRefObject = function (thing) {
	    return !!thing &&
	        typeof thing.current !== "undefined";
	};
	/**
	 * Gets the HTMLElement or null from the checkable thing.
	 *
	 * @private
	 */
	var getElement = function (thing) {
	    if (isMutableRefObject(thing)) {
	        return thing.current;
	    }
	    return thing;
	};
	/**
	 * Checks if a container element contains another element as a child while
	 * allowing for nulls or a MutableRefObject of HTMLElement or null. Mostly just
	 * a convenience function that should be used internally.
	 *
	 * @param container The element to use as a container element. This can be an
	 * HTMLElement, null, or a MutableRefObject of HTMLElement or null.
	 * @param child The element that might be a child of the container
	 * element. This can be an HTMLElement, null, or a MutableRefObject of
	 * HTMLElement or null.
	 * @return True if the container contains the child element and both the
	 * container and child are valid HTMLElements (not null).
	 * @private
	 */
	function containsElement(container, child) {
	    container = getElement(container);
	    child = getElement(child);
	    return !!(container && child && container.contains(child));
	}

	/**
	 * A simple util to convert a unit that is using `px`, `em`, or `rem` to a
	 * number so that calculations can be made on that unit.
	 *
	 * @param unit The unit to convert to a number
	 * @param element The element to use to use for calculating `em`
	 * @return the unit as a number
	 */
	function unitToNumber(unit, options) {
	    if (options === void 0) { options = {}; }
	    var _a = options.fontSizeFallback, fontSizeFallback = _a === void 0 ? 16 : _a, element = options.element;
	    if (typeof unit === "number") {
	        return unit;
	    }
	    var parsed = parseFloat(unit);
	    if (/px$/.test(unit)) {
	        return parsed;
	    }
	    if (typeof document === "undefined") {
	        return parsed * fontSizeFallback;
	    }
	    var rem = /rem$/.test(unit);
	    var el = document.documentElement;
	    if (!rem && element) {
	        el = element.parentElement || element;
	    }
	    var fontSize = parseFloat(window.getComputedStyle(el).fontSize || fontSizeFallback + "px");
	    return parsed * fontSize;
	}

	/**
	 * Creates a throttled version of a function so that it'll be called with
	 * trailing and leading calls. Since I always get this confused with `debounce`,
	 * here's a quick summary of the differences:
	 *
	 * - debounce will wait to call the function until it hasn't been called again
	 *   for the wait duration without trailing or leading calls. If it has the
	 *   trailing and leading calls, I can't figure out how it's different than
	 *   throttle.
	 * - throttle will be called each time it is available to be called.
	 *
	 * So debounce is great for things like auto-save features if you want to save
	 * whenever the user stops typing for a few seconds while throttle is good for
	 * things like sending an API request when the user is typing so that it isn't
	 * sent every keystroke, but every few letters. You _could_ also do debounce
	 * here, but it'll feel more "responsive" to the user when throttled.
	 *
	 * @param fn The function that should be throttled
	 * @param wait The number of milliseconds to wait before calling the function
	 * again
	 * @return a throttled version of the function that'll return the last computed
	 * value if it was called again during the "wait" period.
	 */
	function throttle$1(fn, wait) {
	    var lastCalledTime = 0;
	    var timeout;
	    var result;
	    var args;
	    function trailingCall() {
	        lastCalledTime = Date.now();
	        timeout = undefined;
	        result = fn.apply(void 0, args);
	    }
	    return function throttled() {
	        var nextArgs = [];
	        for (var _i = 0; _i < arguments.length; _i++) {
	            nextArgs[_i] = arguments[_i];
	        }
	        args = nextArgs;
	        var now = Date.now();
	        var remaining = wait - (now - lastCalledTime);
	        if (remaining <= 0 || remaining > wait) {
	            lastCalledTime = now;
	            result = fn.apply(void 0, args);
	        }
	        else if (!timeout) {
	            timeout = window.setTimeout(trailingCall, remaining);
	        }
	        return result;
	    };
	}

	/**
	 * Simple hook to use an interval with auto setup and teardown. The provided
	 * functions will be guaranteed to not change and are memoized.
	 *
	 * @param callback The callback function to call
	 * @param delay The time in milliseconds the timer should delay between
	 * executions of the callback function
	 * @param defaultRunning Boolean if the interval should be started immediately
	 * @return a list containing a boolean if the interval is running, function to
	 * start the interval, and a function to stop the interval.
	 */
	function useInterval(callback, delay, defaultRunning) {
	    if (defaultRunning === void 0) { defaultRunning = false; }
	    var ref = useRefCache(callback);
	    var _a = useToggle(defaultRunning), running = _a[0], start = _a[1], stop = _a[2];
	    React.useEffect(function () {
	        if (!running) {
	            return;
	        }
	        var interval = window.setInterval(function () {
	            ref.current(stop);
	        }, delay);
	        return function () {
	            window.clearInterval(interval);
	        };
	        // disabled since useRefCache for the callback
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [delay, running, stop]);
	    return [running, start, stop];
	}

	/**
	 * Simple hook to use an timeout with auto setup and teardown. The provided
	 * functions will be guaranteed to not change and are memoized.
	 *
	 * @param cb The callback function to call
	 * @param delay The time in milliseconds the timer should delay between
	 * executions of the callback function
	 * @param defaultStarted Boolean if the timeout should be started immediately.
	 * @return a list containing a function to start the timeout, a function to stop
	 * the timeout, and a function to restart the timeout.
	 */
	function useTimeout(cb, delay, defaultStarted) {
	    if (defaultStarted === void 0) { defaultStarted = false; }
	    var cbRef = useRefCache(cb);
	    var delayRef = useRefCache(delay);
	    var timeoutRef = React.useRef();
	    var _a = useToggle(defaultStarted), enabled = _a[0], start = _a[1], disable = _a[2];
	    var clearTimeout = React.useCallback(function () {
	        window.clearTimeout(timeoutRef.current);
	        timeoutRef.current = undefined;
	    }, []);
	    /* eslint-disable react-hooks/exhaustive-deps */
	    // these are all guaranteed to not change since using refs or non-updating callbacks
	    var restart = React.useCallback(function () {
	        clearTimeout();
	        timeoutRef.current = window.setTimeout(function () {
	            cbRef.current();
	            disable();
	        }, delayRef.current);
	    }, []);
	    var stop = React.useCallback(function () {
	        clearTimeout();
	        disable();
	    }, []);
	    React.useEffect(function () {
	        if (!enabled) {
	            return;
	        }
	        timeoutRef.current = window.setTimeout(function () {
	            cbRef.current();
	            disable();
	        }, delay);
	        return function () {
	            clearTimeout();
	        };
	    }, [enabled, delay, disable]);
	    return [start, stop, restart];
	}

	/**
	 * Gets the HTMLElement or null from a provided RefObject or HTMLElement/null
	 * @private
	 */
	function getElement$1(element) {
	    if (!element) {
	        return null;
	    }
	    if (typeof element.current !== "undefined") {
	        return element.current;
	    }
	    return element;
	}
	/**
	 * Triggers a callback function when another element in the page is clicked that
	 * is outside of the provided element. This is generally used for closing
	 * temporary elements when something else within the page has been clicked.
	 *
	 * The callback will be provided the current `element` as well as the click
	 * target if additional logic should be applied before closing.
	 *
	 * @typeparam E The type of element
	 */
	function useCloseOnOutsideClick(_a) {
	    var enabled = _a.enabled, element = _a.element, onOutsideClick = _a.onOutsideClick;
	    React.useEffect(function () {
	        if (!enabled) {
	            return;
	        }
	        function handleClick(event) {
	            var target = event.target;
	            var el = getElement$1(element);
	            if (!containsElement(el, target)) {
	                onOutsideClick(el, target, containsElement);
	            }
	        }
	        window.addEventListener("click", handleClick);
	        return function () {
	            window.removeEventListener("click", handleClick);
	        };
	    }, [enabled, element, onOutsideClick]);
	}

	var __assign$d = (undefined && undefined.__assign) || function () {
	    __assign$d = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d.apply(this, arguments);
	};
	var __rest$8 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$4 = bem("rmd-snackbar");
	var Snackbar = React.forwardRef(function Snackbar(_a, ref) {
	    var _b;
	    var className = _a.className, children = _a.children, _c = _a.portal, portal = _c === void 0 ? false : _c, portalInto = _a.portalInto, portalIntoId = _a.portalIntoId, _d = _a.position, position = _d === void 0 ? "bottom" : _d, props = __rest$8(_a, ["className", "children", "portal", "portalInto", "portalIntoId", "position"]);
	    return (React__default.createElement(ConditionalPortal, { portal: portal, portalInto: portalInto, portalIntoId: portalIntoId },
	        React__default.createElement("div", __assign$d({}, props, { role: "status", ref: ref, className: classnames(block$4((_b = {}, _b[position] = true, _b)), className) }), children)));
	});
	{
	    try {
	        var PropTypes$b = require("prop-types");
	        Snackbar.propTypes = {
	            id: PropTypes$b.string.isRequired,
	            className: PropTypes$b.string,
	            children: PropTypes$b.node,
	            position: PropTypes$b.oneOf(["bottom", "top"]),
	            portal: PropTypes$b.bool,
	            portalInto: PropTypes$b.oneOfType([PropTypes$b.object, PropTypes$b.string]),
	            portalIntoId: PropTypes$b.string,
	        };
	    }
	    catch (e) { }
	}

	function _extends() {
	  _extends = Object.assign || function (target) {
	    for (var i = 1; i < arguments.length; i++) {
	      var source = arguments[i];

	      for (var key in source) {
	        if (Object.prototype.hasOwnProperty.call(source, key)) {
	          target[key] = source[key];
	        }
	      }
	    }

	    return target;
	  };

	  return _extends.apply(this, arguments);
	}

	function _objectWithoutPropertiesLoose(source, excluded) {
	  if (source == null) return {};
	  var target = {};
	  var sourceKeys = Object.keys(source);
	  var key, i;

	  for (i = 0; i < sourceKeys.length; i++) {
	    key = sourceKeys[i];
	    if (excluded.indexOf(key) >= 0) continue;
	    target[key] = source[key];
	  }

	  return target;
	}

	function _inheritsLoose(subClass, superClass) {
	  subClass.prototype = Object.create(superClass.prototype);
	  subClass.prototype.constructor = subClass;
	  subClass.__proto__ = superClass;
	}

	var reactIs_development = createCommonjsModule(function (module, exports) {



	{
	  (function() {

	// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
	// nor polyfill, then a plain number is used for performance.
	var hasSymbol = typeof Symbol === 'function' && Symbol.for;
	var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
	var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
	var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
	var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
	var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
	var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
	var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
	// (unstable) APIs that have been removed. Can we remove the symbols?

	var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
	var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
	var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
	var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
	var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
	var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
	var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
	var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
	var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
	var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
	var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;

	function isValidElementType(type) {
	  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
	  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
	}

	function typeOf(object) {
	  if (typeof object === 'object' && object !== null) {
	    var $$typeof = object.$$typeof;

	    switch ($$typeof) {
	      case REACT_ELEMENT_TYPE:
	        var type = object.type;

	        switch (type) {
	          case REACT_ASYNC_MODE_TYPE:
	          case REACT_CONCURRENT_MODE_TYPE:
	          case REACT_FRAGMENT_TYPE:
	          case REACT_PROFILER_TYPE:
	          case REACT_STRICT_MODE_TYPE:
	          case REACT_SUSPENSE_TYPE:
	            return type;

	          default:
	            var $$typeofType = type && type.$$typeof;

	            switch ($$typeofType) {
	              case REACT_CONTEXT_TYPE:
	              case REACT_FORWARD_REF_TYPE:
	              case REACT_LAZY_TYPE:
	              case REACT_MEMO_TYPE:
	              case REACT_PROVIDER_TYPE:
	                return $$typeofType;

	              default:
	                return $$typeof;
	            }

	        }

	      case REACT_PORTAL_TYPE:
	        return $$typeof;
	    }
	  }

	  return undefined;
	} // AsyncMode is deprecated along with isAsyncMode

	var AsyncMode = REACT_ASYNC_MODE_TYPE;
	var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
	var ContextConsumer = REACT_CONTEXT_TYPE;
	var ContextProvider = REACT_PROVIDER_TYPE;
	var Element = REACT_ELEMENT_TYPE;
	var ForwardRef = REACT_FORWARD_REF_TYPE;
	var Fragment = REACT_FRAGMENT_TYPE;
	var Lazy = REACT_LAZY_TYPE;
	var Memo = REACT_MEMO_TYPE;
	var Portal = REACT_PORTAL_TYPE;
	var Profiler = REACT_PROFILER_TYPE;
	var StrictMode = REACT_STRICT_MODE_TYPE;
	var Suspense = REACT_SUSPENSE_TYPE;
	var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated

	function isAsyncMode(object) {
	  {
	    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
	      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint

	      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
	    }
	  }

	  return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
	}
	function isConcurrentMode(object) {
	  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
	}
	function isContextConsumer(object) {
	  return typeOf(object) === REACT_CONTEXT_TYPE;
	}
	function isContextProvider(object) {
	  return typeOf(object) === REACT_PROVIDER_TYPE;
	}
	function isElement(object) {
	  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
	}
	function isForwardRef(object) {
	  return typeOf(object) === REACT_FORWARD_REF_TYPE;
	}
	function isFragment(object) {
	  return typeOf(object) === REACT_FRAGMENT_TYPE;
	}
	function isLazy(object) {
	  return typeOf(object) === REACT_LAZY_TYPE;
	}
	function isMemo(object) {
	  return typeOf(object) === REACT_MEMO_TYPE;
	}
	function isPortal(object) {
	  return typeOf(object) === REACT_PORTAL_TYPE;
	}
	function isProfiler(object) {
	  return typeOf(object) === REACT_PROFILER_TYPE;
	}
	function isStrictMode(object) {
	  return typeOf(object) === REACT_STRICT_MODE_TYPE;
	}
	function isSuspense(object) {
	  return typeOf(object) === REACT_SUSPENSE_TYPE;
	}

	exports.AsyncMode = AsyncMode;
	exports.ConcurrentMode = ConcurrentMode;
	exports.ContextConsumer = ContextConsumer;
	exports.ContextProvider = ContextProvider;
	exports.Element = Element;
	exports.ForwardRef = ForwardRef;
	exports.Fragment = Fragment;
	exports.Lazy = Lazy;
	exports.Memo = Memo;
	exports.Portal = Portal;
	exports.Profiler = Profiler;
	exports.StrictMode = StrictMode;
	exports.Suspense = Suspense;
	exports.isAsyncMode = isAsyncMode;
	exports.isConcurrentMode = isConcurrentMode;
	exports.isContextConsumer = isContextConsumer;
	exports.isContextProvider = isContextProvider;
	exports.isElement = isElement;
	exports.isForwardRef = isForwardRef;
	exports.isFragment = isFragment;
	exports.isLazy = isLazy;
	exports.isMemo = isMemo;
	exports.isPortal = isPortal;
	exports.isProfiler = isProfiler;
	exports.isStrictMode = isStrictMode;
	exports.isSuspense = isSuspense;
	exports.isValidElementType = isValidElementType;
	exports.typeOf = typeOf;
	  })();
	}
	});

	var reactIs = createCommonjsModule(function (module) {

	{
	  module.exports = reactIs_development;
	}
	});

	/*
	object-assign
	(c) Sindre Sorhus
	@license MIT
	*/
	/* eslint-disable no-unused-vars */
	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
	var hasOwnProperty = Object.prototype.hasOwnProperty;
	var propIsEnumerable = Object.prototype.propertyIsEnumerable;

	function toObject(val) {
		if (val === null || val === undefined) {
			throw new TypeError('Object.assign cannot be called with null or undefined');
		}

		return Object(val);
	}

	function shouldUseNative() {
		try {
			if (!Object.assign) {
				return false;
			}

			// Detect buggy property enumeration order in older V8 versions.

			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
			var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
			test1[5] = 'de';
			if (Object.getOwnPropertyNames(test1)[0] === '5') {
				return false;
			}

			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
			var test2 = {};
			for (var i = 0; i < 10; i++) {
				test2['_' + String.fromCharCode(i)] = i;
			}
			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
				return test2[n];
			});
			if (order2.join('') !== '0123456789') {
				return false;
			}

			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
			var test3 = {};
			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
				test3[letter] = letter;
			});
			if (Object.keys(Object.assign({}, test3)).join('') !==
					'abcdefghijklmnopqrst') {
				return false;
			}

			return true;
		} catch (err) {
			// We don't expect any of the above to throw, but better to be safe.
			return false;
		}
	}

	var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
		var from;
		var to = toObject(target);
		var symbols;

		for (var s = 1; s < arguments.length; s++) {
			from = Object(arguments[s]);

			for (var key in from) {
				if (hasOwnProperty.call(from, key)) {
					to[key] = from[key];
				}
			}

			if (getOwnPropertySymbols) {
				symbols = getOwnPropertySymbols(from);
				for (var i = 0; i < symbols.length; i++) {
					if (propIsEnumerable.call(from, symbols[i])) {
						to[symbols[i]] = from[symbols[i]];
					}
				}
			}
		}

		return to;
	};

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */

	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';

	var ReactPropTypesSecret_1 = ReactPropTypesSecret;

	var printWarning = function() {};

	{
	  var ReactPropTypesSecret$1 = ReactPropTypesSecret_1;
	  var loggedTypeFailures = {};
	  var has = Function.call.bind(Object.prototype.hasOwnProperty);

	  printWarning = function(text) {
	    var message = 'Warning: ' + text;
	    if (typeof console !== 'undefined') {
	      console.error(message);
	    }
	    try {
	      // --- Welcome to debugging React ---
	      // This error was thrown as a convenience so that you can use this stack
	      // to find the callsite that caused this warning to fire.
	      throw new Error(message);
	    } catch (x) {}
	  };
	}

	/**
	 * Assert that the values match with the type specs.
	 * Error messages are memorized and will only be shown once.
	 *
	 * @param {object} typeSpecs Map of name to a ReactPropType
	 * @param {object} values Runtime values that need to be type-checked
	 * @param {string} location e.g. "prop", "context", "child context"
	 * @param {string} componentName Name of the component for error messages.
	 * @param {?Function} getStack Returns the component stack.
	 * @private
	 */
	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
	  {
	    for (var typeSpecName in typeSpecs) {
	      if (has(typeSpecs, typeSpecName)) {
	        var error;
	        // Prop type validation may throw. In case they do, we don't want to
	        // fail the render phase where it didn't fail before. So we log it.
	        // After these have been cleaned up, we'll let them throw.
	        try {
	          // This is intentionally an invariant that gets caught. It's the same
	          // behavior as without this statement except with a better message.
	          if (typeof typeSpecs[typeSpecName] !== 'function') {
	            var err = Error(
	              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
	              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.'
	            );
	            err.name = 'Invariant Violation';
	            throw err;
	          }
	          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret$1);
	        } catch (ex) {
	          error = ex;
	        }
	        if (error && !(error instanceof Error)) {
	          printWarning(
	            (componentName || 'React class') + ': type specification of ' +
	            location + ' `' + typeSpecName + '` is invalid; the type checker ' +
	            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
	            'You may have forgotten to pass an argument to the type checker ' +
	            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
	            'shape all require an argument).'
	          );
	        }
	        if (error instanceof Error && !(error.message in loggedTypeFailures)) {
	          // Only monitor this failure once because there tends to be a lot of the
	          // same error.
	          loggedTypeFailures[error.message] = true;

	          var stack = getStack ? getStack() : '';

	          printWarning(
	            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
	          );
	        }
	      }
	    }
	  }
	}

	/**
	 * Resets warning cache when testing.
	 *
	 * @private
	 */
	checkPropTypes.resetWarningCache = function() {
	  {
	    loggedTypeFailures = {};
	  }
	};

	var checkPropTypes_1 = checkPropTypes;

	var has$1 = Function.call.bind(Object.prototype.hasOwnProperty);
	var printWarning$1 = function() {};

	{
	  printWarning$1 = function(text) {
	    var message = 'Warning: ' + text;
	    if (typeof console !== 'undefined') {
	      console.error(message);
	    }
	    try {
	      // --- Welcome to debugging React ---
	      // This error was thrown as a convenience so that you can use this stack
	      // to find the callsite that caused this warning to fire.
	      throw new Error(message);
	    } catch (x) {}
	  };
	}

	function emptyFunctionThatReturnsNull() {
	  return null;
	}

	var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
	  /* global Symbol */
	  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
	  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.

	  /**
	   * Returns the iterator method function contained on the iterable object.
	   *
	   * Be sure to invoke the function with the iterable as context:
	   *
	   *     var iteratorFn = getIteratorFn(myIterable);
	   *     if (iteratorFn) {
	   *       var iterator = iteratorFn.call(myIterable);
	   *       ...
	   *     }
	   *
	   * @param {?object} maybeIterable
	   * @return {?function}
	   */
	  function getIteratorFn(maybeIterable) {
	    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
	    if (typeof iteratorFn === 'function') {
	      return iteratorFn;
	    }
	  }

	  /**
	   * Collection of methods that allow declaration and validation of props that are
	   * supplied to React components. Example usage:
	   *
	   *   var Props = require('ReactPropTypes');
	   *   var MyArticle = React.createClass({
	   *     propTypes: {
	   *       // An optional string prop named "description".
	   *       description: Props.string,
	   *
	   *       // A required enum prop named "category".
	   *       category: Props.oneOf(['News','Photos']).isRequired,
	   *
	   *       // A prop named "dialog" that requires an instance of Dialog.
	   *       dialog: Props.instanceOf(Dialog).isRequired
	   *     },
	   *     render: function() { ... }
	   *   });
	   *
	   * A more formal specification of how these methods are used:
	   *
	   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
	   *   decl := ReactPropTypes.{type}(.isRequired)?
	   *
	   * Each and every declaration produces a function with the same signature. This
	   * allows the creation of custom validation functions. For example:
	   *
	   *  var MyLink = React.createClass({
	   *    propTypes: {
	   *      // An optional string or URI prop named "href".
	   *      href: function(props, propName, componentName) {
	   *        var propValue = props[propName];
	   *        if (propValue != null && typeof propValue !== 'string' &&
	   *            !(propValue instanceof URI)) {
	   *          return new Error(
	   *            'Expected a string or an URI for ' + propName + ' in ' +
	   *            componentName
	   *          );
	   *        }
	   *      }
	   *    },
	   *    render: function() {...}
	   *  });
	   *
	   * @internal
	   */

	  var ANONYMOUS = '<<anonymous>>';

	  // Important!
	  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
	  var ReactPropTypes = {
	    array: createPrimitiveTypeChecker('array'),
	    bool: createPrimitiveTypeChecker('boolean'),
	    func: createPrimitiveTypeChecker('function'),
	    number: createPrimitiveTypeChecker('number'),
	    object: createPrimitiveTypeChecker('object'),
	    string: createPrimitiveTypeChecker('string'),
	    symbol: createPrimitiveTypeChecker('symbol'),

	    any: createAnyTypeChecker(),
	    arrayOf: createArrayOfTypeChecker,
	    element: createElementTypeChecker(),
	    elementType: createElementTypeTypeChecker(),
	    instanceOf: createInstanceTypeChecker,
	    node: createNodeChecker(),
	    objectOf: createObjectOfTypeChecker,
	    oneOf: createEnumTypeChecker,
	    oneOfType: createUnionTypeChecker,
	    shape: createShapeTypeChecker,
	    exact: createStrictShapeTypeChecker,
	  };

	  /**
	   * inlined Object.is polyfill to avoid requiring consumers ship their own
	   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
	   */
	  /*eslint-disable no-self-compare*/
	  function is(x, y) {
	    // SameValue algorithm
	    if (x === y) {
	      // Steps 1-5, 7-10
	      // Steps 6.b-6.e: +0 != -0
	      return x !== 0 || 1 / x === 1 / y;
	    } else {
	      // Step 6.a: NaN == NaN
	      return x !== x && y !== y;
	    }
	  }
	  /*eslint-enable no-self-compare*/

	  /**
	   * We use an Error-like object for backward compatibility as people may call
	   * PropTypes directly and inspect their output. However, we don't use real
	   * Errors anymore. We don't inspect their stack anyway, and creating them
	   * is prohibitively expensive if they are created too often, such as what
	   * happens in oneOfType() for any type before the one that matched.
	   */
	  function PropTypeError(message) {
	    this.message = message;
	    this.stack = '';
	  }
	  // Make `instanceof Error` still work for returned errors.
	  PropTypeError.prototype = Error.prototype;

	  function createChainableTypeChecker(validate) {
	    {
	      var manualPropTypeCallCache = {};
	      var manualPropTypeWarningCount = 0;
	    }
	    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
	      componentName = componentName || ANONYMOUS;
	      propFullName = propFullName || propName;

	      if (secret !== ReactPropTypesSecret_1) {
	        if (throwOnDirectAccess) {
	          // New behavior only for users of `prop-types` package
	          var err = new Error(
	            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
	            'Use `PropTypes.checkPropTypes()` to call them. ' +
	            'Read more at http://fb.me/use-check-prop-types'
	          );
	          err.name = 'Invariant Violation';
	          throw err;
	        } else if ( typeof console !== 'undefined') {
	          // Old behavior for people using React.PropTypes
	          var cacheKey = componentName + ':' + propName;
	          if (
	            !manualPropTypeCallCache[cacheKey] &&
	            // Avoid spamming the console because they are often not actionable except for lib authors
	            manualPropTypeWarningCount < 3
	          ) {
	            printWarning$1(
	              'You are manually calling a React.PropTypes validation ' +
	              'function for the `' + propFullName + '` prop on `' + componentName  + '`. This is deprecated ' +
	              'and will throw in the standalone `prop-types` package. ' +
	              'You may be seeing this warning due to a third-party PropTypes ' +
	              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'
	            );
	            manualPropTypeCallCache[cacheKey] = true;
	            manualPropTypeWarningCount++;
	          }
	        }
	      }
	      if (props[propName] == null) {
	        if (isRequired) {
	          if (props[propName] === null) {
	            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
	          }
	          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
	        }
	        return null;
	      } else {
	        return validate(props, propName, componentName, location, propFullName);
	      }
	    }

	    var chainedCheckType = checkType.bind(null, false);
	    chainedCheckType.isRequired = checkType.bind(null, true);

	    return chainedCheckType;
	  }

	  function createPrimitiveTypeChecker(expectedType) {
	    function validate(props, propName, componentName, location, propFullName, secret) {
	      var propValue = props[propName];
	      var propType = getPropType(propValue);
	      if (propType !== expectedType) {
	        // `propValue` being instance of, say, date/regexp, pass the 'object'
	        // check, but we can offer a more precise error message here rather than
	        // 'of type `object`'.
	        var preciseType = getPreciseType(propValue);

	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
	      }
	      return null;
	    }
	    return createChainableTypeChecker(validate);
	  }

	  function createAnyTypeChecker() {
	    return createChainableTypeChecker(emptyFunctionThatReturnsNull);
	  }

	  function createArrayOfTypeChecker(typeChecker) {
	    function validate(props, propName, componentName, location, propFullName) {
	      if (typeof typeChecker !== 'function') {
	        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
	      }
	      var propValue = props[propName];
	      if (!Array.isArray(propValue)) {
	        var propType = getPropType(propValue);
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
	      }
	      for (var i = 0; i < propValue.length; i++) {
	        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret_1);
	        if (error instanceof Error) {
	          return error;
	        }
	      }
	      return null;
	    }
	    return createChainableTypeChecker(validate);
	  }

	  function createElementTypeChecker() {
	    function validate(props, propName, componentName, location, propFullName) {
	      var propValue = props[propName];
	      if (!isValidElement(propValue)) {
	        var propType = getPropType(propValue);
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
	      }
	      return null;
	    }
	    return createChainableTypeChecker(validate);
	  }

	  function createElementTypeTypeChecker() {
	    function validate(props, propName, componentName, location, propFullName) {
	      var propValue = props[propName];
	      if (!reactIs.isValidElementType(propValue)) {
	        var propType = getPropType(propValue);
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
	      }
	      return null;
	    }
	    return createChainableTypeChecker(validate);
	  }

	  function createInstanceTypeChecker(expectedClass) {
	    function validate(props, propName, componentName, location, propFullName) {
	      if (!(props[propName] instanceof expectedClass)) {
	        var expectedClassName = expectedClass.name || ANONYMOUS;
	        var actualClassName = getClassName(props[propName]);
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
	      }
	      return null;
	    }
	    return createChainableTypeChecker(validate);
	  }

	  function createEnumTypeChecker(expectedValues) {
	    if (!Array.isArray(expectedValues)) {
	      {
	        if (arguments.length > 1) {
	          printWarning$1(
	            'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +
	            'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'
	          );
	        } else {
	          printWarning$1('Invalid argument supplied to oneOf, expected an array.');
	        }
	      }
	      return emptyFunctionThatReturnsNull;
	    }

	    function validate(props, propName, componentName, location, propFullName) {
	      var propValue = props[propName];
	      for (var i = 0; i < expectedValues.length; i++) {
	        if (is(propValue, expectedValues[i])) {
	          return null;
	        }
	      }

	      var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
	        var type = getPreciseType(value);
	        if (type === 'symbol') {
	          return String(value);
	        }
	        return value;
	      });
	      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
	    }
	    return createChainableTypeChecker(validate);
	  }

	  function createObjectOfTypeChecker(typeChecker) {
	    function validate(props, propName, componentName, location, propFullName) {
	      if (typeof typeChecker !== 'function') {
	        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
	      }
	      var propValue = props[propName];
	      var propType = getPropType(propValue);
	      if (propType !== 'object') {
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
	      }
	      for (var key in propValue) {
	        if (has$1(propValue, key)) {
	          var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret_1);
	          if (error instanceof Error) {
	            return error;
	          }
	        }
	      }
	      return null;
	    }
	    return createChainableTypeChecker(validate);
	  }

	  function createUnionTypeChecker(arrayOfTypeCheckers) {
	    if (!Array.isArray(arrayOfTypeCheckers)) {
	       printWarning$1('Invalid argument supplied to oneOfType, expected an instance of array.') ;
	      return emptyFunctionThatReturnsNull;
	    }

	    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
	      var checker = arrayOfTypeCheckers[i];
	      if (typeof checker !== 'function') {
	        printWarning$1(
	          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
	          'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'
	        );
	        return emptyFunctionThatReturnsNull;
	      }
	    }

	    function validate(props, propName, componentName, location, propFullName) {
	      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
	        var checker = arrayOfTypeCheckers[i];
	        if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret_1) == null) {
	          return null;
	        }
	      }

	      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
	    }
	    return createChainableTypeChecker(validate);
	  }

	  function createNodeChecker() {
	    function validate(props, propName, componentName, location, propFullName) {
	      if (!isNode(props[propName])) {
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
	      }
	      return null;
	    }
	    return createChainableTypeChecker(validate);
	  }

	  function createShapeTypeChecker(shapeTypes) {
	    function validate(props, propName, componentName, location, propFullName) {
	      var propValue = props[propName];
	      var propType = getPropType(propValue);
	      if (propType !== 'object') {
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
	      }
	      for (var key in shapeTypes) {
	        var checker = shapeTypes[key];
	        if (!checker) {
	          continue;
	        }
	        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret_1);
	        if (error) {
	          return error;
	        }
	      }
	      return null;
	    }
	    return createChainableTypeChecker(validate);
	  }

	  function createStrictShapeTypeChecker(shapeTypes) {
	    function validate(props, propName, componentName, location, propFullName) {
	      var propValue = props[propName];
	      var propType = getPropType(propValue);
	      if (propType !== 'object') {
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
	      }
	      // We need to check all keys in case some are required but missing from
	      // props.
	      var allKeys = objectAssign({}, props[propName], shapeTypes);
	      for (var key in allKeys) {
	        var checker = shapeTypes[key];
	        if (!checker) {
	          return new PropTypeError(
	            'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
	            '\nBad object: ' + JSON.stringify(props[propName], null, '  ') +
	            '\nValid keys: ' +  JSON.stringify(Object.keys(shapeTypes), null, '  ')
	          );
	        }
	        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret_1);
	        if (error) {
	          return error;
	        }
	      }
	      return null;
	    }

	    return createChainableTypeChecker(validate);
	  }

	  function isNode(propValue) {
	    switch (typeof propValue) {
	      case 'number':
	      case 'string':
	      case 'undefined':
	        return true;
	      case 'boolean':
	        return !propValue;
	      case 'object':
	        if (Array.isArray(propValue)) {
	          return propValue.every(isNode);
	        }
	        if (propValue === null || isValidElement(propValue)) {
	          return true;
	        }

	        var iteratorFn = getIteratorFn(propValue);
	        if (iteratorFn) {
	          var iterator = iteratorFn.call(propValue);
	          var step;
	          if (iteratorFn !== propValue.entries) {
	            while (!(step = iterator.next()).done) {
	              if (!isNode(step.value)) {
	                return false;
	              }
	            }
	          } else {
	            // Iterator will provide entry [k,v] tuples rather than values.
	            while (!(step = iterator.next()).done) {
	              var entry = step.value;
	              if (entry) {
	                if (!isNode(entry[1])) {
	                  return false;
	                }
	              }
	            }
	          }
	        } else {
	          return false;
	        }

	        return true;
	      default:
	        return false;
	    }
	  }

	  function isSymbol(propType, propValue) {
	    // Native Symbol.
	    if (propType === 'symbol') {
	      return true;
	    }

	    // falsy value can't be a Symbol
	    if (!propValue) {
	      return false;
	    }

	    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
	    if (propValue['@@toStringTag'] === 'Symbol') {
	      return true;
	    }

	    // Fallback for non-spec compliant Symbols which are polyfilled.
	    if (typeof Symbol === 'function' && propValue instanceof Symbol) {
	      return true;
	    }

	    return false;
	  }

	  // Equivalent of `typeof` but with special handling for array and regexp.
	  function getPropType(propValue) {
	    var propType = typeof propValue;
	    if (Array.isArray(propValue)) {
	      return 'array';
	    }
	    if (propValue instanceof RegExp) {
	      // Old webkits (at least until Android 4.0) return 'function' rather than
	      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
	      // passes PropTypes.object.
	      return 'object';
	    }
	    if (isSymbol(propType, propValue)) {
	      return 'symbol';
	    }
	    return propType;
	  }

	  // This handles more types than `getPropType`. Only used for error messages.
	  // See `createPrimitiveTypeChecker`.
	  function getPreciseType(propValue) {
	    if (typeof propValue === 'undefined' || propValue === null) {
	      return '' + propValue;
	    }
	    var propType = getPropType(propValue);
	    if (propType === 'object') {
	      if (propValue instanceof Date) {
	        return 'date';
	      } else if (propValue instanceof RegExp) {
	        return 'regexp';
	      }
	    }
	    return propType;
	  }

	  // Returns a string that is postfixed to a warning about an invalid type.
	  // For example, "undefined" or "of type array"
	  function getPostfixForTypeWarning(value) {
	    var type = getPreciseType(value);
	    switch (type) {
	      case 'array':
	      case 'object':
	        return 'an ' + type;
	      case 'boolean':
	      case 'date':
	      case 'regexp':
	        return 'a ' + type;
	      default:
	        return type;
	    }
	  }

	  // Returns class name of the object, if any.
	  function getClassName(propValue) {
	    if (!propValue.constructor || !propValue.constructor.name) {
	      return ANONYMOUS;
	    }
	    return propValue.constructor.name;
	  }

	  ReactPropTypes.checkPropTypes = checkPropTypes_1;
	  ReactPropTypes.resetWarningCache = checkPropTypes_1.resetWarningCache;
	  ReactPropTypes.PropTypes = ReactPropTypes;

	  return ReactPropTypes;
	};

	var propTypes = createCommonjsModule(function (module) {
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */

	{
	  var ReactIs = reactIs;

	  // By explicitly using `prop-types` you are opting into new development behavior.
	  // http://fb.me/prop-types-in-prod
	  var throwOnDirectAccess = true;
	  module.exports = factoryWithTypeCheckers(ReactIs.isElement, throwOnDirectAccess);
	}
	});

	function hasClass(element, className) {
	  if (element.classList) return !!className && element.classList.contains(className);
	  return (" " + (element.className.baseVal || element.className) + " ").indexOf(" " + className + " ") !== -1;
	}

	function addClass(element, className) {
	  if (element.classList) element.classList.add(className);else if (!hasClass(element, className)) if (typeof element.className === 'string') element.className = element.className + " " + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + " " + className);
	}

	function replaceClassName(origClass, classToRemove) {
	  return origClass.replace(new RegExp("(^|\\s)" + classToRemove + "(?:\\s|$)", 'g'), '$1').replace(/\s+/g, ' ').replace(/^\s*|\s*$/g, '');
	}

	function removeClass(element, className) {
	  if (element.classList) {
	    element.classList.remove(className);
	  } else if (typeof element.className === 'string') {
	    element.className = replaceClassName(element.className, className);
	  } else {
	    element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));
	  }
	}

	var config = {
	  disabled: false
	};

	var timeoutsShape =  propTypes.oneOfType([propTypes.number, propTypes.shape({
	  enter: propTypes.number,
	  exit: propTypes.number,
	  appear: propTypes.number
	}).isRequired]) ;
	var classNamesShape =  propTypes.oneOfType([propTypes.string, propTypes.shape({
	  enter: propTypes.string,
	  exit: propTypes.string,
	  active: propTypes.string
	}), propTypes.shape({
	  enter: propTypes.string,
	  enterDone: propTypes.string,
	  enterActive: propTypes.string,
	  exit: propTypes.string,
	  exitDone: propTypes.string,
	  exitActive: propTypes.string
	})]) ;

	var TransitionGroupContext = React__default.createContext(null);

	var UNMOUNTED = 'unmounted';
	var EXITED = 'exited';
	var ENTERING = 'entering';
	var ENTERED = 'entered';
	var EXITING = 'exiting';
	/**
	 * The Transition component lets you describe a transition from one component
	 * state to another _over time_ with a simple declarative API. Most commonly
	 * it's used to animate the mounting and unmounting of a component, but can also
	 * be used to describe in-place transition states as well.
	 *
	 * ---
	 *
	 * **Note**: `Transition` is a platform-agnostic base component. If you're using
	 * transitions in CSS, you'll probably want to use
	 * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)
	 * instead. It inherits all the features of `Transition`, but contains
	 * additional features necessary to play nice with CSS transitions (hence the
	 * name of the component).
	 *
	 * ---
	 *
	 * By default the `Transition` component does not alter the behavior of the
	 * component it renders, it only tracks "enter" and "exit" states for the
	 * components. It's up to you to give meaning and effect to those states. For
	 * example we can add styles to a component when it enters or exits:
	 *
	 * ```jsx
	 * import { Transition } from 'react-transition-group';
	 *
	 * const duration = 300;
	 *
	 * const defaultStyle = {
	 *   transition: `opacity ${duration}ms ease-in-out`,
	 *   opacity: 0,
	 * }
	 *
	 * const transitionStyles = {
	 *   entering: { opacity: 1 },
	 *   entered:  { opacity: 1 },
	 *   exiting:  { opacity: 0 },
	 *   exited:  { opacity: 0 },
	 * };
	 *
	 * const Fade = ({ in: inProp }) => (
	 *   <Transition in={inProp} timeout={duration}>
	 *     {state => (
	 *       <div style={{
	 *         ...defaultStyle,
	 *         ...transitionStyles[state]
	 *       }}>
	 *         I'm a fade Transition!
	 *       </div>
	 *     )}
	 *   </Transition>
	 * );
	 * ```
	 *
	 * There are 4 main states a Transition can be in:
	 *  - `'entering'`
	 *  - `'entered'`
	 *  - `'exiting'`
	 *  - `'exited'`
	 *
	 * Transition state is toggled via the `in` prop. When `true` the component
	 * begins the "Enter" stage. During this stage, the component will shift from
	 * its current transition state, to `'entering'` for the duration of the
	 * transition and then to the `'entered'` stage once it's complete. Let's take
	 * the following example (we'll use the
	 * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):
	 *
	 * ```jsx
	 * function App() {
	 *   const [inProp, setInProp] = useState(false);
	 *   return (
	 *     <div>
	 *       <Transition in={inProp} timeout={500}>
	 *         {state => (
	 *           // ...
	 *         )}
	 *       </Transition>
	 *       <button onClick={() => setInProp(true)}>
	 *         Click to Enter
	 *       </button>
	 *     </div>
	 *   );
	 * }
	 * ```
	 *
	 * When the button is clicked the component will shift to the `'entering'` state
	 * and stay there for 500ms (the value of `timeout`) before it finally switches
	 * to `'entered'`.
	 *
	 * When `in` is `false` the same thing happens except the state moves from
	 * `'exiting'` to `'exited'`.
	 */

	var Transition =
	/*#__PURE__*/
	function (_React$Component) {
	  _inheritsLoose(Transition, _React$Component);

	  function Transition(props, context) {
	    var _this;

	    _this = _React$Component.call(this, props, context) || this;
	    var parentGroup = context; // In the context of a TransitionGroup all enters are really appears

	    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;
	    var initialStatus;
	    _this.appearStatus = null;

	    if (props.in) {
	      if (appear) {
	        initialStatus = EXITED;
	        _this.appearStatus = ENTERING;
	      } else {
	        initialStatus = ENTERED;
	      }
	    } else {
	      if (props.unmountOnExit || props.mountOnEnter) {
	        initialStatus = UNMOUNTED;
	      } else {
	        initialStatus = EXITED;
	      }
	    }

	    _this.state = {
	      status: initialStatus
	    };
	    _this.nextCallback = null;
	    return _this;
	  }

	  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {
	    var nextIn = _ref.in;

	    if (nextIn && prevState.status === UNMOUNTED) {
	      return {
	        status: EXITED
	      };
	    }

	    return null;
	  }; // getSnapshotBeforeUpdate(prevProps) {
	  //   let nextStatus = null
	  //   if (prevProps !== this.props) {
	  //     const { status } = this.state
	  //     if (this.props.in) {
	  //       if (status !== ENTERING && status !== ENTERED) {
	  //         nextStatus = ENTERING
	  //       }
	  //     } else {
	  //       if (status === ENTERING || status === ENTERED) {
	  //         nextStatus = EXITING
	  //       }
	  //     }
	  //   }
	  //   return { nextStatus }
	  // }


	  var _proto = Transition.prototype;

	  _proto.componentDidMount = function componentDidMount() {
	    this.updateStatus(true, this.appearStatus);
	  };

	  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
	    var nextStatus = null;

	    if (prevProps !== this.props) {
	      var status = this.state.status;

	      if (this.props.in) {
	        if (status !== ENTERING && status !== ENTERED) {
	          nextStatus = ENTERING;
	        }
	      } else {
	        if (status === ENTERING || status === ENTERED) {
	          nextStatus = EXITING;
	        }
	      }
	    }

	    this.updateStatus(false, nextStatus);
	  };

	  _proto.componentWillUnmount = function componentWillUnmount() {
	    this.cancelNextCallback();
	  };

	  _proto.getTimeouts = function getTimeouts() {
	    var timeout = this.props.timeout;
	    var exit, enter, appear;
	    exit = enter = appear = timeout;

	    if (timeout != null && typeof timeout !== 'number') {
	      exit = timeout.exit;
	      enter = timeout.enter; // TODO: remove fallback for next major

	      appear = timeout.appear !== undefined ? timeout.appear : enter;
	    }

	    return {
	      exit: exit,
	      enter: enter,
	      appear: appear
	    };
	  };

	  _proto.updateStatus = function updateStatus(mounting, nextStatus) {
	    if (mounting === void 0) {
	      mounting = false;
	    }

	    if (nextStatus !== null) {
	      // nextStatus will always be ENTERING or EXITING.
	      this.cancelNextCallback();
	      var node = ReactDOM__default.findDOMNode(this);

	      if (nextStatus === ENTERING) {
	        this.performEnter(node, mounting);
	      } else {
	        this.performExit(node);
	      }
	    } else if (this.props.unmountOnExit && this.state.status === EXITED) {
	      this.setState({
	        status: UNMOUNTED
	      });
	    }
	  };

	  _proto.performEnter = function performEnter(node, mounting) {
	    var _this2 = this;

	    var enter = this.props.enter;
	    var appearing = this.context ? this.context.isMounting : mounting;
	    var timeouts = this.getTimeouts();
	    var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED
	    // if we are mounting and running this it means appear _must_ be set

	    if (!mounting && !enter || config.disabled) {
	      this.safeSetState({
	        status: ENTERED
	      }, function () {
	        _this2.props.onEntered(node);
	      });
	      return;
	    }

	    this.props.onEnter(node, appearing);
	    this.safeSetState({
	      status: ENTERING
	    }, function () {
	      _this2.props.onEntering(node, appearing);

	      _this2.onTransitionEnd(node, enterTimeout, function () {
	        _this2.safeSetState({
	          status: ENTERED
	        }, function () {
	          _this2.props.onEntered(node, appearing);
	        });
	      });
	    });
	  };

	  _proto.performExit = function performExit(node) {
	    var _this3 = this;

	    var exit = this.props.exit;
	    var timeouts = this.getTimeouts(); // no exit animation skip right to EXITED

	    if (!exit || config.disabled) {
	      this.safeSetState({
	        status: EXITED
	      }, function () {
	        _this3.props.onExited(node);
	      });
	      return;
	    }

	    this.props.onExit(node);
	    this.safeSetState({
	      status: EXITING
	    }, function () {
	      _this3.props.onExiting(node);

	      _this3.onTransitionEnd(node, timeouts.exit, function () {
	        _this3.safeSetState({
	          status: EXITED
	        }, function () {
	          _this3.props.onExited(node);
	        });
	      });
	    });
	  };

	  _proto.cancelNextCallback = function cancelNextCallback() {
	    if (this.nextCallback !== null) {
	      this.nextCallback.cancel();
	      this.nextCallback = null;
	    }
	  };

	  _proto.safeSetState = function safeSetState(nextState, callback) {
	    // This shouldn't be necessary, but there are weird race conditions with
	    // setState callbacks and unmounting in testing, so always make sure that
	    // we can cancel any pending setState callbacks after we unmount.
	    callback = this.setNextCallback(callback);
	    this.setState(nextState, callback);
	  };

	  _proto.setNextCallback = function setNextCallback(callback) {
	    var _this4 = this;

	    var active = true;

	    this.nextCallback = function (event) {
	      if (active) {
	        active = false;
	        _this4.nextCallback = null;
	        callback(event);
	      }
	    };

	    this.nextCallback.cancel = function () {
	      active = false;
	    };

	    return this.nextCallback;
	  };

	  _proto.onTransitionEnd = function onTransitionEnd(node, timeout, handler) {
	    this.setNextCallback(handler);
	    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;

	    if (!node || doesNotHaveTimeoutOrListener) {
	      setTimeout(this.nextCallback, 0);
	      return;
	    }

	    if (this.props.addEndListener) {
	      this.props.addEndListener(node, this.nextCallback);
	    }

	    if (timeout != null) {
	      setTimeout(this.nextCallback, timeout);
	    }
	  };

	  _proto.render = function render() {
	    var status = this.state.status;

	    if (status === UNMOUNTED) {
	      return null;
	    }

	    var _this$props = this.props,
	        children = _this$props.children,
	        childProps = _objectWithoutPropertiesLoose(_this$props, ["children"]); // filter props for Transtition


	    delete childProps.in;
	    delete childProps.mountOnEnter;
	    delete childProps.unmountOnExit;
	    delete childProps.appear;
	    delete childProps.enter;
	    delete childProps.exit;
	    delete childProps.timeout;
	    delete childProps.addEndListener;
	    delete childProps.onEnter;
	    delete childProps.onEntering;
	    delete childProps.onEntered;
	    delete childProps.onExit;
	    delete childProps.onExiting;
	    delete childProps.onExited;

	    if (typeof children === 'function') {
	      // allows for nested Transitions
	      return React__default.createElement(TransitionGroupContext.Provider, {
	        value: null
	      }, children(status, childProps));
	    }

	    var child = React__default.Children.only(children);
	    return (// allows for nested Transitions
	      React__default.createElement(TransitionGroupContext.Provider, {
	        value: null
	      }, React__default.cloneElement(child, childProps))
	    );
	  };

	  return Transition;
	}(React__default.Component);

	Transition.contextType = TransitionGroupContext;
	Transition.propTypes =  {
	  /**
	   * A `function` child can be used instead of a React element. This function is
	   * called with the current transition status (`'entering'`, `'entered'`,
	   * `'exiting'`, `'exited'`), which can be used to apply context
	   * specific props to a component.
	   *
	   * ```jsx
	   * <Transition in={this.state.in} timeout={150}>
	   *   {state => (
	   *     <MyComponent className={`fade fade-${state}`} />
	   *   )}
	   * </Transition>
	   * ```
	   */
	  children: propTypes.oneOfType([propTypes.func.isRequired, propTypes.element.isRequired]).isRequired,

	  /**
	   * Show the component; triggers the enter or exit states
	   */
	  in: propTypes.bool,

	  /**
	   * By default the child component is mounted immediately along with
	   * the parent `Transition` component. If you want to "lazy mount" the component on the
	   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
	   * mounted, even on "exited", unless you also specify `unmountOnExit`.
	   */
	  mountOnEnter: propTypes.bool,

	  /**
	   * By default the child component stays mounted after it reaches the `'exited'` state.
	   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
	   */
	  unmountOnExit: propTypes.bool,

	  /**
	   * Normally a component is not transitioned if it is shown when the
	   * `<Transition>` component mounts. If you want to transition on the first
	   * mount set `appear` to `true`, and the component will transition in as soon
	   * as the `<Transition>` mounts.
	   *
	   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
	   * > only adds an additional enter transition. However, in the
	   * > `<CSSTransition>` component that first enter transition does result in
	   * > additional `.appear-*` classes, that way you can choose to style it
	   * > differently.
	   */
	  appear: propTypes.bool,

	  /**
	   * Enable or disable enter transitions.
	   */
	  enter: propTypes.bool,

	  /**
	   * Enable or disable exit transitions.
	   */
	  exit: propTypes.bool,

	  /**
	   * The duration of the transition, in milliseconds.
	   * Required unless `addEndListener` is provided.
	   *
	   * You may specify a single timeout for all transitions:
	   *
	   * ```jsx
	   * timeout={500}
	   * ```
	   *
	   * or individually:
	   *
	   * ```jsx
	   * timeout={{
	   *  appear: 500,
	   *  enter: 300,
	   *  exit: 500,
	   * }}
	   * ```
	   *
	   * - `appear` defaults to the value of `enter`
	   * - `enter` defaults to `0`
	   * - `exit` defaults to `0`
	   *
	   * @type {number | { enter?: number, exit?: number, appear?: number }}
	   */
	  timeout: function timeout(props) {
	    var pt = timeoutsShape;
	    if (!props.addEndListener) pt = pt.isRequired;

	    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	      args[_key - 1] = arguments[_key];
	    }

	    return pt.apply(void 0, [props].concat(args));
	  },

	  /**
	   * Add a custom transition end trigger. Called with the transitioning
	   * DOM node and a `done` callback. Allows for more fine grained transition end
	   * logic. **Note:** Timeouts are still used as a fallback if provided.
	   *
	   * ```jsx
	   * addEndListener={(node, done) => {
	   *   // use the css transitionend event to mark the finish of a transition
	   *   node.addEventListener('transitionend', done, false);
	   * }}
	   * ```
	   */
	  addEndListener: propTypes.func,

	  /**
	   * Callback fired before the "entering" status is applied. An extra parameter
	   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
	   *
	   * @type Function(node: HtmlElement, isAppearing: bool) -> void
	   */
	  onEnter: propTypes.func,

	  /**
	   * Callback fired after the "entering" status is applied. An extra parameter
	   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
	   *
	   * @type Function(node: HtmlElement, isAppearing: bool)
	   */
	  onEntering: propTypes.func,

	  /**
	   * Callback fired after the "entered" status is applied. An extra parameter
	   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
	   *
	   * @type Function(node: HtmlElement, isAppearing: bool) -> void
	   */
	  onEntered: propTypes.func,

	  /**
	   * Callback fired before the "exiting" status is applied.
	   *
	   * @type Function(node: HtmlElement) -> void
	   */
	  onExit: propTypes.func,

	  /**
	   * Callback fired after the "exiting" status is applied.
	   *
	   * @type Function(node: HtmlElement) -> void
	   */
	  onExiting: propTypes.func,

	  /**
	   * Callback fired after the "exited" status is applied.
	   *
	   * @type Function(node: HtmlElement) -> void
	   */
	  onExited: propTypes.func // Name the function so it is clearer in the documentation

	} ;

	function noop$1() {}

	Transition.defaultProps = {
	  in: false,
	  mountOnEnter: false,
	  unmountOnExit: false,
	  appear: false,
	  enter: true,
	  exit: true,
	  onEnter: noop$1,
	  onEntering: noop$1,
	  onEntered: noop$1,
	  onExit: noop$1,
	  onExiting: noop$1,
	  onExited: noop$1
	};
	Transition.UNMOUNTED = 0;
	Transition.EXITED = 1;
	Transition.ENTERING = 2;
	Transition.ENTERED = 3;
	Transition.EXITING = 4;

	var _addClass = function addClass$1(node, classes) {
	  return node && classes && classes.split(' ').forEach(function (c) {
	    return addClass(node, c);
	  });
	};

	var removeClass$1 = function removeClass$1(node, classes) {
	  return node && classes && classes.split(' ').forEach(function (c) {
	    return removeClass(node, c);
	  });
	};
	/**
	 * A transition component inspired by the excellent
	 * [ng-animate](http://www.nganimate.org/) library, you should use it if you're
	 * using CSS transitions or animations. It's built upon the
	 * [`Transition`](https://reactcommunity.org/react-transition-group/transition)
	 * component, so it inherits all of its props.
	 *
	 * `CSSTransition` applies a pair of class names during the `appear`, `enter`,
	 * and `exit` states of the transition. The first class is applied and then a
	 * second `*-active` class in order to activate the CSS transition. After the
	 * transition, matching `*-done` class names are applied to persist the
	 * transition state.
	 *
	 * ```jsx
	 * function App() {
	 *   const [inProp, setInProp] = useState(false);
	 *   return (
	 *     <div>
	 *       <CSSTransition in={inProp} timeout={200} classNames="my-node">
	 *         <div>
	 *           {"I'll receive my-node-* classes"}
	 *         </div>
	 *       </CSSTransition>
	 *       <button type="button" onClick={() => setInProp(true)}>
	 *         Click to Enter
	 *       </button>
	 *     </div>
	 *   );
	 * }
	 * ```
	 *
	 * When the `in` prop is set to `true`, the child component will first receive
	 * the class `example-enter`, then the `example-enter-active` will be added in
	 * the next tick. `CSSTransition` [forces a
	 * reflow](https://github.com/reactjs/react-transition-group/blob/5007303e729a74be66a21c3e2205e4916821524b/src/CSSTransition.js#L208-L215)
	 * between before adding the `example-enter-active`. This is an important trick
	 * because it allows us to transition between `example-enter` and
	 * `example-enter-active` even though they were added immediately one after
	 * another. Most notably, this is what makes it possible for us to animate
	 * _appearance_.
	 *
	 * ```css
	 * .my-node-enter {
	 *   opacity: 0;
	 * }
	 * .my-node-enter-active {
	 *   opacity: 1;
	 *   transition: opacity 200ms;
	 * }
	 * .my-node-exit {
	 *   opacity: 1;
	 * }
	 * .my-node-exit-active {
	 *   opacity: 0;
	 *   transition: opacity 200ms;
	 * }
	 * ```
	 *
	 * `*-active` classes represent which styles you want to animate **to**.
	 *
	 * **Note**: If you're using the
	 * [`appear`](http://reactcommunity.org/react-transition-group/transition#Transition-prop-appear)
	 * prop, make sure to define styles for `.appear-*` classes as well.
	 */


	var CSSTransition =
	/*#__PURE__*/
	function (_React$Component) {
	  _inheritsLoose(CSSTransition, _React$Component);

	  function CSSTransition() {
	    var _this;

	    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }

	    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
	    _this.appliedClasses = {
	      appear: {},
	      enter: {},
	      exit: {}
	    };

	    _this.onEnter = function (node, appearing) {
	      _this.removeClasses(node, 'exit');

	      _this.addClass(node, appearing ? 'appear' : 'enter', 'base');

	      if (_this.props.onEnter) {
	        _this.props.onEnter(node, appearing);
	      }
	    };

	    _this.onEntering = function (node, appearing) {
	      var type = appearing ? 'appear' : 'enter';

	      _this.addClass(node, type, 'active');

	      if (_this.props.onEntering) {
	        _this.props.onEntering(node, appearing);
	      }
	    };

	    _this.onEntered = function (node, appearing) {
	      var type = appearing ? 'appear' : 'enter';

	      _this.removeClasses(node, type);

	      _this.addClass(node, type, 'done');

	      if (_this.props.onEntered) {
	        _this.props.onEntered(node, appearing);
	      }
	    };

	    _this.onExit = function (node) {
	      _this.removeClasses(node, 'appear');

	      _this.removeClasses(node, 'enter');

	      _this.addClass(node, 'exit', 'base');

	      if (_this.props.onExit) {
	        _this.props.onExit(node);
	      }
	    };

	    _this.onExiting = function (node) {
	      _this.addClass(node, 'exit', 'active');

	      if (_this.props.onExiting) {
	        _this.props.onExiting(node);
	      }
	    };

	    _this.onExited = function (node) {
	      _this.removeClasses(node, 'exit');

	      _this.addClass(node, 'exit', 'done');

	      if (_this.props.onExited) {
	        _this.props.onExited(node);
	      }
	    };

	    _this.getClassNames = function (type) {
	      var classNames = _this.props.classNames;
	      var isStringClassNames = typeof classNames === 'string';
	      var prefix = isStringClassNames && classNames ? classNames + "-" : '';
	      var baseClassName = isStringClassNames ? "" + prefix + type : classNames[type];
	      var activeClassName = isStringClassNames ? baseClassName + "-active" : classNames[type + "Active"];
	      var doneClassName = isStringClassNames ? baseClassName + "-done" : classNames[type + "Done"];
	      return {
	        baseClassName: baseClassName,
	        activeClassName: activeClassName,
	        doneClassName: doneClassName
	      };
	    };

	    return _this;
	  }

	  var _proto = CSSTransition.prototype;

	  _proto.addClass = function addClass(node, type, phase) {
	    var className = this.getClassNames(type)[phase + "ClassName"];

	    if (type === 'appear' && phase === 'done') {
	      className += " " + this.getClassNames('enter').doneClassName;
	    } // This is for to force a repaint,
	    // which is necessary in order to transition styles when adding a class name.


	    if (phase === 'active') {
	      /* eslint-disable no-unused-expressions */
	      node && node.scrollTop;
	    }

	    this.appliedClasses[type][phase] = className;

	    _addClass(node, className);
	  };

	  _proto.removeClasses = function removeClasses(node, type) {
	    var _this$appliedClasses$ = this.appliedClasses[type],
	        baseClassName = _this$appliedClasses$.base,
	        activeClassName = _this$appliedClasses$.active,
	        doneClassName = _this$appliedClasses$.done;
	    this.appliedClasses[type] = {};

	    if (baseClassName) {
	      removeClass$1(node, baseClassName);
	    }

	    if (activeClassName) {
	      removeClass$1(node, activeClassName);
	    }

	    if (doneClassName) {
	      removeClass$1(node, doneClassName);
	    }
	  };

	  _proto.render = function render() {
	    var _this$props = this.props,
	        _ = _this$props.classNames,
	        props = _objectWithoutPropertiesLoose(_this$props, ["classNames"]);

	    return React__default.createElement(Transition, _extends({}, props, {
	      onEnter: this.onEnter,
	      onEntered: this.onEntered,
	      onEntering: this.onEntering,
	      onExit: this.onExit,
	      onExiting: this.onExiting,
	      onExited: this.onExited
	    }));
	  };

	  return CSSTransition;
	}(React__default.Component);

	CSSTransition.defaultProps = {
	  classNames: ''
	};
	CSSTransition.propTypes =  _extends({}, Transition.propTypes, {
	  /**
	   * The animation classNames applied to the component as it appears, enters,
	   * exits or has finished the transition. A single name can be provided and it
	   * will be suffixed for each stage: e.g.
	   *
	   * `classNames="fade"` applies `fade-appear`, `fade-appear-active`,
	   * `fade-appear-done`, `fade-enter`, `fade-enter-active`, `fade-enter-done`,
	   * `fade-exit`, `fade-exit-active`, and `fade-exit-done`.
	   *
	   * **Note**: `fade-appear-done` and `fade-enter-done` will _both_ be applied.
	   * This allows you to define different behavior for when appearing is done and
	   * when regular entering is done, using selectors like
	   * `.fade-enter-done:not(.fade-appear-done)`. For example, you could apply an
	   * epic entrance animation when element first appears in the DOM using
	   * [Animate.css](https://daneden.github.io/animate.css/). Otherwise you can
	   * simply use `fade-enter-done` for defining both cases.
	   *
	   * Each individual classNames can also be specified independently like:
	   *
	   * ```js
	   * classNames={{
	   *  appear: 'my-appear',
	   *  appearActive: 'my-active-appear',
	   *  appearDone: 'my-done-appear',
	   *  enter: 'my-enter',
	   *  enterActive: 'my-active-enter',
	   *  enterDone: 'my-done-enter',
	   *  exit: 'my-exit',
	   *  exitActive: 'my-active-exit',
	   *  exitDone: 'my-done-exit',
	   * }}
	   * ```
	   *
	   * If you want to set these classes using CSS Modules:
	   *
	   * ```js
	   * import styles from './styles.css';
	   * ```
	   *
	   * you might want to use camelCase in your CSS file, that way could simply
	   * spread them instead of listing them one by one:
	   *
	   * ```js
	   * classNames={{ ...styles }}
	   * ```
	   *
	   * @type {string | {
	   *  appear?: string,
	   *  appearActive?: string,
	   *  appearDone?: string,
	   *  enter?: string,
	   *  enterActive?: string,
	   *  enterDone?: string,
	   *  exit?: string,
	   *  exitActive?: string,
	   *  exitDone?: string,
	   * }}
	   */
	  classNames: classNamesShape,

	  /**
	   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is
	   * applied.
	   *
	   * @type Function(node: HtmlElement, isAppearing: bool)
	   */
	  onEnter: propTypes.func,

	  /**
	   * A `<Transition>` callback fired immediately after the 'enter-active' or
	   * 'appear-active' class is applied.
	   *
	   * @type Function(node: HtmlElement, isAppearing: bool)
	   */
	  onEntering: propTypes.func,

	  /**
	   * A `<Transition>` callback fired immediately after the 'enter' or
	   * 'appear' classes are **removed** and the `done` class is added to the DOM node.
	   *
	   * @type Function(node: HtmlElement, isAppearing: bool)
	   */
	  onEntered: propTypes.func,

	  /**
	   * A `<Transition>` callback fired immediately after the 'exit' class is
	   * applied.
	   *
	   * @type Function(node: HtmlElement)
	   */
	  onExit: propTypes.func,

	  /**
	   * A `<Transition>` callback fired immediately after the 'exit-active' is applied.
	   *
	   * @type Function(node: HtmlElement)
	   */
	  onExiting: propTypes.func,

	  /**
	   * A `<Transition>` callback fired immediately after the 'exit' classes
	   * are **removed** and the `exit-done` class is added to the DOM node.
	   *
	   * @type Function(node: HtmlElement)
	   */
	  onExited: propTypes.func
	}) ;

	var __assign$e = (undefined && undefined.__assign) || function () {
	    __assign$e = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e.apply(this, arguments);
	};
	var __rest$9 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$5 = bem("rmd-toast");
	var DEFAULT_TOAST_CLASSNAMES = {
	    appear: "rmd-toast--enter",
	    appearActive: "rmd-toast--enter-active",
	    enter: "rmd-toast--enter",
	    enterActive: "rmd-toast--enter-active",
	    enterDone: "",
	    exit: "rmd-toast--exit",
	    exitActive: "rmd-toast--exit-active",
	    exitDone: "",
	};
	/**
	 * This is a very low-level component that can be used to animate a new toast in
	 * to a `Snackbar` as it is mainly just a wrapper of the `CSSTransition`
	 * component. If you are using this component, it is generally recommended to
	 * provide the `onEntered` callback as a function to start the hide visibility
	 * timer and the `onExited` callback to remove the current toast from your
	 * queue.
	 */
	var Toast = React.forwardRef(function Toast(_a, ref) {
	    var className = _a.className, children = _a.children, onEnter = _a.onEnter, onEntering = _a.onEntering, onEntered = _a.onEntered, onExit = _a.onExit, onExiting = _a.onExiting, onExited = _a.onExited, _b = _a.timeout, timeout = _b === void 0 ? 150 : _b, _c = _a.classNames, classNames = _c === void 0 ? DEFAULT_TOAST_CLASSNAMES : _c, _d = _a.action, action = _d === void 0 ? null : _d, _e = _a.stacked, stacked = _e === void 0 ? false : _e, _f = _a.twoLines, twoLines = _f === void 0 ? false : _f, visible = _a.visible, props = __rest$9(_a, ["className", "children", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "timeout", "classNames", "action", "stacked", "twoLines", "visible"]);
	    return (React__default.createElement(CSSTransition, { in: visible, appear: true, onEnter: onEnter, onEntering: onEntering, onEntered: onEntered, onExit: onExit, onExiting: onExiting, onExited: onExited, timeout: timeout, classNames: classNames, mountOnEnter: true, unmountOnExit: true },
	        React__default.createElement("div", __assign$e({}, props, { ref: ref, className: classnames(block$5({
	                stacked: stacked,
	                padded: !action || twoLines,
	                "two-lines": twoLines,
	                action: action,
	                "action-2": action && twoLines,
	            }), className) }),
	            React__default.createElement("span", { className: block$5("message", { action: action }) }, children),
	            action && (React__default.createElement("span", { className: block$5("action", { stacked: stacked }) }, action)))));
	});
	{
	    try {
	        var PropTypes$c = require("prop-types");
	        Toast.propTypes = {
	            visible: PropTypes$c.bool.isRequired,
	            action: PropTypes$c.element,
	            stacked: PropTypes$c.bool,
	            twoLines: PropTypes$c.bool,
	            className: PropTypes$c.string,
	            classNames: PropTypes$c.oneOfType([
	                PropTypes$c.string,
	                PropTypes$c.shape({
	                    appear: PropTypes$c.string,
	                    appearActive: PropTypes$c.string,
	                    enter: PropTypes$c.string,
	                    enterActive: PropTypes$c.string,
	                    enterDone: PropTypes$c.string,
	                    exit: PropTypes$c.string,
	                    exitActive: PropTypes$c.string,
	                    exitDone: PropTypes$c.string,
	                }),
	            ]),
	            timeout: PropTypes$c.oneOfType([
	                PropTypes$c.number,
	                PropTypes$c.shape({
	                    enter: PropTypes$c.number,
	                    exit: PropTypes$c.number,
	                }),
	            ]),
	            children: PropTypes$c.node,
	            onEnter: PropTypes$c.func,
	            onEntering: PropTypes$c.func,
	            onEntered: PropTypes$c.func,
	            onExit: PropTypes$c.func,
	            onExiting: PropTypes$c.func,
	            onExited: PropTypes$c.func,
	        };
	    }
	    catch (e) { }
	}

	var DEFAULT_MESSAGE_QUEUE_TIMEOUT = 5000;
	/**
	 * @private
	 */
	var AddMessageContext = React.createContext(function () {
	    throw new Error("Attempted to create a message without initializing the MessageQueue component.");
	});
	/**
	 * @private
	 */
	var MessageVisibilityContext = React.createContext(false);
	/**
	 * This hook is used to add a message to the queue from anywhere in your app.
	 * This should normally be used from click event handlers, but can also be
	 * triggered with custom logic within components.
	 */
	function useAddMessage() {
	    return React.useContext(AddMessageContext);
	}
	/**
	 * Gets the current message visibility to provide to the toast.
	 *
	 * @private
	 */
	function useMessageVisibility() {
	    return React.useContext(MessageVisibilityContext);
	}
	/**
	 * @private
	 */
	var MessageQueueActionsContext = React.createContext({
	    popMessage: function () {
	        throw new Error("Attempted to pop a message without initializing the MessageQueue component.");
	    },
	    hideMessage: function () {
	        throw new Error("Attempted to hide a message within initializing the MessageQueue component.");
	    },
	    startTimer: function () {
	        throw new Error("Attempted to start a message queue timer without initializing the MessageQueue component.");
	    },
	    stopTimer: function () {
	        throw new Error("Attempted to stop a message queue timer without initializing the MessageQueue component.");
	    },
	    restartTimer: function () {
	        throw new Error("Attempted to restart a message queue timer without initializing the MessageQueue component.");
	    },
	    resetQueue: function () {
	        throw new Error("Attempted to reset the message queue timer without initializing the MessageQueue component.");
	    },
	});
	/**
	 * This hook exposes some of the lower level actions for handling a message
	 * queue if advanced behavior is desired.
	 */
	function useMessageQueueActions() {
	    // I don't know how to type the createContext for a generic
	    return React.useContext(MessageQueueActionsContext);
	}
	/**
	 * @private
	 */
	var MessageQueueContext = React.createContext([]);
	/**
	 * This hook will allow you to get the current queue. This probably shouldn't be
	 * used that much.
	 */
	function useQueue() {
	    return React.useContext(MessageQueueContext);
	}

	var block$6 = bem("rmd-button");
	/**
	 * Creates a button theme based on the button theming props. This is really just
	 * used so that other elements like clickable `<div>`s or `<input type="file">`
	 * can look like buttons.
	 *
	 * @param props An object containing the themeable button props to generate a
	 * button theme className.
	 * @return a string of class names to create an element with a button theme.
	 */
	function buttonThemeClassNames(props) {
	    var _a;
	    var _b = props.theme, theme = _b === void 0 ? "clear" : _b, _c = props.themeType, themeType = _c === void 0 ? "flat" : _c, _d = props.buttonType, buttonType = _d === void 0 ? "text" : _d, disabled = props.disabled, className = props.className;
	    var text = buttonType === "text";
	    var icon = buttonType === "icon";
	    var outline = themeType === "outline";
	    var contained = themeType === "contained";
	    var clear = theme === "clear";
	    return classnames(block$6((_a = {
	            text: text,
	            icon: icon,
	            disabled: disabled,
	            contained: !disabled && contained,
	            outline: outline
	        },
	        _a[theme] = !disabled && !clear && contained,
	        _a["text-" + theme] = !disabled && !clear && !contained,
	        _a["outline-" + theme] = !disabled && !clear && outline,
	        _a)), className);
	}

	/**
	 * Checks if the ripple event should be ignored since it was bubbled
	 * up from a child treeitem. I should find a better way to handle
	 * this at some point.
	 */
	function isBubbled(event) {
	    return Array.from(event.currentTarget.querySelectorAll('[role="treeitem"]')).some(function (item) { return item.contains(event.target); });
	}
	/**
	 * Gets the ripple event type based on the provided event.
	 */
	function getType(event) {
	    switch (event.type) {
	        case "mousedown":
	        case "mouseup":
	        case "mouseleave":
	            return "mouse";
	        case "touchstart":
	        case "touchmove":
	        case "touchend":
	            return "touch";
	        case "keydown":
	        case "keyup":
	            return "keyboard";
	        default:
	            return "programmatic";
	    }
	}
	/**
	 * Checks if the provided event type is actually rippleable by ensuring:
	 * - it is a mousedown event while not in touch mode and the left mouse was
	 *   clicked.
	 * - it was a keydown event for either tab or space when spacebar clicks have not
	 *   been disabled
	 * - it was a touchstart event
	 */
	function isRippleable(event, disableSpacebarClick) {
	    switch (event.type) {
	        case "mousedown":
	            return (document.querySelector(".rmd-states--touch") === null &&
	                event.button === 0);
	        case "keydown":
	            return ((!disableSpacebarClick && event.key === " ") ||
	                (event.key === "Enter" &&
	                    !/checkbox|radio/i.test(event.currentTarget.getAttribute("type") || "")));
	        case "touchstart":
	        case "click":
	            return true;
	        default:
	            return false;
	    }
	}
	function calcHypotenuse(a, b) {
	    return Math.sqrt(a * a + b * b);
	}
	/**
	 * Gets the current radius for a ripple based on the x and y page dimensions
	 * as well as the size of the element.
	 *
	 * This is really just in a separate file so I can easily mock this and write
	 * tests.
	 */
	function getRadius(x, y, offsetWidth, offsetHeight) {
	    return Math.max(calcHypotenuse(x, y), calcHypotenuse(offsetWidth - x, y), calcHypotenuse(offsetWidth - x, offsetHeight - y), calcHypotenuse(x, offsetHeight - y));
	}
	/**
	 * Gets the ripple creation origin base on the provided event. When the event
	 * type is for keyboards or triggered programmatically, the origin will
	 * be the center of the target element. When the event is for touch or mouse,
	 * the origin will be the location within the viewport where the user touched
	 * or clicked the target element.
	 */
	function getOrigin(event, element) {
	    var _a;
	    var type = getType(event);
	    var offsetWidth = element.offsetWidth, offsetHeight = element.offsetHeight;
	    var x;
	    var y;
	    if (type === "programmatic" || type === "keyboard") {
	        x = offsetWidth / 2;
	        y = offsetHeight / 2;
	    }
	    else {
	        // if the event type is not programmatic, want to figure out exactly where in
	        // the element to trigger the animation from. this can be determined by:
	        // - getting the pageX and pageY of the mouse or touch event
	        // - getting element's current position in the page
	        var pageX = void 0;
	        var pageY = void 0;
	        if (type === "mouse") {
	            (_a = event, pageX = _a.pageX, pageY = _a.pageY);
	        }
	        else {
	            var touch = event.touches.item(0);
	            (pageX = touch.pageX, pageY = touch.pageY);
	        }
	        var rect = element.getBoundingClientRect();
	        // have to include the current page's scroll offset to the element's
	        // bounding rect since the pageX and pageY from Events include the scroll
	        // offset while the bounding rect is only based on viewport.
	        x = pageX - (rect.left + window.pageXOffset);
	        y = pageY - (rect.top + window.pageYOffset);
	    }
	    return { x: x, y: y };
	}
	/**
	 * Creates a new ripple state based off the provided event type.
	 */
	function createRippleState(event) {
	    var element = findSizingContainer(event.currentTarget) || event.currentTarget;
	    var offsetWidth = element.offsetWidth, offsetHeight = element.offsetHeight;
	    var type = getType(event);
	    var _a = getOrigin(event, element), x = _a.x, y = _a.y;
	    var radius = getRadius(x, y, offsetWidth, offsetHeight);
	    var size = radius * 2;
	    return {
	        startTime: Date.now(),
	        style: {
	            left: x - radius,
	            top: y - radius,
	            height: size,
	            width: size,
	        },
	        type: type,
	        holding: type !== "programmatic",
	        exiting: false,
	        entered: false,
	    };
	}

	var __assign$f = (undefined && undefined.__assign) || function () {
	    __assign$f = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f.apply(this, arguments);
	};
	var __spreadArrays$1 = (undefined && undefined.__spreadArrays) || function () {
	    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	    for (var r = Array(s), k = 0, i = 0; i < il; i++)
	        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
	            r[k] = a[j];
	    return r;
	};
	var CREATE = "CREATE";
	var CANCEL = "CANCEL";
	var RELEASE = "RELEASE";
	var ENTERED$1 = "ENTERED";
	var REMOVE = "REMOVE";
	/**
	 * This function will create a simplified version of the create event
	 * that only includes the parts that are needed to trigger a ripple.
	 * This is really only required since `event.persist()` crashed a lot
	 * when spamming the trigger events and it threw warnings when not
	 * persisting the event.
	 */
	function createRippleAction(event, disableSpacebarClick) {
	    var _a = event, type = _a.type, target = _a.target, currentTarget = _a.currentTarget, touches = _a.touches, pageX = _a.pageX, pageY = _a.pageY, button = _a.button, key = _a.key;
	    return {
	        type: CREATE,
	        disableSpacebarClick: disableSpacebarClick,
	        event: {
	            type: type,
	            key: key,
	            target: target,
	            button: button,
	            currentTarget: currentTarget,
	            touches: touches,
	            pageX: pageX,
	            pageY: pageY,
	        },
	    };
	}
	function createRipple(state, event, disableSpacebarClick) {
	    if (!isRippleable(event, disableSpacebarClick) || isBubbled(event)) {
	        return state;
	    }
	    if (state.find(function (r) { return r.holding; }) ||
	        (getType(event) !== "touch" && state.find(function (r) { return r.type === "touch"; }))) {
	        // keyboard events are a bit different than the others since it is actually
	        // spammable since the space or enter key can be held down which triggers click
	        // events infinitely until they release. There's also the fun fact that mouse
	        // events are triggered after touch events, so we need to make sure duplicate
	        // ripples aren't created for these
	        return state;
	    }
	    var ripple = createRippleState(event);
	    return __spreadArrays$1(state, [ripple]);
	}
	function enteredRipple(state, ripple) {
	    var i = state.findIndex(function (r) { return r === ripple; });
	    if (i === -1 || ripple.exiting) {
	        return state;
	    }
	    var nextState = state.slice();
	    var exiting = !ripple.holding || Date.now() - ripple.startTime > 300;
	    nextState[i] = __assign$f(__assign$f({}, ripple), { exiting: exiting, entered: true });
	    return nextState;
	}
	function releaseRipple(state) {
	    var i = state.findIndex(function (r) { return r.holding && !r.exiting; });
	    if (i === -1) {
	        return state;
	    }
	    var ripple = state[i];
	    var exiting = ripple.entered || Date.now() - ripple.startTime > 300;
	    var nextState = state.slice();
	    nextState[i] = __assign$f(__assign$f({}, ripple), { exiting: exiting, holding: false });
	    return nextState;
	}
	function removeRipple(state, ripple) {
	    var i = state.findIndex(function (r) { return r.startTime === ripple.startTime; });
	    if (i === -1) {
	        return state;
	    }
	    var nextState = state.slice();
	    nextState.splice(i, 1);
	    return nextState;
	}
	function cancelRipples(state, ease) {
	    if (ease) {
	        return state.map(function (r) { return (__assign$f(__assign$f({}, r), { exiting: true, mounted: true, holding: false })); });
	    }
	    return [];
	}
	function reducer(state, action) {
	    if (state === void 0) { state = []; }
	    switch (action.type) {
	        case CREATE:
	            return createRipple(state, action.event, action.disableSpacebarClick);
	        case RELEASE:
	            return releaseRipple(state);
	        case CANCEL:
	            return cancelRipples(state, action.ease);
	        case ENTERED$1:
	            return enteredRipple(state, action.ripple);
	        case REMOVE:
	            return removeRipple(state, action.ripple);
	        default:
	            return state;
	    }
	}
	/**
	 * This hook creates memoized callbacks for each part of the ripple transition
	 * as well as returning the current list of ripples.
	 */
	function useRippleTransition(disableSpacebarClick) {
	    if (disableSpacebarClick === void 0) { disableSpacebarClick = false; }
	    var _a = React.useReducer(reducer, []), state = _a[0], dispatch = _a[1];
	    var spacebarRef = useRefCache(disableSpacebarClick);
	    var create = React.useCallback(function (event) {
	        var disableSpacebarClick = spacebarRef.current;
	        dispatch(createRippleAction(event, disableSpacebarClick));
	        // disabled since useRefCache
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    var release = React.useCallback(function (event) {
	        dispatch({ type: RELEASE, event: event });
	    }, []);
	    var entered = React.useCallback(function (ripple) {
	        dispatch({ type: ENTERED$1, ripple: ripple });
	    }, []);
	    var cancel = React.useCallback(function (ease) {
	        if (ease === void 0) { ease = false; }
	        dispatch({ type: CANCEL, ease: ease });
	    }, []);
	    var remove = React.useCallback(function (ripple) {
	        dispatch({ type: REMOVE, ripple: ripple });
	    }, []);
	    return { state: state, create: create, release: release, entered: entered, remove: remove, cancel: cancel };
	}

	var DEFAULT_RIPPLE_CLASSNAMES = {
	    enter: "rmd-ripple--animating",
	    enterActive: "rmd-ripple--scaling",
	    enterDone: "rmd-ripple--animating rmd-ripple--scaling",
	    exit: "rmd-ripple--animating rmd-ripple--scaling",
	    exitActive: "rmd-ripple--fading",
	};
	var DEFAULT_RIPPLE_TIMEOUT = {
	    enter: 150,
	    exit: 300,
	};

	var StatesConfigContext = React.createContext({
	    rippleTimeout: DEFAULT_RIPPLE_TIMEOUT,
	    rippleClassNames: DEFAULT_RIPPLE_CLASSNAMES,
	    disableRipple: false,
	    disableProgrammaticRipple: false,
	});
	/**
	 * A simple hook that can be used to get the Ripple context. This is used behind
	 * the scenes for the Ripple component and _probably_ shouldn't be used anywhere
	 * else. It's mostly used to just use the context defaults when the timeout or
	 * classNames are undefined.
	 */
	function useStatesConfigContext() {
	    return React.useContext(StatesConfigContext);
	}
	/**
	 * The `StatesConfig` component is a top-level context provider for the states
	 * context configuration. It'll keep track of:
	 *
	 * - the current interaction mode of your user
	 * - configuration for ripple effects
	 * - disabling or enabling the ripple effects
	 * - disabling or enabling the fix for color pollution
	 */
	function StatesConfig(_a) {
	    var _b = _a.rippleTimeout, rippleTimeout = _b === void 0 ? DEFAULT_RIPPLE_TIMEOUT : _b, _c = _a.rippleClassNames, rippleClassNames = _c === void 0 ? DEFAULT_RIPPLE_CLASSNAMES : _c, _d = _a.disableRipple, disableRipple = _d === void 0 ? false : _d, _e = _a.disableProgrammaticRipple, disableProgrammaticRipple = _e === void 0 ? false : _e, children = _a.children;
	    var value = React.useMemo(function () { return ({
	        rippleTimeout: rippleTimeout,
	        rippleClassNames: rippleClassNames,
	        disableRipple: disableRipple,
	        disableProgrammaticRipple: disableProgrammaticRipple,
	    }); }, [rippleTimeout, rippleClassNames, disableRipple, disableProgrammaticRipple]);
	    return (React__default.createElement(StatesConfigContext.Provider, { value: value }, children));
	}
	{
	    try {
	        var PropTypes$d = require("prop-types");
	        StatesConfig.propTypes = {
	            rippleTimeout: PropTypes$d.oneOfType([
	                PropTypes$d.number,
	                PropTypes$d.shape({
	                    enter: PropTypes$d.number,
	                    exit: PropTypes$d.number,
	                }),
	            ]),
	            rippleClassNames: PropTypes$d.oneOfType([
	                PropTypes$d.string,
	                PropTypes$d.shape({
	                    enter: PropTypes$d.string,
	                    enterActive: PropTypes$d.string,
	                    enterDone: PropTypes$d.string,
	                    exit: PropTypes$d.string,
	                    exitActive: PropTypes$d.string,
	                }),
	            ]),
	            disableRipple: PropTypes$d.bool,
	            disableProgrammaticRipple: PropTypes$d.bool,
	            children: PropTypes$d.node.isRequired,
	        };
	    }
	    catch (e) { }
	}

	/* eslint-disable react/prop-types */
	var Ripple = function (props) {
	    var className = props.className, propClassNames = props.classNames, propTimeout = props.timeout, ripple = props.ripple, entered = props.entered, exited = props.exited;
	    var exiting = ripple.exiting, style = ripple.style;
	    var timeout = propTimeout;
	    var classNames = propClassNames;
	    var context = useStatesConfigContext();
	    if (typeof timeout === "undefined" || typeof classNames === "undefined") {
	        if (typeof timeout === "undefined") {
	            timeout = context.rippleTimeout;
	        }
	        if (typeof classNames === "undefined") {
	            classNames = context.rippleClassNames;
	        }
	    }
	    var ref = useRefCache({ ripple: ripple, entered: entered, exited: exited });
	    var onEntered = React.useCallback(function () {
	        var _a = ref.current, ripple = _a.ripple, entered = _a.entered;
	        entered(ripple);
	        // disabled since useRefCache
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    var onExited = React.useCallback(function () {
	        var _a = ref.current, ripple = _a.ripple, exited = _a.exited;
	        exited(ripple);
	        // disabled since useRefCache
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    return (React__default.createElement(CSSTransition, { in: !exiting, appear: true, classNames: classNames, timeout: timeout, onEntered: onEntered, onExited: onExited },
	        React__default.createElement("span", { style: style, className: classnames("rmd-ripple", className) })));
	};

	/* eslint-disable react/prop-types */
	var RippleContainer = function (_a) {
	    var ripples = _a.ripples, className = _a.className, rippleClassName = _a.rippleClassName, timeout = _a.timeout, classNames = _a.classNames, entered = _a.entered, exited = _a.exited;
	    return (React__default.createElement("span", { className: classnames("rmd-ripple-container", className) }, ripples.map(function (ripple) { return (React__default.createElement(Ripple, { key: ripple.startTime, ripple: ripple, className: rippleClassName, entered: entered, exited: exited, timeout: timeout, classNames: classNames })); })));
	};

	var __assign$g = (undefined && undefined.__assign) || function () {
	    __assign$g = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$g.apply(this, arguments);
	};
	/**
	 * This hook is used to create all the event handlers required for
	 * creating ripples on an element. Each handler will be memoized and
	 * merged with any provided event handlers of the same type. If the
	 * ripple effect is disabled, the provided event handlers will be
	 * returned instead.
	 */
	function useRippleHandlers(_a) {
	    var create = _a.create, release = _a.release, cancel = _a.cancel, _b = _a.handlers, handlers = _b === void 0 ? {} : _b, _c = _a.disabled, propDisabled = _c === void 0 ? false : _c, _d = _a.disableRipple, disableRipple = _d === void 0 ? false : _d, _e = _a.disableProgrammaticRipple, disableProgrammaticRipple = _e === void 0 ? false : _e;
	    var disabled = propDisabled || disableRipple;
	    var ref = useRefCache(__assign$g(__assign$g({}, handlers), { disableProgrammaticRipple: disableProgrammaticRipple }));
	    // some OS/browser don't actually focus buttons/elements that are focusable after a click
	    // event which causes a double ripple effect. This ref is used to disable the programmatic
	    // ripple in these cases.
	    var disableProgrammatic = React.useRef(false);
	    var onKeyDown = React.useCallback(function (event) {
	        var callback = ref.current.onKeyDown;
	        if (callback) {
	            callback(event);
	        }
	        create(event);
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [create]);
	    var onKeyUp = React.useCallback(function (event) {
	        var callback = ref.current.onKeyUp;
	        if (callback) {
	            callback(event);
	        }
	        release(event);
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [release]);
	    var onMouseDown = React.useCallback(function (event) {
	        var callback = ref.current.onMouseDown;
	        if (callback) {
	            callback(event);
	        }
	        create(event);
	        disableProgrammatic.current = true;
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [create]);
	    var onMouseUp = React.useCallback(function (event) {
	        var callback = ref.current.onMouseUp;
	        if (callback) {
	            callback(event);
	        }
	        release(event);
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [release]);
	    var onMouseLeave = React.useCallback(function (event) {
	        var callback = ref.current.onMouseLeave;
	        if (callback) {
	            callback(event);
	        }
	        cancel(true);
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [cancel]);
	    var onTouchStart = React.useCallback(function (event) {
	        var callback = ref.current.onTouchStart;
	        if (callback) {
	            callback(event);
	        }
	        create(event);
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [create]);
	    var onTouchMove = React.useCallback(function (event) {
	        var callback = ref.current.onTouchMove;
	        if (callback) {
	            callback(event);
	        }
	        cancel(false);
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [cancel]);
	    var onTouchEnd = React.useCallback(function (event) {
	        var callback = ref.current.onTouchEnd;
	        if (callback) {
	            callback(event);
	        }
	        release(event);
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [release]);
	    var onClick = React.useCallback(function (event) {
	        var _a = ref.current, callback = _a.onClick, disableProgrammaticRipple = _a.disableProgrammaticRipple;
	        if (callback) {
	            callback(event);
	        }
	        // when a click event is triggered and the current active element is not
	        // the event target, we know it was a true programmatic event and should
	        // trigger a ripple for it.
	        if (disableProgrammaticRipple ||
	            document.activeElement === event.currentTarget ||
	            disableProgrammatic.current) {
	            disableProgrammatic.current = false;
	            return;
	        }
	        create(event);
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [create]);
	    return {
	        onKeyDown: disabled ? handlers.onKeyDown : onKeyDown,
	        onKeyUp: disabled ? handlers.onKeyUp : onKeyUp,
	        onMouseDown: disabled ? handlers.onMouseDown : onMouseDown,
	        onMouseUp: disabled ? handlers.onMouseUp : onMouseUp,
	        onMouseLeave: disabled ? handlers.onMouseLeave : onMouseLeave,
	        onTouchStart: disabled ? handlers.onTouchStart : onTouchStart,
	        onTouchMove: disabled ? handlers.onTouchMove : onTouchMove,
	        onTouchEnd: disabled ? handlers.onTouchEnd : onTouchEnd,
	        onClick: disabled || disableProgrammaticRipple ? handlers.onClick : onClick,
	    };
	}

	var __assign$h = (undefined && undefined.__assign) || function () {
	    __assign$h = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$h.apply(this, arguments);
	};
	var __rest$a = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * A hook that will return an object containing the ripples element
	 * and an object of event handlers to apply to an element to trigger
	 * the ripple effects.
	 */
	function useRipples(_a) {
	    var rippleTimeout = _a.rippleTimeout, rippleClassNames = _a.rippleClassNames, rippleContainerClassName = _a.rippleContainerClassName, rippleClassName = _a.rippleClassName, disableRipple = _a.disableRipple, disableSpacebarClick = _a.disableSpacebarClick, options = __rest$a(_a, ["rippleTimeout", "rippleClassNames", "rippleContainerClassName", "rippleClassName", "disableRipple", "disableSpacebarClick"]);
	    var _b = useRippleTransition(disableSpacebarClick), create = _b.create, state = _b.state, release = _b.release, entered = _b.entered, remove = _b.remove, cancel = _b.cancel;
	    var handlers = useRippleHandlers(__assign$h({ create: create,
	        release: release,
	        cancel: cancel,
	        disableRipple: disableRipple }, options));
	    return {
	        handlers: handlers,
	        ripples: disableRipple ? null : (React__default.createElement(RippleContainer, { key: "ripples", ripples: state, className: rippleContainerClassName, rippleClassName: rippleClassName, timeout: rippleTimeout, classNames: rippleClassNames, entered: entered, exited: remove })),
	    };
	}

	/**
	 * This small utility function will create an onKeyDown handler that allows the
	 * user to "click" an element with the keyboard via Enter or Space.
	 */
	function useKeyboardClickPolyfill(_a) {
	    var _b = _a === void 0 ? {} : _a, onKeyDown = _b.onKeyDown, _c = _b.disabled, disabled = _c === void 0 ? false : _c, _d = _b.disableEnterClick, disableEnterClick = _d === void 0 ? false : _d, _e = _b.disableSpacebarClick, disableSpacebarClick = _e === void 0 ? false : _e;
	    var ref = useRefCache({
	        onKeyDown: onKeyDown,
	        disableSpacebarClick: disableSpacebarClick,
	        disableEnterClick: disableEnterClick,
	    });
	    var handleKeyDown = React.useCallback(function (event) {
	        var _a = ref.current, onKeyDown = _a.onKeyDown, disableSpacebarClick = _a.disableSpacebarClick, disableEnterClick = _a.disableEnterClick;
	        if (onKeyDown) {
	            onKeyDown(event);
	        }
	        var isSpace = event.key === " ";
	        var isEnter = event.key === "Enter";
	        var currentTarget = event.currentTarget;
	        var tagName = currentTarget.tagName;
	        if ((!isSpace && !isEnter) ||
	            (isSpace && disableSpacebarClick) ||
	            (isEnter && disableEnterClick) ||
	            // buttons and textareas, and inputs shouldn't be polyfilled
	            /BUTTON|TEXTAREA|INPUT/.test(tagName) ||
	            // native links don't click on space
	            (isSpace && tagName === "A")) {
	            return;
	        }
	        if (isSpace) {
	            // prevent default behavior of page scrolling
	            event.preventDefault();
	        }
	        // don't want parent keydown events to be triggered since this should now
	        // be a "click" event instead.
	        event.stopPropagation();
	        event.currentTarget.click();
	        // disabled since useRefCache
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    return disabled ? onKeyDown : handleKeyDown;
	}

	var __assign$i = (undefined && undefined.__assign) || function () {
	    __assign$i = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$i.apply(this, arguments);
	};
	/**
	 * This is a different version of the useRippleStates that will allow you to
	 * know when a component is being pressed by the user. This is really just a
	 * fallback for when the ripples are disabled.
	 *
	 * This will return an object containing the current pressed state of the
	 * element as well as all the merged eventHandlers required to trigger the
	 * different states.
	 *
	 * NOTE: Unlike the ripple effect, this pressed states will not be triggered
	 * from a programmatic click event.
	 */
	function usePressedStates(_a) {
	    var _b = _a === void 0 ? {} : _a, _c = _b.handlers, handlers = _c === void 0 ? {} : _c, _d = _b.disableSpacebarClick, disableSpacebarClick = _d === void 0 ? false : _d;
	    var _e = React.useState(false), pressed = _e[0], setPressed = _e[1];
	    var ref = useRefCache(__assign$i(__assign$i({}, handlers), { pressed: pressed }));
	    var handleKeyDown = React.useCallback(function (event) {
	        var _a = ref.current, onKeyDown = _a.onKeyDown, pressed = _a.pressed;
	        if (onKeyDown) {
	            onKeyDown(event);
	        }
	        var key = event.key;
	        if (!pressed &&
	            (key === "Enter" || (!disableSpacebarClick && key === " "))) {
	            setPressed(true);
	        }
	    }, 
	    // disabled since useRefCache for ref
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [disableSpacebarClick]);
	    var handleKeyUp = React.useCallback(function (event) {
	        var _a = ref.current, onKeyUp = _a.onKeyUp, pressed = _a.pressed;
	        if (onKeyUp) {
	            onKeyUp(event);
	        }
	        if (pressed) {
	            setPressed(false);
	        }
	        // disabled since useRefCache for ref
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    var handleMouseDown = React.useCallback(function (event) {
	        var _a = ref.current, onMouseDown = _a.onMouseDown, pressed = _a.pressed;
	        if (onMouseDown) {
	            onMouseDown(event);
	        }
	        if (!pressed && event.button === 0 && !isBubbled(event)) {
	            setPressed(true);
	        }
	        // disabled since useRefCache for ref
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    var handleMouseUp = React.useCallback(function (event) {
	        var _a = ref.current, onMouseUp = _a.onMouseUp, pressed = _a.pressed;
	        if (onMouseUp) {
	            onMouseUp(event);
	        }
	        if (pressed) {
	            setPressed(false);
	        }
	        // disabled since useRefCache for ref
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    var handleMouseLeave = React.useCallback(function (event) {
	        var _a = ref.current, onMouseLeave = _a.onMouseLeave, pressed = _a.pressed;
	        if (onMouseLeave) {
	            onMouseLeave(event);
	        }
	        if (pressed) {
	            setPressed(false);
	        }
	        // disabled since useRefCache for ref
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    var handleTouchStart = React.useCallback(function (event) {
	        var _a = ref.current, onTouchStart = _a.onTouchStart, pressed = _a.pressed;
	        if (onTouchStart) {
	            onTouchStart(event);
	        }
	        if (!pressed && !isBubbled(event)) {
	            setPressed(true);
	        }
	        // disabled since useRefCache for ref
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    var handleTouchMove = React.useCallback(function (event) {
	        var _a = ref.current, onTouchMove = _a.onTouchMove, pressed = _a.pressed;
	        if (onTouchMove) {
	            onTouchMove(event);
	        }
	        if (pressed) {
	            setPressed(false);
	        }
	        // disabled since useRefCache for ref
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    var handleTouchEnd = React.useCallback(function (event) {
	        var _a = ref.current, onTouchEnd = _a.onTouchEnd, pressed = _a.pressed;
	        if (onTouchEnd) {
	            onTouchEnd(event);
	        }
	        if (pressed) {
	            setPressed(false);
	        }
	        // disabled since useRefCache for ref
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	    return {
	        pressed: pressed,
	        handlers: {
	            onKeyDown: handleKeyDown,
	            onKeyUp: handleKeyUp,
	            onMouseDown: handleMouseDown,
	            onMouseUp: handleMouseUp,
	            onMouseLeave: handleMouseLeave,
	            onTouchStart: handleTouchStart,
	            onTouchMove: handleTouchMove,
	            onTouchEnd: handleTouchEnd,
	        },
	    };
	}

	var __assign$j = (undefined && undefined.__assign) || function () {
	    __assign$j = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$j.apply(this, arguments);
	};
	/**
	 * This is probably one of the most useful hook in react-md. Any functional
	 * component component that uses this will gain all the different interaction
	 * states based on the states context or any custom overrides.
	 *
	 * The main interaction state is the "ripple" effect when an element has been
	 * clicked either via keyboard, mouse, or touch.
	 *
	 * If the ripple effect is disabled, it will fallback to "polyfilling"/fixing
	 * the `:pressed` pseudo-selector state for items so that a different
	 * background-color opacity is applied instead of the entire ripple effect. This
	 * is polyfilled since the `:pressed` state does not work on anything other than
	 * buttons and links by default and it is not triggered on "valid" keyboard
	 * clicks with a spacebar.
	 *
	 * Finally, the element that uses this hook will gain a focused className
	 * whenever it gains keyboard focus only.
	 *
	 * To get all these interaction states to work correctly, this hook returns an
	 * object containing:
	 *
	 * - `handlers`- an object of event handlers that must be passed down to your
	 *   component to get the different interaction states. All the event handlers
	 *   are automatically merged with any `handlers` that are provided to this hook
	 *   so they can all be called if needed.
	 * - `className` - the current class name for the element
	 * - `ripples` - a renderable element that displays the ripple effects. This
	 *   will be `null` when ripples are disabled.
	 *
	 * @typeparam E The element type for the component being wrapped. This is really
	 * just used to "better type" the event handlers.
	 */
	function useInteractionStates(options) {
	    if (options === void 0) { options = {}; }
	    var disabled = options.disabled, rippleClassName = options.rippleClassName, rippleContainerClassName = options.rippleContainerClassName, _a = options.disableSpacebarClick, disableSpacebarClick = _a === void 0 ? false : _a, _b = options.disablePressedFallback, disablePressedFallback = _b === void 0 ? false : _b, _c = options.enablePressedAndRipple, enablePressedAndRipple = _c === void 0 ? false : _c, _d = options.disableEnterClick, disableEnterClick = _d === void 0 ? false : _d;
	    var className = options.className, disableRipple = options.disableRipple, disableProgrammaticRipple = options.disableProgrammaticRipple, rippleTimeout = options.rippleTimeout, rippleClassNames = options.rippleClassNames;
	    // populate undefined props from their context values
	    var context = useStatesConfigContext();
	    if (typeof disableRipple === "undefined") {
	        (disableRipple = context.disableRipple);
	    }
	    if (typeof disableProgrammaticRipple === "undefined") {
	        (disableProgrammaticRipple = context.disableProgrammaticRipple);
	    }
	    if (typeof rippleTimeout === "undefined") {
	        (rippleTimeout = context.rippleTimeout);
	    }
	    if (typeof rippleClassNames === "undefined") {
	        (rippleClassNames = context.rippleClassNames);
	    }
	    var handlers = null;
	    var ripples = null;
	    var ripplesResult = useRipples(__assign$j(__assign$j({}, options), { disableSpacebarClick: disableSpacebarClick,
	        disableRipple: disableRipple,
	        disableProgrammaticRipple: disableProgrammaticRipple,
	        rippleTimeout: rippleTimeout,
	        rippleClassName: rippleClassName,
	        rippleContainerClassName: rippleContainerClassName }));
	    if (!disableRipple) {
	        (ripples = ripplesResult.ripples, handlers = ripplesResult.handlers);
	    }
	    var pressedResult = usePressedStates(__assign$j(__assign$j({}, options), { handlers: handlers || options.handlers, disableSpacebarClick: disableSpacebarClick }));
	    if (enablePressedAndRipple || (disableRipple && !disablePressedFallback)) {
	        (handlers = pressedResult.handlers);
	        className = classnames(className, { "rmd-states--pressed": pressedResult.pressed });
	    }
	    handlers = handlers || options.handlers || {};
	    handlers.onKeyDown = useKeyboardClickPolyfill({
	        disabled: disabled,
	        disableEnterClick: disableEnterClick,
	        disableSpacebarClick: disableSpacebarClick,
	        onKeyDown: handlers.onKeyDown,
	    });
	    return {
	        ripples: ripples,
	        className: className,
	        handlers: handlers,
	    };
	}

	var __assign$k = (undefined && undefined.__assign) || function () {
	    __assign$k = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$k.apply(this, arguments);
	};
	var __rest$b = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var styles = bem("rmd-fab");
	/**
	 * This is a simple wrapper for the `Button` component that will conditionally
	 * render the `Button` in a `<span>` to render as a floating action button.
	 *
	 * Note: You probably don't really want to use this externally since this is
	 * really just required so that the click and focus states behavior will still
	 * be contained within the button. The states behavior requires
	 * `position: relative` to work while changing into a floating action button
	 * makes it `position: fixed`.
	 */
	var FAB = React.forwardRef(function FAB(_a, ref) {
	    var _b = _a.position, position = _b === void 0 ? null : _b, children = _a.children, className = _a.className, props = __rest$b(_a, ["position", "children", "className"]);
	    if (!position) {
	        return React__default.createElement(React__default.Fragment, null, children);
	    }
	    return (React__default.createElement("span", __assign$k({}, props, { ref: ref, className: classnames(styles({
	            tl: position === "top-left",
	            tr: position === "top-right",
	            bl: position === "bottom-left",
	            br: position === "bottom-right",
	        }), className) }), children));
	});

	var __assign$l = (undefined && undefined.__assign) || function () {
	    __assign$l = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$l.apply(this, arguments);
	};
	var __rest$c = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var Button = React.forwardRef(function Button(_a, ref) {
	    var _b = _a.type, type = _b === void 0 ? "button" : _b, _c = _a.disabled, disabled = _c === void 0 ? false : _c, _d = _a.floating, floating = _d === void 0 ? null : _d, floatingProps = _a.floatingProps, _e = _a.theme, theme = _e === void 0 ? floating ? "secondary" : "clear" : _e, _f = _a.themeType, themeType = _f === void 0 ? floating ? "contained" : "flat" : _f, _g = _a.buttonType, buttonType = _g === void 0 ? floating ? "icon" : "text" : _g, propClassName = _a.className, children = _a.children, disableRipple = _a.disableRipple, disableProgrammaticRipple = _a.disableProgrammaticRipple, rippleTimeout = _a.rippleTimeout, rippleClassNames = _a.rippleClassNames, rippleClassName = _a.rippleClassName, rippleContainerClassName = _a.rippleContainerClassName, propEnablePressedAndRipple = _a.enablePressedAndRipple, props = __rest$c(_a, ["type", "disabled", "floating", "floatingProps", "theme", "themeType", "buttonType", "className", "children", "disableRipple", "disableProgrammaticRipple", "rippleTimeout", "rippleClassNames", "rippleClassName", "rippleContainerClassName", "enablePressedAndRipple"]);
	    var enablePressedAndRipple = typeof propEnablePressedAndRipple === "boolean"
	        ? propEnablePressedAndRipple
	        : themeType === "contained";
	    var _h = useInteractionStates({
	        handlers: props,
	        className: buttonThemeClassNames({
	            theme: theme,
	            themeType: themeType,
	            buttonType: buttonType,
	            disabled: disabled,
	            className: propClassName,
	        }),
	        disabled: disabled,
	        disableRipple: disableRipple,
	        disableProgrammaticRipple: disableProgrammaticRipple,
	        rippleTimeout: rippleTimeout,
	        rippleClassNames: rippleClassNames,
	        rippleClassName: rippleClassName,
	        rippleContainerClassName: rippleContainerClassName,
	        enablePressedAndRipple: enablePressedAndRipple,
	    }), ripples = _h.ripples, className = _h.className, handlers = _h.handlers;
	    return (React__default.createElement(FAB, __assign$l({ position: floating }, floatingProps),
	        React__default.createElement("button", __assign$l({}, props, handlers, { ref: ref, type: type, className: className, disabled: disabled }),
	            children,
	            ripples)));
	});
	{
	    try {
	        var PropTypes$e = require("prop-types");
	        Button.propTypes = {
	            type: PropTypes$e.oneOf(["button", "reset", "submit"]),
	            className: PropTypes$e.string,
	            theme: PropTypes$e.oneOf([
	                "clear",
	                "primary",
	                "secondary",
	                "warning",
	                "error",
	            ]),
	            themeType: PropTypes$e.oneOf(["flat", "outline", "contained"]),
	            buttonType: PropTypes$e.oneOf(["text", "icon"]),
	            disabled: PropTypes$e.bool,
	            children: PropTypes$e.node,
	            disableRipple: PropTypes$e.bool,
	            disableProgrammaticRipple: PropTypes$e.bool,
	            rippleTimeout: PropTypes$e.oneOfType([
	                PropTypes$e.number,
	                PropTypes$e.shape({
	                    appear: PropTypes$e.number,
	                    enter: PropTypes$e.number,
	                    exit: PropTypes$e.number,
	                }),
	            ]),
	            rippleClassNames: PropTypes$e.oneOfType([
	                PropTypes$e.string,
	                PropTypes$e.shape({
	                    appear: PropTypes$e.string,
	                    appearActive: PropTypes$e.string,
	                    enter: PropTypes$e.string,
	                    enterActive: PropTypes$e.string,
	                    enterDone: PropTypes$e.string,
	                    exit: PropTypes$e.string,
	                    exitActive: PropTypes$e.string,
	                    exitDone: PropTypes$e.string,
	                }),
	            ]),
	            rippleClassName: PropTypes$e.string,
	            rippleContainerClassName: PropTypes$e.string,
	            enablePressedAndRipple: PropTypes$e.bool,
	            floating: PropTypes$e.oneOf([
	                "top-left",
	                "top-right",
	                "bottom-left",
	                "bottom-right",
	            ]),
	            floatingProps: PropTypes$e.object,
	        };
	    }
	    catch (e) { }
	}

	var __assign$m = (undefined && undefined.__assign) || function () {
	    __assign$m = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$m.apply(this, arguments);
	};
	var __rest$d = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * The unstyled button is a really simple button element that resets the default
	 * browser button styles into a clear clickable element.
	 */
	var UnstyledButton = React.forwardRef(function UnstyledButton(_a, ref) {
	    var className = _a.className, children = _a.children, props = __rest$d(_a, ["className", "children"]);
	    return (React__default.createElement("button", __assign$m({}, props, { type: "button", ref: ref, className: classnames("rmd-button-unstyled", className) }), children));
	});
	{
	    try {
	        var PropTypes$f = require("prop-types");
	        UnstyledButton.propTypes = {
	            className: PropTypes$f.string,
	            disabled: PropTypes$f.bool,
	            children: PropTypes$f.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$n = (undefined && undefined.__assign) || function () {
	    __assign$n = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$n.apply(this, arguments);
	};
	var __rest$e = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	function getId(snackbarId, toastId, actionId) {
	    if (actionId) {
	        return actionId;
	    }
	    if (toastId) {
	        return toastId + "-action";
	    }
	    return snackbarId + "-action";
	}
	/**
	 * Because the toast renderer is a callback function instead of a React
	 * component, it's actually required to create a separate component instance so
	 * that the context API can be
	 *
	 * @private
	 */
	function SnackbarQueue(_a, ref) {
	    var queue = _a.queue, onActionClick = _a.onActionClick, props = __rest$e(_a, ["queue", "onActionClick"]);
	    var toast = queue[0];
	    var visible = useMessageVisibility();
	    var _b = useMessageQueueActions(), popMessage = _b.popMessage, hideMessage = _b.hideMessage, startTimer = _b.startTimer;
	    var content = null;
	    if (toast) {
	        var snackbarId = props.id;
	        var toastId = toast.id;
	        var _messageId = toast.messageId, _messagePriority = toast.messagePriority, _c = toast.disableAutohide, disableAutohide = _c === void 0 ? false : _c, _d = toast.disableActionHide, disableActionHide_1 = _d === void 0 ? false : _d, providedAction = toast.action, toastProps = __rest$e(toast, ["messageId", "messagePriority", "disableAutohide", "disableActionHide", "action"]);
	        var action = null;
	        if (providedAction) {
	            var actionProps_1 = providedAction;
	            var onClick = function (event) {
	                if (onActionClick) {
	                    onActionClick(toast, event);
	                }
	                if (actionProps_1.onClick) {
	                    actionProps_1.onClick(event);
	                }
	                if (!disableActionHide_1) {
	                    hideMessage();
	                }
	            };
	            var t = typeof providedAction;
	            if (React.isValidElement(providedAction) || t !== "object") {
	                action = (React__default.createElement(Button, { id: getId(snackbarId, toastId, undefined), onClick: onClick, theme: "secondary" }, providedAction));
	            }
	            else {
	                action = (React__default.createElement(Button, __assign$n({ id: getId(snackbarId, toastId, actionProps_1.id), theme: "secondary" }, actionProps_1, { onClick: onClick })));
	            }
	        }
	        content = (React__default.createElement(Toast, __assign$n({}, toastProps, { action: action, visible: visible, onEntered: disableAutohide ? undefined : startTimer, onExited: popMessage })));
	    }
	    return (React__default.createElement(Snackbar, __assign$n({}, props, { ref: ref }), content));
	}
	// eslint-disable-next-line @typescript-eslint/no-explicit-any
	var SnackbarQueue$1 = React.forwardRef(SnackbarQueue);

	/**
	 * This hook is used to pause the exit timeout if the user blurs the window
	 * while a toast is visible and the autohide functionality is not disabled. If
	 * this functionality is not added, messages and alerts might be missed by the
	 * user since they minimized the browser or viewing something on a second
	 * screen.
	 *
	 * @private
	 */
	function useWindowBlurPause(_a) {
	    var startTimer = _a.startTimer, stopTimer = _a.stopTimer, visible = _a.visible, message = _a.message, _b = _a.disabled, disabled = _b === void 0 ? false : _b;
	    React.useEffect(function () {
	        if (disabled || !visible || !message || message.disableAutohide) {
	            return;
	        }
	        var handleFocusEvent = function (event) {
	            if (event.type === "focus") {
	                startTimer();
	            }
	            else {
	                stopTimer();
	            }
	        };
	        window.addEventListener("blur", handleFocusEvent);
	        window.addEventListener("focus", handleFocusEvent);
	        return function () {
	            window.removeEventListener("blur", handleFocusEvent);
	            window.removeEventListener("focus", handleFocusEvent);
	        };
	    }, [disabled, startTimer, stopTimer, visible, message]);
	}

	var __spreadArrays$2 = (undefined && undefined.__spreadArrays) || function () {
	    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	    for (var r = Array(s), k = 0, i = 0; i < il; i++)
	        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
	            r[k] = a[j];
	    return r;
	};
	var ADD_MESSAGE = "ADD_MESSAGE";
	var POP_MESSAGE = "POP_MESSAGE";
	var RESET_QUEUE = "RESET_QUEUE";
	/**
	 * @private
	 */
	var popMessage = function () { return ({ type: POP_MESSAGE }); };
	/**
	 * @private
	 */
	var resetQueue = function () { return ({ type: RESET_QUEUE }); };
	/**
	 * This function is used to update the message queue state by adding a new message when
	 * needed.
	 *
	 * @private
	 */
	function handleAddMessage(state, message, duplicates) {
	    if (state.length === 0) {
	        return [message];
	    }
	    var messageId = message.messageId, _a = message.messagePriority, messagePriority = _a === void 0 ? "normal" : _a;
	    var i = state.findIndex(function (mes) { return mes.messageId === messageId; });
	    var isNext = messagePriority === "next";
	    var isNormal = messagePriority === "normal";
	    var isReplace = messagePriority === "replace";
	    var isImmediate = messagePriority === "immediate";
	    var isDuplicable = duplicates === "allow";
	    var isRestart = duplicates === "restart";
	    if (isNext || isImmediate) {
	        var nextState = state.slice();
	        // remove the existing message if duplicated messages aren't allowed. This will
	        // kind of act like a replace + next behavior
	        if (!isDuplicable && i > 0) {
	            nextState.splice(i, 1);
	        }
	        var current = nextState[0], remaining = nextState.slice(1);
	        if (isImmediate && current.messagePriority !== "immediate") {
	            return __spreadArrays$2([current, message, current], remaining);
	        }
	        return __spreadArrays$2([current, message], remaining);
	    }
	    if (i === -1 || (isDuplicable && isNormal)) {
	        return __spreadArrays$2(state, [message]);
	    }
	    if (isNormal) {
	        if (isRestart) {
	            // creating a new state so that the queue visibility hook can still be triggered
	            // which will restart the timer
	            return state.slice();
	        }
	        return state;
	    }
	    if (isReplace) {
	        var nextState = state.slice();
	        nextState[i] = message;
	        return nextState;
	    }
	    return __spreadArrays$2(state, [message]);
	}
	/**
	 * @private
	 */
	function reducer$1(state, action) {
	    switch (action.type) {
	        case ADD_MESSAGE:
	            return handleAddMessage(state, action.message, action.duplicates);
	        case POP_MESSAGE:
	            return state.length ? state.slice(1) : state;
	        case RESET_QUEUE:
	            return state.length ? [] : state;
	        default:
	            return state;
	    }
	}
	/**
	 * This is the main logic for the message queue behavior that will handle:
	 *
	 * - creating timeouts as needed to show/hide toasts within the SnackbarQueue component
	 * - create a way to push messages with optional priority onto the queue
	 *
	 * @private
	 */
	function useMessageQueue(_a) {
	    var _b = _a.timeout, timeout = _b === void 0 ? DEFAULT_MESSAGE_QUEUE_TIMEOUT : _b, _c = _a.duplicates, duplicates = _c === void 0 ? "allow" : _c, _d = _a.defaultQueue, defaultQueue = _d === void 0 ? [] : _d;
	    var _e = React.useReducer(function (state, action) { return reducer$1(state, action); }, defaultQueue), queue = _e[0], dispatch = _e[1];
	    var queueRef = React.useRef(queue);
	    var addMessageDispatch = React.useCallback(function (message) {
	        if (duplicates !== "allow" && !message.messageId) {
	            throw new Error("A messageId is required when the \"" + duplicates + "\" duplicate behavior is enabled but it was not provided in the current message.");
	        }
	        dispatch({ type: ADD_MESSAGE, message: message, duplicates: duplicates });
	    }, [duplicates]);
	    var popMessageDispatch = React.useCallback(function () {
	        dispatch(popMessage());
	    }, []);
	    var resetQueueDispatch = React.useCallback(function () {
	        dispatch(resetQueue());
	        return queueRef.current;
	    }, []);
	    var _f = useToggle(defaultQueue.length > 0), visible = _f[0], showMessage = _f[1], hideMessage = _f[2];
	    var _g = useTimeout(hideMessage, timeout), startTimer = _g[0], stopTimer = _g[1], restartTimer = _g[2];
	    React.useEffect(function () {
	        // this effect will handle all the "logic" for transitioning between each message along with the
	        // message priority updates.
	        var message = queue[0], nextMessage = queue[1];
	        if (!message) {
	            return;
	        }
	        var prevQueue = queueRef.current;
	        var prevMessage = prevQueue[0];
	        if (message.messagePriority !== "immediate" &&
	            nextMessage &&
	            nextMessage.messagePriority === "immediate") {
	            stopTimer();
	            if (!visible) {
	                popMessageDispatch();
	                return;
	            }
	            hideMessage();
	            return;
	        }
	        if (!visible) {
	            showMessage();
	        }
	        if (queue.length === prevQueue.length && message === prevMessage) {
	            restartTimer();
	        }
	        // only want to run this on queue changes
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [queue]);
	    useWindowBlurPause({
	        startTimer: startTimer,
	        stopTimer: stopTimer,
	        visible: visible,
	        message: queue[0],
	    });
	    React.useEffect(function () {
	        queueRef.current = queue;
	    });
	    return {
	        queue: queue,
	        resetQueue: resetQueueDispatch,
	        visible: visible,
	        hideMessage: hideMessage,
	        addMessage: addMessageDispatch,
	        popMessage: popMessageDispatch,
	        startTimer: startTimer,
	        stopTimer: stopTimer,
	        restartTimer: restartTimer,
	    };
	}

	var __assign$o = (undefined && undefined.__assign) || function () {
	    __assign$o = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$o.apply(this, arguments);
	};
	var __rest$f = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This component is used to be able to create a queue of messages with the `Snackbar` and
	 * `Toast` components with a _fairly_ decent API out of the box.
	 */
	function MessageQueue(_a) {
	    var _b = _a.timeout, timeout = _b === void 0 ? 5000 : _b, _c = _a.duplicates, duplicates = _c === void 0 ? "allow" : _c, _d = _a.defaultQueue, defaultQueue = _d === void 0 ? [] : _d, children = _a.children, props = __rest$f(_a, ["timeout", "duplicates", "defaultQueue", "children"]);
	    var _e = useMessageQueue({ timeout: timeout, duplicates: duplicates, defaultQueue: defaultQueue }), queue = _e.queue, visible = _e.visible, hideMessage = _e.hideMessage, startTimer = _e.startTimer, stopTimer = _e.stopTimer, restartTimer = _e.restartTimer, addMessage = _e.addMessage, popMessage = _e.popMessage, resetQueue = _e.resetQueue;
	    var actions = React.useMemo(function () { return ({
	        popMessage: popMessage,
	        hideMessage: hideMessage,
	        startTimer: startTimer,
	        stopTimer: stopTimer,
	        resetQueue: resetQueue,
	        restartTimer: restartTimer,
	    }); }, [popMessage, hideMessage, startTimer, stopTimer, restartTimer, resetQueue]);
	    return (React__default.createElement(AddMessageContext.Provider, { value: addMessage },
	        React__default.createElement(MessageQueueActionsContext.Provider, { value: actions },
	            React__default.createElement(MessageVisibilityContext.Provider, { value: visible },
	                React__default.createElement(MessageQueueContext.Provider, { value: queue }, children),
	                React__default.createElement(SnackbarQueue$1, __assign$o({}, props, { queue: queue }))))));
	}
	{
	    try {
	        var PropTypes$g = require("prop-types");
	        MessageQueue.propTypes = {
	            timeout: PropTypes$g.number,
	            duplicates: PropTypes$g.oneOf(["allow", "restart", "prevent"]),
	            defaultQueue: PropTypes$g.array,
	            onActionClick: PropTypes$g.func,
	            children: PropTypes$g.node.isRequired,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * Boolean if the child components should inherit the color of the app bar.
	 * @private
	 */
	var InheritContext = React.createContext(false);
	/**
	 * This is probably a bit overkill... but this is used so that all the AppBar
	 * child components can automatically inherit the base color as needed within an
	 * AppBar. If the `inheritColor` prop was provided to the component, that value
	 * will be used instead.
	 *
	 * @param inheritColor The prop inheritColor for the component
	 * @return true if the color should be inherited.
	 * @private
	 */
	function useInheritContext(inheritColor) {
	    var inheritContext = React.useContext(InheritContext);
	    return typeof inheritColor === "boolean" ? inheritColor : inheritContext;
	}
	/**
	 * Boolean if there is a parent app bar. The theme colors will be inherited from
	 * the parent app bar instead of the current app bar for these cases since
	 * nested app bars usually happen with prominent toolbars and the root app bar
	 * defines the theme.
	 *
	 * @private
	 */
	var ParentContext$1 = React.createContext(false);
	/**
	 *
	 * @private
	 */
	function useParentContext() {
	    return React.useContext(ParentContext$1);
	}
	{
	    InheritContext.displayName = "InheritColorContext";
	    ParentContext$1.displayName = "ParentContext";
	}

	var __assign$p = (undefined && undefined.__assign) || function () {
	    __assign$p = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$p.apply(this, arguments);
	};
	var __rest$g = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$7 = bem("rmd-app-bar");
	/**
	 * This component is used to create a top-level app bar in your application that
	 * can be used to contain a navigation menu toggle button, the app's logo and/or
	 * title, as well as any top-level actions that will be reused throughout your
	 * app. When using this component with the `fixed` prop, it is recommended to
	 * also use one of the "offset class names" so that your content will not be
	 * converted by the app bar. You can also use any of the exposed mixins to add
	 * these offsets as well.
	 */
	var AppBar = React.forwardRef(function AppBar(_a, ref) {
	    var _b;
	    var className = _a.className, children = _a.children, _c = _a.theme, propTheme = _c === void 0 ? "primary" : _c, _d = _a.component, propComponent = _d === void 0 ? "header" : _d, _e = _a.height, height = _e === void 0 ? "normal" : _e, _f = _a.fixed, fixed = _f === void 0 ? false : _f, _g = _a.fixedPosition, fixedPosition = _g === void 0 ? "top" : _g, _h = _a.fixedElevation, fixedElevation = _h === void 0 ? true : _h, inheritColor = _a.inheritColor, _j = _a.flexWrap, flexWrap = _j === void 0 ? height === "none" ||
	        height === "prominent" ||
	        height === "prominent-dense" : _j, remaining = __rest$g(_a, ["className", "children", "theme", "component", "height", "fixed", "fixedPosition", "fixedElevation", "inheritColor", "flexWrap"]);
	    var parentContext = useParentContext();
	    var inheritContext = useInheritContext(undefined);
	    var inherit;
	    var theme = propTheme;
	    var Component = propComponent;
	    if (typeof inheritColor === "boolean") {
	        inherit = inheritColor;
	    }
	    else if (parentContext) {
	        inherit = inheritContext;
	        theme = "clear";
	        Component = "div";
	    }
	    else {
	        inherit = theme !== "clear" && theme !== "default";
	    }
	    return (React__default.createElement(ParentContext$1.Provider, { value: true },
	        React__default.createElement(InheritContext.Provider, { value: inherit },
	            React__default.createElement(Component, __assign$p({}, remaining, { className: classnames(block$7((_b = {},
	                    _b[theme] = theme !== "clear",
	                    _b[height] = height !== "none",
	                    _b.wrap = flexWrap,
	                    _b.fixed = fixed,
	                    _b[fixedPosition] = fixed,
	                    _b["fixed-elevation"] = fixed && fixedElevation,
	                    _b)), className), ref: ref }), children))));
	});
	{
	    try {
	        var PropTypes$h = require("prop-types");
	        AppBar.propTypes = {
	            className: PropTypes$h.string,
	            component: PropTypes$h.oneOfType([
	                PropTypes$h.string,
	                PropTypes$h.func,
	                PropTypes$h.object,
	            ]),
	            height: PropTypes$h.oneOf([
	                "none",
	                "normal",
	                "dense",
	                "prominent",
	                "prominent-dense",
	            ]),
	            flexWrap: PropTypes$h.bool,
	            children: PropTypes$h.node,
	            fixed: PropTypes$h.bool,
	            fixedPosition: PropTypes$h.oneOf(["top", "bottom"]),
	            fixedElevation: PropTypes$h.bool,
	            inheritColor: PropTypes$h.bool,
	            theme: PropTypes$h.oneOf(["primary", "secondary", "default", "clear"]),
	        };
	    }
	    catch (e) { }
	}

	var __assign$q = (undefined && undefined.__assign) || function () {
	    __assign$q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$q.apply(this, arguments);
	};
	var __rest$h = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$8 = bem("rmd-app-bar");
	/**
	 * This component is used to create a title for your application. If your app is
	 * not using the `AppBarNav` component, you can enable the `keyline` prop to
	 * ensure that your title aligns with the keyline of your navigation element.
	 */
	var AppBarTitle = React.forwardRef(function AppBarTitle(_a, ref) {
	    var _b = _a.noWrap, noWrap = _b === void 0 ? true : _b, _c = _a.keyline, keyline = _c === void 0 ? false : _c, className = _a.className, children = _a.children, inheritColor = _a.inheritColor, props = __rest$h(_a, ["noWrap", "keyline", "className", "children", "inheritColor"]);
	    return (React__default.createElement("h6", __assign$q({}, props, { ref: ref, className: classnames(block$8("title", {
	            "no-wrap": noWrap,
	            keyline: keyline,
	            inherit: useInheritContext(inheritColor),
	        }), className) }), children));
	});
	{
	    try {
	        var PropTypes$i = require("prop-types");
	        AppBarTitle.propTypes = {
	            className: PropTypes$i.string,
	            children: PropTypes$i.node,
	            keyline: PropTypes$i.bool,
	            noWrap: PropTypes$i.bool,
	            inheritColor: PropTypes$i.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$r = (undefined && undefined.__assign) || function () {
	    __assign$r = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$r.apply(this, arguments);
	};
	var __rest$i = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$9 = bem("rmd-app-bar");
	/**
	 * This component is really just a simple wrapper for the `Button` component
	 * that adds some additional styles for adding spacing before and after this
	 * button so that it aligns to the main "keyline" of your application's
	 * navigation. In simpler terms, it will make the left side of the icon in this
	 * button aligns with all the other icons that appear in `ListItem`s in your
	 * main navigation.
	 *
	 * This component is generally really only used when you want to have a
	 * temporary navigation element like a hamburger menu.
	 */
	var AppBarNav = React.forwardRef(function AppBarNav(_a, ref) {
	    var className = _a.className, children = _a.children, inheritColor = _a.inheritColor, floating = _a.floating, _b = _a.theme, theme = _b === void 0 ? floating ? "secondary" : "clear" : _b, _c = _a.buttonType, buttonType = _c === void 0 ? "icon" : _c, props = __rest$i(_a, ["className", "children", "inheritColor", "floating", "theme", "buttonType"]);
	    return (React__default.createElement(Button, __assign$r({}, props, { theme: theme, floating: floating, buttonType: buttonType, ref: ref, className: classnames(block$9("nav", {
	            inherit: useInheritContext(inheritColor),
	        }), className) }), children));
	});

	var block$a = bem("rmd-app-bar");
	/**
	 * This is a hook that will apply the nav classnames to an element. This should
	 * really not be used externally and is really just for creating dropdown menus
	 * within app bars that have the action styles.
	 *
	 * @private
	 */
	function useActionClassName(_a) {
	    var _b = _a === void 0 ? {} : _a, first = _b.first, last = _b.last, inheritColor = _b.inheritColor, className = _b.className;
	    return classnames(block$a("action", {
	        first: first,
	        last: last,
	        inherit: useInheritContext(inheritColor),
	    }), className);
	}

	var __assign$s = (undefined && undefined.__assign) || function () {
	    __assign$s = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$s.apply(this, arguments);
	};
	var __rest$j = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This component is really just a simple wrapper for the `Button` component
	 * that adds a few additional styles to prevent the button from shrinking when
	 * an `AppBar` has a lot of content.  It also will automatically add spacing
	 * either before or after this button when the `first` or `last` props are
	 * provided.
	 */
	var AppBarAction = React.forwardRef(function AppBarAction(_a, ref) {
	    var className = _a.className, _b = _a.first, first = _b === void 0 ? false : _b, _c = _a.last, last = _c === void 0 ? false : _c, children = _a.children, inheritColor = _a.inheritColor, floating = _a.floating, _d = _a.theme, theme = _d === void 0 ? floating ? "secondary" : "clear" : _d, _e = _a.buttonType, buttonType = _e === void 0 ? "icon" : _e, props = __rest$j(_a, ["className", "first", "last", "children", "inheritColor", "floating", "theme", "buttonType"]);
	    return (React__default.createElement(Button, __assign$s({}, props, { theme: theme, buttonType: buttonType, floating: floating, ref: ref, className: useActionClassName({ first: first, last: last, inheritColor: inheritColor, className: className }) }), children));
	});
	{
	    try {
	        var PropTypes$j = require("prop-types");
	        AppBarAction.propTypes = {
	            className: PropTypes$j.string,
	            children: PropTypes$j.node,
	            first: PropTypes$j.bool,
	            last: PropTypes$j.bool,
	            theme: PropTypes$j.oneOf([
	                "primary",
	                "secondary",
	                "warning",
	                "error",
	                "clear",
	            ]),
	            buttonType: PropTypes$j.oneOf(["text", "icon"]),
	            floating: PropTypes$j.oneOf([
	                "top-left",
	                "top-right",
	                "bottom-left",
	                "bottom-right",
	            ]),
	            inheritColor: PropTypes$j.bool,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * A classname to apply to an element that should be offset either with padding
	 * or margin by the height of a normal App Bar.
	 */
	var APP_BAR_OFFSET_CLASSNAME = "rmd-app-bar-offset";
	/**
	 * A classname to apply to an element that should be offset either with padding
	 * or margin by the height of a dense App Bar.
	 */
	var APP_BAR_OFFSET_DENSE_CLASSNAME = "rmd-app-bar-offset--dense";
	/**
	 * A classname to apply to an element that should be offset either with padding
	 * or margin by the height of a prominent App Bar.
	 */
	var APP_BAR_OFFSET_PROMINENT_CLASSNAME = "rmd-app-bar-offset--prominent";
	/**
	 * A classname to apply to an element that should be offset either with padding
	 * or margin by the height of a prominent and dense App Bar.
	 */
	var APP_BAR_OFFSET_PROMINENT_DENSE_CLASSNAME = "rmd-app-bar-offset--prominent-dense";

	var __assign$t = (undefined && undefined.__assign) || function () {
	    __assign$t = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$t.apply(this, arguments);
	};
	var __rest$k = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This is probably one of the least useful components available as it doesn't
	 * do much styling or logic. All this form component will do is add basic flex
	 * behavior and prevent the default form submit behavior.
	 */
	var Form = React.forwardRef(function Form(_a, ref) {
	    var children = _a.children, _b = _a.disablePreventDefault, disablePreventDefault = _b === void 0 ? false : _b, onSubmit = _a.onSubmit, props = __rest$k(_a, ["children", "disablePreventDefault", "onSubmit"]);
	    var handleOnSubmit = React.useCallback(function (event) {
	        if (!disablePreventDefault) {
	            event.preventDefault();
	        }
	        if (onSubmit) {
	            onSubmit(event);
	        }
	    }, [disablePreventDefault, onSubmit]);
	    return (React__default.createElement("form", __assign$t({}, props, { onSubmit: handleOnSubmit, ref: ref }), children));
	});
	{
	    try {
	        var PropTypes$k = require("prop-types");
	        Form.propTypes = {
	            children: PropTypes$k.node,
	            onSubmit: PropTypes$k.func,
	            disablePreventDefault: PropTypes$k.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$u = (undefined && undefined.__assign) || function () {
	    __assign$u = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$u.apply(this, arguments);
	};
	var __rest$l = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$b = bem("rmd-fieldset");
	/**
	 * This is a simple wrapper for the `<fieldset>` that defaults to removing
	 * the default styles of a border, padding, and margin and having a screen-reader
	 * visible only legend element for added accessibility.
	 */
	var Fieldset = React.forwardRef(function Fieldset(_a, ref) {
	    var className = _a.className, legend = _a.legend, legendStyle = _a.legendStyle, legendClassName = _a.legendClassName, _b = _a.legendSROnly, legendSROnly = _b === void 0 ? false : _b, _c = _a.unstyled, unstyled = _c === void 0 ? true : _c, children = _a.children, props = __rest$l(_a, ["className", "legend", "legendStyle", "legendClassName", "legendSROnly", "unstyled", "children"]);
	    return (React__default.createElement("fieldset", __assign$u({}, props, { ref: ref, className: classnames(block$b({ unstyled: unstyled }), className) }),
	        React__default.createElement("legend", { style: legendStyle, className: classnames(block$b("legend", { "sr-only": legendSROnly }), legendClassName) }, legend),
	        children));
	});
	{
	    try {
	        var PropTypes$l = require("prop-types");
	        Fieldset.propTypes = {
	            className: PropTypes$l.string,
	            unstyled: PropTypes$l.bool,
	            legend: PropTypes$l.node.isRequired,
	            legendStyle: PropTypes$l.object,
	            legendClassName: PropTypes$l.string,
	            legendSROnly: PropTypes$l.bool,
	            children: PropTypes$l.node,
	        };
	    }
	    catch (e) { }
	}

	var context = React.createContext({
	    theme: "outline",
	    underlineDirection: "left",
	});
	/**
	 * Gets the current theme values for a form component by inheriting the current
	 * form theme via context. If you provide an object of theme props, the returned
	 * value will use any defined values from the theme props and fallback to the
	 * context value.
	 *
	 * Example:
	 * ```ts
	 * // everything is inherited
	 * const formTheme = useFormTheme();
	 *
	 * // theme will be set to "underline" while the others will be inherited
	 * const formTheme = useFormTheme({ theme: "underline" });
	 * ```
	 */
	function useFormTheme(options) {
	    if (options === void 0) { options = {}; }
	    var formTheme = React.useContext(context);
	    var theme = options.theme, underlineDirection = options.underlineDirection;
	    theme = theme !== null && theme !== void 0 ? theme : formTheme.theme;
	    underlineDirection = underlineDirection !== null && underlineDirection !== void 0 ? underlineDirection : formTheme.underlineDirection;
	    return {
	        theme: theme,
	        underlineDirection: underlineDirection,
	    };
	}
	var Provider = context.Provider;
	/**
	 * Since you'll normally want all of your form components to use the same theme,
	 * this is a simple way to provide the same theme to all components without
	 * needing all the prop-drilling/copying.
	 */
	function FormThemeProvider(_a) {
	    var _b = _a.theme, theme = _b === void 0 ? "outline" : _b, _c = _a.underlineDirection, underlineDirection = _c === void 0 ? "left" : _c, children = _a.children;
	    var value = React.useMemo(function () { return ({ theme: theme, underlineDirection: underlineDirection }); }, [
	        theme,
	        underlineDirection,
	    ]);
	    return React__default.createElement(Provider, { value: value }, children);
	}

	var __assign$v = (undefined && undefined.__assign) || function () {
	    __assign$v = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$v.apply(this, arguments);
	};
	var __rest$m = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$c = bem("rmd-icon");
	/**
	 * The `FontIcon` component is used for rendering a font-icon library's icon.
	 * The default is to use the `material-icons` library, but others can be used as
	 * well.
	 *
	 * If you are using another font icon library that does not always create icons
	 * with a perfect 1:1 scale (such as font awesome), it is recommended to use the
	 * `forceSize` and `forceFontSize` props to fix the sizing issues.
	 */
	var FontIcon = React.forwardRef(function FontIcon(_a, ref) {
	    var className = _a.className, children = _a.children, _b = _a["aria-hidden"], ariaHidden = _b === void 0 ? true : _b, _c = _a.dense, dense = _c === void 0 ? false : _c, _d = _a.iconClassName, iconClassName = _d === void 0 ? "material-icons" : _d, _e = _a.forceSize, forceSize = _e === void 0 ? false : _e, _f = _a.forceFontSize, forceFontSize = _f === void 0 ? false : _f, props = __rest$m(_a, ["className", "children", "aria-hidden", "dense", "iconClassName", "forceSize", "forceFontSize"]);
	    return (React__default.createElement("i", __assign$v({}, props, { "aria-hidden": ariaHidden, ref: ref, className: classnames(block$c({
	            font: true,
	            dense: dense,
	            "forced-font": forceFontSize,
	            "forced-size": forceSize,
	        }), iconClassName, className) }), children));
	});
	{
	    try {
	        var PropTypes$m = require("prop-types");
	        FontIcon.propTypes = {
	            "aria-hidden": PropTypes$m.oneOfType([
	                PropTypes$m.oneOf(["true", "false"]),
	                PropTypes$m.bool,
	            ]),
	            className: PropTypes$m.string,
	            iconClassName: PropTypes$m.string,
	            dense: PropTypes$m.bool,
	            forceSize: PropTypes$m.bool,
	            forceFontSize: PropTypes$m.bool,
	            children: PropTypes$m.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$w = (undefined && undefined.__assign) || function () {
	    __assign$w = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$w.apply(this, arguments);
	};
	var __rest$n = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$d = bem("rmd-icon");
	/**
	 * The `SVGIcon` component is used to render inline SVG icons or SVG icons in a
	 * sprite map as an icon.
	 */
	var SVGIcon = React.forwardRef(function SVGIcon(_a, ref) {
	    var _b = _a["aria-hidden"], ariaHidden = _b === void 0 ? true : _b, _c = _a.focusable, focusable = _c === void 0 ? "false" : _c, _d = _a.xmlns, xmlns = _d === void 0 ? "http://www.w3.org/2000/svg" : _d, _e = _a.viewBox, viewBox = _e === void 0 ? "0 0 24 24" : _e, _f = _a.dense, dense = _f === void 0 ? false : _f, className = _a.className, use = _a.use, propChildren = _a.children, props = __rest$n(_a, ["aria-hidden", "focusable", "xmlns", "viewBox", "dense", "className", "use", "children"]);
	    var children = propChildren;
	    if (!children && use) {
	        children = React__default.createElement("use", { xlinkHref: use });
	    }
	    return (React__default.createElement("svg", __assign$w({}, props, { "aria-hidden": ariaHidden, ref: ref, className: classnames(block$d({ svg: true, dense: dense }), className), focusable: focusable, xmlns: xmlns, viewBox: viewBox }), children));
	});
	{
	    try {
	        var PropTypes$n = require("prop-types");
	        SVGIcon.propTypes = {
	            className: PropTypes$n.string,
	            role: PropTypes$n.string,
	            "aria-hidden": PropTypes$n.oneOfType([PropTypes$n.bool, PropTypes$n.string]),
	            "aria-labelledby": PropTypes$n.string,
	            focusable: PropTypes$n.oneOf(["true", "false"]),
	            viewBox: PropTypes$n.string,
	            xmlns: PropTypes$n.string,
	            use: PropTypes$n.string,
	            dense: PropTypes$n.bool,
	            children: PropTypes$n.node,
	        };
	    }
	    catch (e) { }
	}

	var TextIconSpacing = function (_a) {
	    var _b;
	    var className = _a.className, propIcon = _a.icon, _c = _a.children, children = _c === void 0 ? null : _c, _d = _a.stacked, stacked = _d === void 0 ? false : _d, _e = _a.iconAfter, iconAfter = _e === void 0 ? false : _e, _f = _a.forceIconWrap, forceIconWrap = _f === void 0 ? false : _f, _g = _a.beforeClassName, beforeClassName = _g === void 0 ? "rmd-icon--before" : _g, _h = _a.afterClassName, afterClassName = _h === void 0 ? "rmd-icon--after" : _h, _j = _a.aboveClassName, aboveClassName = _j === void 0 ? "rmd-icon--above" : _j, _k = _a.belowClassName, belowClassName = _k === void 0 ? "rmd-icon--below" : _k;
	    if (!propIcon) {
	        return React__default.createElement(React__default.Fragment, null, children);
	    }
	    var baseClassName = classnames((_b = {},
	        _b[beforeClassName] = !stacked && !iconAfter,
	        _b[afterClassName] = !stacked && iconAfter,
	        _b[aboveClassName] = stacked && !iconAfter,
	        _b[belowClassName] = stacked && iconAfter,
	        _b), className);
	    var iconEl = propIcon;
	    var content = children;
	    if (!forceIconWrap && React.isValidElement(propIcon)) {
	        var icon = React.Children.only(propIcon);
	        iconEl = React.cloneElement(icon, {
	            className: classnames(baseClassName, icon.props.className),
	        });
	    }
	    else if (propIcon) {
	        iconEl = (React__default.createElement("span", { className: classnames("rmd-text-icon-spacing", baseClassName) }, propIcon));
	    }
	    if (iconEl) {
	        content = (React__default.createElement(React__default.Fragment, null,
	            !iconAfter && iconEl,
	            children,
	            iconAfter && iconEl));
	    }
	    return content;
	};
	{
	    try {
	        var PropTypes$o = require("prop-types");
	        TextIconSpacing.propTypes = {
	            className: PropTypes$o.string,
	            icon: PropTypes$o.oneOfType([
	                PropTypes$o.element,
	                PropTypes$o.node,
	                PropTypes$o.object,
	            ]),
	            iconAfter: PropTypes$o.bool,
	            stacked: PropTypes$o.bool,
	            children: PropTypes$o.node,
	            beforeClassName: PropTypes$o.string,
	            afterClassName: PropTypes$o.string,
	            aboveClassName: PropTypes$o.string,
	            belowClassName: PropTypes$o.string,
	            forceIconWrap: PropTypes$o.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$x = (undefined && undefined.__assign) || function () {
	    __assign$x = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$x.apply(this, arguments);
	};
	var __rest$o = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$e = bem("rmd-icon-rotator");
	/**
	 * The `IconRotator` is a simple component that is used to rotate an icon from a
	 * one degrees to another.
	 */
	var IconRotator = React.forwardRef(function IconRotator(_a, ref) {
	    var style = _a.style, propClassName = _a.className, _b = _a.animate, animate = _b === void 0 ? true : _b, rotated = _a.rotated, children = _a.children, _c = _a.forceIconWrap, forceIconWrap = _c === void 0 ? false : _c, props = __rest$o(_a, ["style", "className", "animate", "rotated", "children", "forceIconWrap"]);
	    var className = classnames(block$e({ animate: animate, rotated: rotated }), propClassName);
	    if (!forceIconWrap && React.isValidElement(children)) {
	        var child = React.Children.only(children);
	        return React.cloneElement(child, {
	            className: classnames(className, child.props.className),
	        });
	    }
	    return (React__default.createElement("span", __assign$x({}, props, { style: style, className: className, ref: ref }), children));
	});
	{
	    try {
	        var PropTypes$p = require("prop-types");
	        IconRotator.propTypes = {
	            style: PropTypes$p.object,
	            className: PropTypes$p.string,
	            animate: PropTypes$p.bool,
	            rotated: PropTypes$p.bool,
	            forceIconWrap: PropTypes$p.bool,
	            children: PropTypes$p.node,
	        };
	    }
	    catch (e) { }
	}

	var DEFAULT_ICONS = {
	    back: React__default.createElement(FontIcon, null, "keyboard_arrow_left"),
	    checkbox: React__default.createElement(FontIcon, null, "check_box"),
	    download: React__default.createElement(FontIcon, null, "file_download"),
	    dropdown: React__default.createElement(FontIcon, null, "arrow_drop_down"),
	    expander: React__default.createElement(FontIcon, null, "keyboard_arrow_down"),
	    forward: React__default.createElement(FontIcon, null, "keyboard_arrow_right"),
	    menu: React__default.createElement(FontIcon, null, "menu"),
	    notification: React__default.createElement(FontIcon, null, "notifications"),
	    password: React__default.createElement(FontIcon, null, "remove_red_eye"),
	    radio: React__default.createElement(FontIcon, null, "radio_button_checked"),
	    selected: React__default.createElement(FontIcon, null, "check"),
	    sort: React__default.createElement(FontIcon, null, "arrow_upward"),
	};
	var context$1 = React.createContext(DEFAULT_ICONS);
	var Provider$1 = context$1.Provider;
	/**
	 * Gets one of the configured icons from the `IconProvider`. This is probably
	 * just for use within `react-md`, but might be helpful outside if you want to
	 * reuse the existing icon configuration for other custom components.
	 *
	 * If te second argument is provided and it is not `undefined`, that value will
	 * be used instead of the inherited icon type.
	 *
	 * @param name The name of the icon you want to use.
	 * @param override An optional override to use instead of the inherited icon.
	 * @return The overridden icon value or the inherited icon.
	 */
	function useIcon(name, override) {
	    var icons = React.useContext(context$1);
	    if (typeof override !== "undefined") {
	        return override;
	    }
	    return icons[name];
	}
	/**
	 * The `IconProvider` component is used to override all the default icons within
	 * `react-md` with a newly defined set of icons. This is super nice since you
	 * won't need to create new component wrappers for all the components within
	 * `react-md` if you want to switch to SVG icons instead of the default font
	 * icons.
	 */
	var IconProvider = function (_a) {
	    var children = _a.children, _b = _a.back, back = _b === void 0 ? DEFAULT_ICONS.back : _b, _c = _a.checkbox, checkbox = _c === void 0 ? DEFAULT_ICONS.checkbox : _c, _d = _a.download, download = _d === void 0 ? DEFAULT_ICONS.download : _d, _e = _a.dropdown, dropdown = _e === void 0 ? DEFAULT_ICONS.dropdown : _e, _f = _a.expander, expander = _f === void 0 ? DEFAULT_ICONS.expander : _f, _g = _a.forward, forward = _g === void 0 ? DEFAULT_ICONS.forward : _g, _h = _a.menu, menu = _h === void 0 ? DEFAULT_ICONS.menu : _h, _j = _a.notification, notification = _j === void 0 ? DEFAULT_ICONS.notification : _j, _k = _a.password, password = _k === void 0 ? DEFAULT_ICONS.password : _k, _l = _a.radio, radio = _l === void 0 ? DEFAULT_ICONS.radio : _l, _m = _a.selected, selected = _m === void 0 ? DEFAULT_ICONS.selected : _m, _o = _a.sort, sort = _o === void 0 ? DEFAULT_ICONS.sort : _o;
	    var value = React.useMemo(function () { return ({
	        back: back,
	        checkbox: checkbox,
	        download: download,
	        dropdown: dropdown,
	        expander: expander,
	        forward: forward,
	        menu: menu,
	        notification: notification,
	        password: password,
	        radio: radio,
	        selected: selected,
	        sort: sort,
	    }); }, [
	        back,
	        checkbox,
	        download,
	        dropdown,
	        expander,
	        forward,
	        menu,
	        notification,
	        password,
	        radio,
	        selected,
	        sort,
	    ]);
	    return React__default.createElement(Provider$1, { value: value }, children);
	};
	{
	    try {
	        var PropTypes$q = require("prop-types");
	        IconProvider.propTypes = {
	            children: PropTypes$q.node,
	            back: PropTypes$q.node,
	            checkbox: PropTypes$q.node,
	            download: PropTypes$q.node,
	            dropdown: PropTypes$q.node,
	            expander: PropTypes$q.node,
	            forward: PropTypes$q.node,
	            menu: PropTypes$q.node,
	            notification: PropTypes$q.node,
	            password: PropTypes$q.node,
	            radio: PropTypes$q.node,
	            selected: PropTypes$q.node,
	            sort: PropTypes$q.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$y = (undefined && undefined.__assign) || function () {
	    __assign$y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$y.apply(this, arguments);
	};
	var __rest$p = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	function getComponent(component, type) {
	    if (component) {
	        return component;
	    }
	    switch (type) {
	        case "headline-1":
	            return "h1";
	        case "headline-2":
	            return "h2";
	        case "headline-3":
	            return "h3";
	        case "headline-4":
	            return "h4";
	        case "headline-5":
	            return "h5";
	        case "headline-6":
	        case "subtitle-1":
	        case "subtitle-2":
	            return "h6";
	        case "body-1":
	        case "body-2":
	            return "p";
	        case "caption":
	            return "caption";
	        case "button":
	            return "button";
	        default:
	            return "span";
	    }
	}
	var block$f = bem("rmd-typography");
	/**
	 * The `Text` component is used to render text with the material design
	 * typography styles applied.  By default, everything will be rendered in a
	 * `<p>` tag with the normal paragraph styles.
	 *
	 * When the `type` prop is changed to another typography style, this component
	 * will determine the "best" element to render the text in *unless* the
	 * `component` prop is provided. The default mapping is:
	 *
	 * - `"headline-1" -> <h1>`
	 * - `"headline-2" -> <h2>`
	 * - `"headline-3" -> <h3>`
	 * - `"headline-4" -> <h4>`
	 * - `"headline-5" -> <h5>`
	 * - `"headline-6" -> <h6>`
	 * - `"subtitle-1" -> <h5>`
	 * - `"subtitle-2" -> <h6>`
	 * - `"body-1"     -> <p>`
	 * - `"body-2"     -> <p>`
	 * - `"caption"    -> <caption>`
	 * - `"overline"   -> <span>`
	 * - `"button"     -> <button>`
	 *
	 * NOTE: if the `component` prop is not `null`, this logic will be ignored and
	 * the provided `component` will be used instead.
	 */
	var Text = React.forwardRef(function Text(_a, ref) {
	    var _b;
	    var propClassName = _a.className, children = _a.children, _c = _a.type, type = _c === void 0 ? "body-1" : _c, _d = _a.component, component = _d === void 0 ? null : _d, align = _a.align, color = _a.color, decoration = _a.decoration, transform = _a.transform, weight = _a.weight, fontStyle = _a.fontStyle, _e = _a.margin, margin = _e === void 0 ? "initial" : _e, props = __rest$p(_a, ["className", "children", "type", "component", "align", "color", "decoration", "transform", "weight", "fontStyle", "margin"]);
	    var className = classnames(block$f((_b = {},
	        _b[type] = true,
	        _b["no-margin"] = margin === "none",
	        _b["no-margin-top"] = margin === "bottom",
	        _b["no-margin-bottom"] = margin === "top",
	        _b[align || ""] = align,
	        _b[decoration || ""] = decoration && decoration !== "overline",
	        _b[color || ""] = color,
	        // only because "overline" is technically one of the valid material design types :/
	        _b["overline-decoration"] = decoration === "overline",
	        _b[transform || ""] = transform,
	        _b[weight || ""] = weight,
	        _b[fontStyle || ""] = fontStyle,
	        _b)), propClassName);
	    if (typeof children === "function") {
	        return children({ className: className });
	    }
	    return React.createElement(getComponent(component, type), __assign$y(__assign$y({}, props), { className: className, ref: ref }), children);
	});
	{
	    try {
	        var PropTypes$r = require("prop-types");
	        Text.propTypes = {
	            className: PropTypes$r.string,
	            type: PropTypes$r.oneOf([
	                "headline-1",
	                "headline-2",
	                "headline-3",
	                "headline-4",
	                "headline-5",
	                "headline-6",
	                "subtitle-1",
	                "subtitle-2",
	                "body-1",
	                "body-2",
	                "caption",
	                "overline",
	                "button",
	            ]),
	            component: PropTypes$r.oneOfType([
	                PropTypes$r.string,
	                PropTypes$r.func,
	                PropTypes$r.object,
	            ]),
	            children: PropTypes$r.oneOfType([PropTypes$r.node, PropTypes$r.func]),
	            align: PropTypes$r.oneOf(["", "left", "center", "right"]),
	            decoration: PropTypes$r.oneOf(["underline", "overline", "line-through"]),
	            weight: PropTypes$r.oneOf([
	                "thin",
	                "light",
	                "regular",
	                "medium",
	                "bold",
	                "semi-bold",
	                "black",
	            ]),
	            transform: PropTypes$r.oneOf(["", "capitalize", "uppercase", "lowercase"]),
	            color: PropTypes$r.oneOf([
	                "secondary",
	                "hint",
	                "theme-primary",
	                "theme-secondary",
	                "theme-warning",
	                "theme-error",
	            ]),
	            margin: PropTypes$r.oneOf(["initial", "none", "top", "bottom"]),
	            fontStyle: PropTypes$r.oneOf(["normal", "italic", "oblique"]),
	        };
	    }
	    catch (e) { }
	}

	var __assign$z = (undefined && undefined.__assign) || function () {
	    __assign$z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$z.apply(this, arguments);
	};
	var __rest$q = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var TextContainer = React.forwardRef(function TextContainer(_a, ref) {
	    var propClassName = _a.className, _b = _a.component, Component = _b === void 0 ? "div" : _b, _c = _a.size, size = _c === void 0 ? "auto" : _c, children = _a.children, clone = _a.clone, props = __rest$q(_a, ["className", "component", "size", "children", "clone"]);
	    var className = classnames("rmd-text-container rmd-text-container--" + size, propClassName);
	    if (clone && React.isValidElement(children)) {
	        var child = React.Children.only(children);
	        return React.cloneElement(child, {
	            className: classnames(child.props.className, className),
	        });
	    }
	    if (typeof children === "function") {
	        return children({ className: className });
	    }
	    return (React__default.createElement(Component, __assign$z({}, props, { className: className, ref: ref }), children));
	});
	{
	    try {
	        var PropTypes$s = require("prop-types");
	        TextContainer.propTypes = {
	            className: PropTypes$s.string,
	            size: PropTypes$s.oneOf(["auto", "mobile", "desktop"]),
	            component: PropTypes$s.oneOfType([
	                PropTypes$s.string,
	                PropTypes$s.func,
	                PropTypes$s.object,
	            ]),
	            children: PropTypes$s.oneOfType([PropTypes$s.node, PropTypes$s.func]),
	            clone: PropTypes$s.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$A = (undefined && undefined.__assign) || function () {
	    __assign$A = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$A.apply(this, arguments);
	};
	var __rest$r = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$g = bem("rmd-sr-only");
	/**
	 * This component is used to create text that is only visible to screen readers.
	 * If you enable the `focusable` prop, the text will become visible to all users
	 * while focused.
	 */
	var SrOnly = React.forwardRef(function SrOnly(_a, ref) {
	    var className = _a.className, children = _a.children, _b = _a.focusable, focusable = _b === void 0 ? false : _b, propTabIndex = _a.tabIndex, _c = _a.component, component = _c === void 0 ? "span" : _c, props = __rest$r(_a, ["className", "children", "focusable", "tabIndex", "component"]);
	    var tabIndex = propTabIndex;
	    if (focusable && typeof tabIndex === "undefined") {
	        tabIndex = 0;
	    }
	    return (React__default.createElement(Text, __assign$A({}, props, { ref: ref, tabIndex: tabIndex, component: component, className: classnames(block$g({ focusable: focusable }), className) }), children));
	});
	{
	    try {
	        var PropTypes$t = require("prop-types");
	        SrOnly.propTypes = {
	            className: PropTypes$t.string,
	            children: PropTypes$t.node,
	            tabIndex: PropTypes$t.number,
	            focusable: PropTypes$t.bool,
	            component: PropTypes$t.oneOfType([
	                PropTypes$t.string,
	                PropTypes$t.func,
	                PropTypes$t.object,
	            ]),
	        };
	    }
	    catch (e) { }
	}

	var __assign$B = (undefined && undefined.__assign) || function () {
	    __assign$B = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$B.apply(this, arguments);
	};
	var __rest$s = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$h = bem("rmd-file-input");
	/**
	 * This component is a wrapper for the `<input type="file" />` that can be themed
	 * like a button.
	 */
	var FileInput = React.forwardRef(function FileInput(_a, ref) {
	    var style = _a.style, propClassName = _a.className, propIcon = _a.icon, _b = _a.iconAfter, iconAfter = _b === void 0 ? false : _b, _c = _a.children, children = _c === void 0 ? React__default.createElement(SrOnly, null, "Upload") : _c, _d = _a.theme, theme = _d === void 0 ? "primary" : _d, _e = _a.themeType, themeType = _e === void 0 ? "contained" : _e, _f = _a.buttonType, buttonType = _f === void 0 ? "icon" : _f, _g = _a.multiple, multiple = _g === void 0 ? false : _g, _h = _a.disableIconSpacing, disableIconSpacing = _h === void 0 ? false : _h, _j = _a.disableRepeatableFiles, disableRepeatableFiles = _j === void 0 ? false : _j, onKeyDown = _a.onKeyDown, onKeyUp = _a.onKeyUp, onMouseDown = _a.onMouseDown, onMouseUp = _a.onMouseUp, onMouseLeave = _a.onMouseLeave, onClick = _a.onClick, onTouchStart = _a.onTouchStart, onTouchMove = _a.onTouchMove, onTouchEnd = _a.onTouchEnd, onChange = _a.onChange, props = __rest$s(_a, ["style", "className", "icon", "iconAfter", "children", "theme", "themeType", "buttonType", "multiple", "disableIconSpacing", "disableRepeatableFiles", "onKeyDown", "onKeyUp", "onMouseDown", "onMouseUp", "onMouseLeave", "onClick", "onTouchStart", "onTouchMove", "onTouchEnd", "onChange"]);
	    var id = props.id, disabled = props.disabled;
	    var icon = useIcon("download", propIcon);
	    var _k = useInteractionStates({
	        handlers: {
	            onKeyDown: onKeyDown,
	            onKeyUp: onKeyUp,
	            onMouseDown: onMouseDown,
	            onMouseUp: onMouseUp,
	            onMouseLeave: onMouseLeave,
	            onClick: onClick,
	            onTouchStart: onTouchStart,
	            onTouchMove: onTouchMove,
	            onTouchEnd: onTouchEnd,
	        },
	        className: buttonThemeClassNames({
	            theme: theme,
	            themeType: themeType,
	            buttonType: buttonType,
	            disabled: disabled,
	            className: propClassName,
	        }),
	        // pressing enter or space would trigger two click events otherwise.
	        disableEnterClick: true,
	    }), ripples = _k.ripples, className = _k.className, handlers = _k.handlers;
	    var content = icon;
	    if (disableIconSpacing || (children && !icon)) {
	        content = (React__default.createElement(React__default.Fragment, null,
	            !iconAfter && icon,
	            children,
	            iconAfter && icon));
	    }
	    else if (children) {
	        content = (React__default.createElement(TextIconSpacing, { icon: icon, iconAfter: iconAfter }, children));
	    }
	    return (React__default.createElement(React__default.Fragment, null,
	        React__default.createElement("input", __assign$B({}, props, handlers, { ref: ref, onChange: onChange, value: disableRepeatableFiles ? undefined : "", type: "file", className: block$h(), multiple: multiple })),
	        React__default.createElement("label", { htmlFor: id, style: style, className: classnames("rmd-file-input-label", className) },
	            content,
	            ripples)));
	});
	{
	    try {
	        var PropTypes$u = require("prop-types");
	        FileInput.propTypes = {
	            id: PropTypes$u.string.isRequired,
	            style: PropTypes$u.object,
	            className: PropTypes$u.string,
	            name: PropTypes$u.string,
	            onChange: PropTypes$u.func.isRequired,
	            icon: PropTypes$u.node,
	            iconAfter: PropTypes$u.bool,
	            multiple: PropTypes$u.bool,
	            disableIconSpacing: PropTypes$u.bool,
	            disableRepeatableFiles: PropTypes$u.bool,
	            theme: PropTypes$u.oneOf([
	                "clear",
	                "primary",
	                "secondary",
	                "warning",
	                "error",
	            ]),
	            themeType: PropTypes$u.oneOf(["flat", "outline", "contained"]),
	            buttonType: PropTypes$u.oneOf(["text", "icon"]),
	            disabled: PropTypes$u.bool,
	            children: PropTypes$u.node,
	            onKeyDown: PropTypes$u.func,
	            onKeyUp: PropTypes$u.func,
	            onMouseDown: PropTypes$u.func,
	            onMouseUp: PropTypes$u.func,
	            onMouseLeave: PropTypes$u.func,
	            onClick: PropTypes$u.func,
	            onTouchStart: PropTypes$u.func,
	            onTouchMove: PropTypes$u.func,
	            onTouchEnd: PropTypes$u.func,
	        };
	    }
	    catch (e) { }
	}

	var __assign$C = (undefined && undefined.__assign) || function () {
	    __assign$C = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$C.apply(this, arguments);
	};
	var __rest$t = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$i = bem("rmd-label");
	/**
	 * The `Label` component should be used alongside any form elements but is
	 * already built in to the majority of the `react-md` components by default.
	 */
	var Label = React.forwardRef(function Label(_a, ref) {
	    var htmlFor = _a.htmlFor, className = _a.className, _b = _a.error, error = _b === void 0 ? false : _b, _c = _a.active, active = _c === void 0 ? false : _c, _d = _a.disabled, disabled = _d === void 0 ? false : _d, _e = _a.component, Component = _e === void 0 ? "label" : _e, children = _a.children, props = __rest$t(_a, ["htmlFor", "className", "error", "active", "disabled", "component", "children"]);
	    if (!children) {
	        return null;
	    }
	    return (React__default.createElement(Component, __assign$C({}, props, { ref: ref, className: classnames(block$i({
	            error: error,
	            active: active,
	            disabled: disabled,
	        }), className), htmlFor: Component === "label" ? htmlFor : undefined }), children));
	});
	{
	    try {
	        var PropTypes$v = require("prop-types");
	        Label.propTypes = {
	            htmlFor: PropTypes$v.string.isRequired,
	            className: PropTypes$v.string,
	            error: PropTypes$v.bool,
	            active: PropTypes$v.bool,
	            disabled: PropTypes$v.bool,
	            component: PropTypes$v.oneOf(["label", "span"]),
	            children: PropTypes$v.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$D = (undefined && undefined.__assign) || function () {
	    __assign$D = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$D.apply(this, arguments);
	};
	var __rest$u = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$j = bem("rmd-floating-label");
	/**
	 * This is an extension of the `Label` component that is used with text fields
	 * and textareas to float above the input area.
	 */
	var FloatingLabel = React.forwardRef(function FloatingLabel(_a, ref) {
	    var className = _a.className, dense = _a.dense, valued = _a.valued, floating = _a.floating, _b = _a.error, error = _b === void 0 ? false : _b, _c = _a.active, active = _c === void 0 ? false : _c, _d = _a.disabled, disabled = _d === void 0 ? false : _d, props = __rest$u(_a, ["className", "dense", "valued", "floating", "error", "active", "disabled"]);
	    return (React__default.createElement(Label, __assign$D({}, props, { ref: ref, className: classnames(block$j({
	            dense: dense,
	            active: floating,
	            inactive: valued && !active && !error && !disabled,
	        }), className), error: error, active: active, disabled: disabled })));
	});
	{
	    try {
	        var PropTypes$w = require("prop-types");
	        FloatingLabel.propTypes = {
	            className: PropTypes$w.string,
	            dense: PropTypes$w.bool,
	            floating: PropTypes$w.bool,
	            error: PropTypes$w.bool,
	            active: PropTypes$w.bool,
	            disabled: PropTypes$w.bool,
	            valued: PropTypes$w.bool.isRequired,
	        };
	    }
	    catch (e) { }
	}

	var __assign$E = (undefined && undefined.__assign) || function () {
	    __assign$E = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$E.apply(this, arguments);
	};
	var __rest$v = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$k = bem("rmd-text-field-addon");
	/**
	 * This component is used to add an an icon before or after the text field with
	 * correct styling.
	 */
	var TextFieldAddon = React.forwardRef(function TextFieldAddon(_a, ref) {
	    var children = _a.children, className = _a.className, _b = _a.presentational, presentational = _b === void 0 ? true : _b, props = __rest$v(_a, ["children", "className", "presentational"]);
	    if (!children) {
	        return null;
	    }
	    return (React__default.createElement("span", __assign$E({}, props, { ref: ref, className: classnames(block$k({ presentational: presentational }), className) }), children));
	});
	{
	    try {
	        var PropTypes$x = require("prop-types");
	        TextFieldAddon.propTypes = {
	            className: PropTypes$x.string,
	            children: PropTypes$x.node,
	            presentational: PropTypes$x.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$F = (undefined && undefined.__assign) || function () {
	    __assign$F = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$F.apply(this, arguments);
	};
	var __rest$w = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$l = bem("rmd-text-field-container");
	/**
	 * This is a container component that is used to structure the text field with
	 * different parts and themes.
	 */
	var TextFieldContainer = React.forwardRef(function TextFieldContainer(_a, ref) {
	    var _b;
	    var className = _a.className, children = _a.children, _c = _a.inline, inline = _c === void 0 ? false : _c, propTheme = _a.theme, _d = _a.error, error = _d === void 0 ? false : _d, active = _a.active, label = _a.label, _e = _a.dense, dense = _e === void 0 ? false : _e, _f = _a.disabled, disabled = _f === void 0 ? false : _f, _g = _a.isLeftAddon, isLeftAddon = _g === void 0 ? true : _g, _h = _a.isRightAddon, isRightAddon = _h === void 0 ? true : _h, leftChildren = _a.leftChildren, rightChildren = _a.rightChildren, propUnderlineDirection = _a.underlineDirection, props = __rest$w(_a, ["className", "children", "inline", "theme", "error", "active", "label", "dense", "disabled", "isLeftAddon", "isRightAddon", "leftChildren", "rightChildren", "underlineDirection"]);
	    var _j = useFormTheme({
	        theme: propTheme,
	        underlineDirection: propUnderlineDirection,
	    }), theme = _j.theme, underlineDirection = _j.underlineDirection;
	    var underline = theme === "underline";
	    var outline = theme === "outline";
	    var filled = theme === "filled";
	    var isUnderlined = underline || filled;
	    var isOutlineActive = outline && active;
	    return (React__default.createElement("div", __assign$F({}, props, { ref: ref, className: classnames(block$l((_b = {
	                error: error,
	                inline: inline,
	                filled: filled,
	                outline: outline,
	                disabled: disabled,
	                hoverable: !disabled && !isOutlineActive,
	                label: label && !dense,
	                dense: !label && dense,
	                "dense-label": dense && label,
	                "dense-placeholder": dense && isUnderlined && !label,
	                "outline-active": isOutlineActive,
	                "outline-error": outline && error,
	                "outline-left": outline && leftChildren,
	                "outline-right": outline && rightChildren,
	                underline: isUnderlined,
	                "underline-labelled": label && isUnderlined,
	                "underline-active": isUnderlined && active
	            },
	            _b["underline-" + underlineDirection] = isUnderlined,
	            _b["underline-left-addon"] = isUnderlined && leftChildren,
	            _b["underline-right-addon"] = isUnderlined && rightChildren,
	            _b)), className) }),
	        isLeftAddon ? (React__default.createElement(TextFieldAddon, null, leftChildren)) : (leftChildren),
	        children,
	        isRightAddon ? (React__default.createElement(TextFieldAddon, null, rightChildren)) : (rightChildren)));
	});
	{
	    try {
	        var PropTypes$y = require("prop-types");
	        TextFieldContainer.propTypes = {
	            className: PropTypes$y.string,
	            disabled: PropTypes$y.bool,
	            inline: PropTypes$y.bool,
	            theme: PropTypes$y.oneOf(["none", "underline", "outline", "filled"]),
	            active: PropTypes$y.bool,
	            error: PropTypes$y.bool,
	            underlineDirection: PropTypes$y.oneOf(["left", "center", "right"]),
	            isLeftAddon: PropTypes$y.bool,
	            isRightAddon: PropTypes$y.bool,
	            leftChildren: PropTypes$y.node,
	            rightChildren: PropTypes$y.node,
	            label: PropTypes$y.bool,
	            dense: PropTypes$y.bool,
	            children: PropTypes$y.node,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * This is a small hook that will enable a valued flag when the value
	 * of a text input or a textarea has a length greater than 0.
	 *
	 * @private
	 */
	function useValuedState(_a) {
	    var onChange = _a.onChange, value = _a.value, defaultValue = _a.defaultValue;
	    var handler = useRefCache(onChange);
	    var _b = useToggle(function () {
	        if (typeof value === "undefined") {
	            return (typeof defaultValue === "number" || (defaultValue || "").length > 0);
	        }
	        // this isn't used for controlled components
	        return false;
	    }), valued = _b[0], enable = _b[1], disable = _b[2];
	    var handleChange = React.useCallback(function (event) {
	        var onChange = handler.current;
	        if (onChange) {
	            onChange(event);
	        }
	        if (event.currentTarget.value.length > 0) {
	            enable();
	        }
	        else {
	            disable();
	        }
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [enable, disable]);
	    if (typeof value !== "undefined") {
	        var isValued = typeof value === "number" || value.length > 0;
	        return [isValued, onChange];
	    }
	    return [valued, handleChange];
	}

	/**
	 * @private
	 */
	function useFocusState(_a) {
	    var onFocus = _a.onFocus, onBlur = _a.onBlur;
	    var _b = useToggle(false), focused = _b[0], setFocused = _b[1], setBlurred = _b[2];
	    var handleFocus = React.useCallback(function (event) {
	        if (onFocus) {
	            onFocus(event);
	        }
	        setFocused();
	    }, [setFocused, onFocus]);
	    var handleBlur = React.useCallback(function (event) {
	        if (onBlur) {
	            onBlur(event);
	        }
	        setBlurred();
	    }, [setBlurred, onBlur]);
	    return [focused, handleFocus, handleBlur];
	}

	var __assign$G = (undefined && undefined.__assign) || function () {
	    __assign$G = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$G.apply(this, arguments);
	};
	var __rest$x = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$m = bem("rmd-native-select");
	var container = bem("rmd-native-select-container");
	/**
	 * This component is used to render a native `<select>` element with the text
	 * field theme styles. This component is great to use for native behavior and
	 * full accessibility.
	 */
	var NativeSelect = React.forwardRef(function NativeSelect(_a, ref) {
	    var style = _a.style, className = _a.className, labelStyle = _a.labelStyle, labelClassName = _a.labelClassName, selectStyle = _a.selectStyle, selectClassName = _a.selectClassName, propIcon = _a.icon, propTheme = _a.theme, _b = _a.dense, dense = _b === void 0 ? false : _b, _c = _a.inline, inline = _c === void 0 ? false : _c, _d = _a.error, error = _d === void 0 ? false : _d, _e = _a.disabled, disabled = _e === void 0 ? false : _e, label = _a.label, propOnBlur = _a.onBlur, propOnFocus = _a.onFocus, propOnChange = _a.onChange, containerRef = _a.containerRef, isLeftAddon = _a.isLeftAddon, isRightAddon = _a.isRightAddon, leftChildren = _a.leftChildren, rightChildren = _a.rightChildren, propUnderlineDirection = _a.underlineDirection, children = _a.children, props = __rest$x(_a, ["style", "className", "labelStyle", "labelClassName", "selectStyle", "selectClassName", "icon", "theme", "dense", "inline", "error", "disabled", "label", "onBlur", "onFocus", "onChange", "containerRef", "isLeftAddon", "isRightAddon", "leftChildren", "rightChildren", "underlineDirection", "children"]);
	    var id = props.id, value = props.value, defaultValue = props.defaultValue, multiple = props.multiple;
	    var _f = useFormTheme({
	        theme: propTheme,
	        underlineDirection: propUnderlineDirection,
	    }), theme = _f.theme, underlineDirection = _f.underlineDirection;
	    var underline = theme === "underline" || theme === "filled";
	    var icon = useIcon("dropdown", propIcon);
	    var _g = useFocusState({
	        onBlur: propOnBlur,
	        onFocus: propOnFocus,
	    }), focused = _g[0], onFocus = _g[1], onBlur = _g[2];
	    var _h = useValuedState({
	        value: value,
	        defaultValue: defaultValue,
	        onChange: propOnChange,
	    }), valued = _h[0], onChange = _h[1];
	    return (React__default.createElement(TextFieldContainer, { style: style, className: classnames(container({
	            multi: multiple,
	            padded: multiple && label,
	        }), className), ref: containerRef, theme: theme, error: error, active: focused, label: !!label, dense: dense, inline: inline, disabled: disabled, isLeftAddon: isLeftAddon, isRightAddon: isRightAddon, leftChildren: leftChildren, rightChildren: multiple && rightChildren, underlineDirection: underlineDirection },
	        React__default.createElement(FloatingLabel, { style: labelStyle, className: classnames(block$m("label"), labelClassName), htmlFor: id, error: error, active: valued && focused, valued: valued, floating: valued || multiple, dense: dense, disabled: disabled }, label),
	        React__default.createElement("select", __assign$G({}, props, { ref: ref, style: selectStyle, className: classnames(block$m({
	                icon: icon,
	                multi: multiple,
	                "label-underline": label && underline,
	                "placeholder-underline": !label && underline,
	                floating: label && theme !== "none",
	            }), selectClassName), disabled: disabled, onFocus: onFocus, onBlur: onBlur, onChange: onChange }), children),
	        !multiple && icon && React__default.createElement("span", { className: block$m("icon") }, icon)));
	});
	{
	    try {
	        var PropTypes$z = require("prop-types");
	        NativeSelect.propTypes = {
	            id: PropTypes$z.string.isRequired,
	            style: PropTypes$z.object,
	            className: PropTypes$z.string,
	            labelStyle: PropTypes$z.object,
	            labelClassName: PropTypes$z.string,
	            selectStyle: PropTypes$z.object,
	            selectClassName: PropTypes$z.string,
	            icon: PropTypes$z.node,
	            value: PropTypes$z.string,
	            defaultValue: PropTypes$z.oneOfType([
	                PropTypes$z.string,
	                PropTypes$z.arrayOf(PropTypes$z.string),
	            ]),
	            theme: PropTypes$z.oneOf(["none", "underline", "filled", "outline"]),
	            dense: PropTypes$z.bool,
	            error: PropTypes$z.bool,
	            inline: PropTypes$z.bool,
	            disabled: PropTypes$z.bool,
	            underlineDirection: PropTypes$z.oneOf(["left", "center", "right"]),
	            isLeftAddon: PropTypes$z.bool,
	            leftChildren: PropTypes$z.node,
	            rightChildren: PropTypes$z.node,
	            isRightAddon: PropTypes$z.bool,
	            multiple: PropTypes$z.bool,
	            size: PropTypes$z.number,
	            children: PropTypes$z.node,
	            label: PropTypes$z.node,
	            onBlur: PropTypes$z.func,
	            onFocus: PropTypes$z.func,
	            onChange: PropTypes$z.func,
	            containerRef: PropTypes$z.oneOfType([PropTypes$z.func, PropTypes$z.object]),
	        };
	    }
	    catch (e) { }
	}

	var ENTER = "enter";
	var ENTERING$1 = "entering";
	var ENTERED$2 = "entered";
	var EXIT = "exit";
	var EXITING$1 = "exiting";
	var EXITED$1 = "exited";
	var UNMOUNT = "unmount";
	var COLLAPSE_TIMEOUT = {
	    enter: 250,
	    exit: 200,
	};
	var DEFAULT_COLLAPSE_MIN_HEIGHT = 0;
	var DEFAULT_COLLAPSE_MIN_PADDING_TOP = 0;
	var DEFAULT_COLLAPSE_MIN_PADDING_BOTTOM = 0;
	var CROSS_FADE_TIMEOUT = {
	    enter: 300,
	    exit: 0,
	};
	var CROSS_FADE_CLASSNAMES = {
	    appear: "rmd-cross-fade",
	    appearActive: "rmd-cross-fade--active",
	    enter: "rmd-cross-fade",
	    enterActive: "rmd-cross-fade--active",
	};
	var SCALE_CLASSNAMES = {
	    appear: "rmd-transition--scale-enter",
	    appearActive: "rmd-transition--scale-enter-active",
	    enter: "rmd-transition--scale-enter",
	    enterActive: "rmd-transition--scale-enter-active",
	    enterDone: "",
	    exit: "rmd-transition--scale-exit",
	    exitActive: "rmd-transition--scale-exit-active",
	};
	var SCALE_Y_CLASSNAMES = {
	    appear: "rmd-transition--scale-y-enter",
	    appearActive: "rmd-transition--scale-y-enter-active",
	    enter: "rmd-transition--scale-y-enter",
	    enterActive: "rmd-transition--scale-y-enter-active",
	    enterDone: "",
	    exit: "rmd-transition--scale-y-exit",
	    exitActive: "rmd-transition--scale-y-exit-active",
	};
	var SCALE_TIMEOUT = {
	    enter: 200,
	    exit: 150,
	};

	/**
	 * A small util that will find the max-height, padding-top, and padding-bottom
	 * for the provided element. This is really used to be able to transition the
	 * max-height value since `max-height: auto` does not transition. The only way
	 * to get transition is to change max-height values manually.
	 *
	 * @private
	 */
	function getElementSizing(element) {
	    var maxHeight;
	    var paddingTop;
	    var paddingBottom;
	    if (element) {
	        maxHeight = element.scrollHeight;
	        // clone the element (not deep) just to figure out it's padding without the
	        // inline styles applied
	        var cloned = element.cloneNode(false);
	        cloned.style.maxHeight = "";
	        cloned.style.padding = "";
	        cloned.style.paddingLeft = element.style.paddingLeft;
	        cloned.style.paddingRight = element.style.paddingRight;
	        cloned.style.visibility = "hidden";
	        var container = element.parentElement || document.body;
	        container.appendChild(cloned);
	        var style = window.getComputedStyle(cloned);
	        if (style.paddingTop) {
	            paddingTop = parseFloat(style.paddingTop);
	        }
	        if (style.paddingBottom) {
	            paddingBottom = parseFloat(style.paddingBottom);
	        }
	        container.removeChild(cloned);
	    }
	    return { maxHeight: maxHeight, paddingTop: paddingTop, paddingBottom: paddingBottom };
	}

	var error = function (part) {
	    throw new RangeError("Minimum " + (part ? part + " " : "") + "timeout allowed is 0");
	};
	/**
	 * @private
	 */
	function getTimeout(timeout, appear) {
	    var _a, _b, _c;
	    if (typeof timeout === "number") {
	        if (timeout < 0) {
	            error();
	        }
	        return {
	            appear: appear ? timeout : 0,
	            enter: timeout,
	            exit: timeout,
	        };
	    }
	    var appearTime = (_a = timeout.appear) !== null && _a !== void 0 ? _a : ((appear && timeout.enter) || 0);
	    var enter = (_b = timeout.enter) !== null && _b !== void 0 ? _b : 0;
	    var exit = (_c = timeout.exit) !== null && _c !== void 0 ? _c : 0;
	    if (appearTime < 0 && typeof timeout.appear === "number") {
	        error("appear");
	    }
	    if (enter < 0) {
	        error("enter");
	    }
	    if (exit < 0) {
	        error("exit");
	    }
	    return {
	        appear: appearTime,
	        enter: enter,
	        exit: exit,
	    };
	}

	/**
	 *
	 * @private
	 */
	function getNextStage(stage) {
	    switch (stage) {
	        case ENTER:
	            return ENTERING$1;
	        case ENTERING$1:
	            return ENTERED$2;
	        case EXIT:
	            return EXITING$1;
	        case EXITING$1:
	            return EXITED$1;
	        default:
	            return stage;
	    }
	}

	/**
	 * Gets the `window.setTimeout` duration that should be used for a given stage.
	 * This will return `0` for all stagees except for `ENTERING` and `EXITING`.
	 *
	 * @private
	 */
	function getTimeoutDuration(stage, appear, enter, exit, appearing) {
	    if (stage === ENTERING$1) {
	        return appearing ? appear : enter;
	    }
	    if (stage === EXITING$1) {
	        return exit;
	    }
	    return 0;
	}

	var __assign$H = (undefined && undefined.__assign) || function () {
	    __assign$H = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$H.apply(this, arguments);
	};
	/**
	 *
	 * @private
	 */
	var reducer$2 = function (state, action) {
	    switch (action) {
	        case ENTER:
	        case ENTERING$1:
	        case EXIT:
	        case EXITING$1:
	        case EXITED$1:
	            return __assign$H(__assign$H({}, state), { rendered: true, stage: action });
	        case ENTERED$2:
	            return { rendered: true, stage: action, appearing: false };
	        case UNMOUNT:
	            return { stage: EXITED$1, rendered: false, appearing: false };
	        default:
	            return state;
	    }
	};
	/**
	 *
	 * @private
	 */
	var INITIAL_STATE = {
	    appearing: false,
	    rendered: true,
	    stage: ENTERED$2,
	};
	/**
	 *
	 * @private
	 */
	var getInitialState = function (transitionIn, temporary, appear) { return function () {
	    return {
	        rendered: !temporary || transitionIn,
	        appearing: appear && transitionIn,
	        stage: transitionIn && !appear ? ENTERED$2 : EXITED$1,
	    };
	}; };
	/**
	 * This is heavily inspired by the `Transition` component from
	 * `react-transition-group` since it's really just a hook version of it.
	 *
	 * This hook allows you to transition between an enter and exit state with
	 * defined timeouts, but you'll most likely be looking for the
	 * `useCSSTransition` instead.
	 *
	 * @param options All the options used for the transition.
	 * @return An object describing the current transition stage and props that
	 * should be passed to a component.
	 */
	function useTransition(_a) {
	    var _b = _a.appear, appear = _b === void 0 ? false : _b, _c = _a.repaint, repaint = _c === void 0 ? false : _c, _d = _a.temporary, temporary = _d === void 0 ? false : _d, transitionIn = _a.transitionIn, propTimeout = _a.timeout, onEnter = _a.onEnter, onEntering = _a.onEntering, onEntered = _a.onEntered, onExit = _a.onExit, onExiting = _a.onExiting, onExited = _a.onExited, ref = _a.ref;
	    var _e = React.useReducer(reducer$2, INITIAL_STATE, getInitialState(transitionIn, temporary, appear)), _f = _e[0], stage = _f.stage, rendered = _f.rendered, appearing = _f.appearing, dispatch = _e[1];
	    // need to store in mutable ref since these are mostly going to be arrow functions
	    // and shouldn't cause the transitions to change
	    var handlers = React.useRef({
	        onEnter: onEnter,
	        onEntering: onEntering,
	        onEntered: onEntered,
	        onExit: onExit,
	        onExiting: onExiting,
	        onExited: onExited,
	    });
	    React.useEffect(function () {
	        handlers.current = {
	            onEnter: onEnter,
	            onEntering: onEntering,
	            onEntered: onEntered,
	            onExit: onExit,
	            onExiting: onExiting,
	            onExited: onExited,
	        };
	    });
	    var timeout = getTimeout(propTimeout, appear);
	    var nodeRef = React.useRef(null);
	    var disableEnterExitTransition = React.useRef(!appear || !transitionIn);
	    // this effect handles the transition from:
	    // - EXITED -> ENTER
	    // - ENTERED -> EXIT
	    // - EXITED -> ENTERED (when enter timeout is 0)
	    // - ENTERED -> EXITED (when exit timeout is 0)
	    //
	    // all the dependencies are ignored except for `transitionIn` since the
	    // other values changing would actually cause more bugs and this effect
	    // really doesn't care if they changed.
	    React.useEffect(function () {
	        // should never trigger a transition on mount unless both the `appear` and
	        // `transitionIn` are enabled for the appear transition
	        if (disableEnterExitTransition.current) {
	            disableEnterExitTransition.current = false;
	            return;
	        }
	        var duration = 0;
	        if (transitionIn) {
	            duration = appearing ? timeout.appear : timeout.enter;
	        }
	        else {
	            duration = timeout.exit;
	        }
	        if (duration > 0) {
	            dispatch(transitionIn ? ENTER : EXIT);
	        }
	        else {
	            dispatch(transitionIn ? ENTERED$2 : EXITED$1);
	        }
	        // see comment above about why it's only `transitionIn`
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [transitionIn]);
	    var isFirstRender = React.useRef(true);
	    // this effect handles the transitions for:
	    // - ENTER -> ENTERING
	    // - ENTERING -> ENTERED
	    // - EXIT -> EXITING
	    // - EXITING -> EXIT
	    React.useEffect(function () {
	        // need to skip the effects on first render since it should only be called
	        // after a transition change
	        if (isFirstRender.current) {
	            isFirstRender.current = false;
	            return;
	        }
	        var node = nodeRef.current;
	        if (node) {
	            if (repaint && stage !== EXITED$1 && stage !== ENTERED$2) {
	                // force repaint for CSS transitions
	                // eslint-disable-next-line no-unused-expressions
	                node.scrollTop;
	            }
	            var _a = handlers.current, onEnter_1 = _a.onEnter, onEntering_1 = _a.onEntering, onEntered_1 = _a.onEntered, onExit_1 = _a.onExit, onExiting_1 = _a.onExiting, onExited_1 = _a.onExited;
	            switch (stage) {
	                case ENTER:
	                    if (onEnter_1) {
	                        onEnter_1(node, appearing);
	                    }
	                    break;
	                case ENTERING$1:
	                    if (onEntering_1) {
	                        onEntering_1(node, appearing);
	                    }
	                    break;
	                case ENTERED$2:
	                    if (onEntered_1) {
	                        onEntered_1(node, appearing);
	                    }
	                    break;
	                case EXIT:
	                    if (onExit_1) {
	                        onExit_1(node);
	                    }
	                    break;
	                case EXITING$1:
	                    if (onExiting_1) {
	                        onExiting_1(node);
	                    }
	                    break;
	                case EXITED$1:
	                    if (onExited_1) {
	                        onExited_1(node);
	                    }
	                    break;
	                // no default
	            }
	        }
	        var nextStage = getNextStage(stage);
	        if (stage === nextStage) {
	            if (stage === EXITED$1 && temporary) {
	                dispatch(UNMOUNT);
	            }
	            return;
	        }
	        var duration = getTimeoutDuration(stage, timeout.appear, timeout.enter, timeout.exit, appearing);
	        if (duration <= 0) {
	            dispatch(nextStage);
	            return;
	        }
	        var dispatchTimeout = window.setTimeout(function () {
	            dispatch(nextStage);
	        }, duration);
	        return function () {
	            window.clearTimeout(dispatchTimeout);
	        };
	    }, [
	        appearing,
	        repaint,
	        stage,
	        temporary,
	        timeout.appear,
	        timeout.enter,
	        timeout.exit,
	    ]);
	    var refHandler = React.useCallback(function (instance) {
	        applyRef(instance, ref);
	        nodeRef.current = instance;
	    }, [ref]);
	    return {
	        ref: refHandler,
	        stage: stage,
	        rendered: rendered,
	        appearing: appearing,
	        dispatch: dispatch,
	    };
	}

	/**
	 * The `useCollapse` hook is used to transition a child element in and
	 * out of view by animating it's `max-height`. This means that the child
	 * must either be an HTMLElement or a component that forwards the `ref`
	 * to an HTMLElement and applies the `style`, `className`, and `hidden`
	 * props to an HTMLElement.
	 *
	 * Simple Example:
	 *
	 * ```tsx
	 * const Example = () => {
	 *   const [collapsed, setCollapsed] = useState(true);
	 *   const [rendered, transitionProps] = useCollapse(collapsed);
	 *
	 *   return (
	 *     <>
	 *       <Button onClick={() => setCollapsed(!collapsed)}>Toggle</Button>
	 *       {rendered && (
	 *         <div {...transitionProps}>
	 *          <Text>Stuff that should be animated</Text>
	 *          <div>Whatever content...</div>
	 *         </div>
	 *       )}
	 *     </>
	 *   );
	 * }
	 * ```
	 *
	 * Note: This **should not be used for `position: absolute` or `position: fixed`
	 * elements**. Instead, the `ScaleTransition` or just a simple `transform`
	 * transition should be used instead. Animating `max-height`, `padding-top`, and
	 * `padding-bottom` is much less performant than `transform` transition since it
	 * forces the DOM to repaint during the
	 *
	 * @param collapsed Boolean if the element is currently collapsed. Changing this
	 * value will cause the animation to trigger.
	 * @param options All the additional options available for the collapse
	 * transition.
	 * @return An ordered list containing a boolean if the collapse should be
	 * rendered in the DOM followed by an object of props to pass to the collapsible
	 * element to handle the transition.
	 */
	function useCollapse(collapsed, _a) {
	    var _b = _a === void 0 ? {} : _a, className = _b.className, _c = _b.appear, appear = _c === void 0 ? false : _c, _d = _b.timeout, timeout = _d === void 0 ? COLLAPSE_TIMEOUT : _d, onEnter = _b.onEnter, onEntering = _b.onEntering, onEntered = _b.onEntered, onExit = _b.onExit, onExiting = _b.onExiting, onExited = _b.onExited, _e = _b.minHeight, minHeight = _e === void 0 ? DEFAULT_COLLAPSE_MIN_HEIGHT : _e, _f = _b.minPaddingTop, minPaddingTop = _f === void 0 ? DEFAULT_COLLAPSE_MIN_PADDING_TOP : _f, _g = _b.minPaddingBottom, minPaddingBottom = _g === void 0 ? DEFAULT_COLLAPSE_MIN_PADDING_BOTTOM : _g, _h = _b.temporary, temporary = _h === void 0 ? minHeight === 0 &&
	        minPaddingTop === 0 &&
	        minPaddingBottom === 0 : _h;
	    var _j = React.useState(function () {
	        if (!collapsed) {
	            return undefined;
	        }
	        return {
	            maxHeight: minHeight,
	            paddingTop: minPaddingTop,
	            paddingBottom: minPaddingBottom,
	        };
	    }), style = _j[0], setStyle = _j[1];
	    var _k = useTransition({
	        appear: appear,
	        repaint: true,
	        timeout: timeout,
	        temporary: temporary,
	        transitionIn: !collapsed,
	        onEnter: function (node, isAppearing) {
	            if (onEnter) {
	                onEnter(node, isAppearing);
	            }
	            setStyle({
	                maxHeight: minHeight,
	                paddingTop: minPaddingTop,
	                paddingBottom: minPaddingBottom,
	            });
	        },
	        onEntering: function (node, isAppearing) {
	            if (onEntering) {
	                onEntering(node, isAppearing);
	            }
	            var _a = getElementSizing(node), maxHeight = _a.maxHeight, paddingTop = _a.paddingTop, paddingBottom = _a.paddingBottom;
	            var defaultedTimeout = getTimeout(timeout, isAppearing);
	            var duration = isAppearing
	                ? defaultedTimeout.appear
	                : defaultedTimeout.enter;
	            setStyle({
	                maxHeight: maxHeight,
	                paddingTop: paddingTop,
	                paddingBottom: paddingBottom,
	                transitionDuration: duration + "ms",
	            });
	        },
	        onEntered: function (node, isAppearing) {
	            if (onEntered) {
	                onEntered(node, isAppearing);
	            }
	            setStyle(undefined);
	        },
	        onExit: function (node) {
	            if (onExit) {
	                onExit(node);
	            }
	            var _a = getElementSizing(node), maxHeight = _a.maxHeight, paddingTop = _a.paddingTop, paddingBottom = _a.paddingBottom;
	            setStyle({
	                maxHeight: maxHeight,
	                paddingTop: paddingTop,
	                paddingBottom: paddingBottom,
	                transitionDuration: getTimeout(timeout, false).exit + "ms",
	            });
	        },
	        onExiting: function (node) {
	            if (onExiting) {
	                onExiting(node);
	            }
	            setStyle({
	                maxHeight: minHeight,
	                paddingTop: minPaddingTop,
	                paddingBottom: minPaddingBottom,
	                transitionDuration: getTimeout(timeout, false).exit + "ms",
	            });
	        },
	        onExited: function (node) {
	            if (onExited) {
	                onExited(node);
	            }
	            setStyle({
	                maxHeight: minHeight,
	                paddingTop: minPaddingTop,
	                paddingBottom: minPaddingBottom,
	            });
	        },
	    }), rendered = _k.rendered, stage = _k.stage, ref = _k.ref;
	    var entering = stage === ENTER || stage === ENTERING$1;
	    var exiting = stage === EXIT || stage === EXITING$1;
	    var collapsable = React.useMemo(function () { return Object.values(getTimeout(timeout, false)).some(function (v) { return v !== 0; }); }, [timeout]);
	    var hidden = collapsed &&
	        rendered &&
	        stage === EXITED$1 &&
	        !temporary &&
	        minHeight === 0 &&
	        minPaddingTop === 0 &&
	        minPaddingBottom === 0;
	    return [
	        rendered,
	        {
	            ref: ref,
	            hidden: hidden,
	            style: style,
	            className: classnames({
	                "rmd-collapse": collapsable,
	                "rmd-collapse--enter": entering,
	                "rmd-collapse--leave": exiting,
	                "rmd-collapse--no-overflow": collapsed || style,
	            }, className),
	        },
	    ];
	}

	var __assign$I = (undefined && undefined.__assign) || function () {
	    __assign$I = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$I.apply(this, arguments);
	};
	/**
	 * The `Collapse` component is used to transition a child element in and
	 * out of view by animating it's `max-height`. This means that the child must
	 * either be an HTMLElement or a component that forwards the `ref` to an
	 * HTMLElement and applies the `style`, `className`, and `hidden` props to an
	 * HTMLElement.
	 *
	 * Note: This component **should not be used for `position: absolute` or
	 * `position: fixed` elements**. Instead, the `ScaleTransition` or just a simple
	 * `transform` transition should be used instead. Animating `max-height`,
	 * `padding-top`, and `padding-bottom` is much less performant than `transform`
	 * transition since it forces DOM repaints.
	 */
	function Collapse(_a) {
	    var children = _a.children, collapsed = _a.collapsed, className = _a.className, _b = _a.appear, appear = _b === void 0 ? false : _b, _c = _a.timeout, timeout = _c === void 0 ? COLLAPSE_TIMEOUT : _c, onEnter = _a.onEnter, onEntering = _a.onEntering, onEntered = _a.onEntered, onExit = _a.onExit, onExiting = _a.onExiting, onExited = _a.onExited, _d = _a.minHeight, minHeight = _d === void 0 ? DEFAULT_COLLAPSE_MIN_HEIGHT : _d, _e = _a.minPaddingTop, minPaddingTop = _e === void 0 ? DEFAULT_COLLAPSE_MIN_PADDING_TOP : _e, _f = _a.minPaddingBottom, minPaddingBottom = _f === void 0 ? DEFAULT_COLLAPSE_MIN_PADDING_BOTTOM : _f, _g = _a.temporary, temporary = _g === void 0 ? minHeight === 0 && minPaddingTop === 0 && minPaddingBottom === 0 : _g;
	    var _h = useCollapse(collapsed, {
	        appear: appear,
	        temporary: temporary,
	        className: className,
	        timeout: timeout,
	        onEnter: onEnter,
	        onEntering: onEntering,
	        onEntered: onEntered,
	        onExit: onExit,
	        onExiting: onExiting,
	        onExited: onExited,
	        minHeight: minHeight,
	        minPaddingBottom: minPaddingBottom,
	        minPaddingTop: minPaddingTop,
	    }), rendered = _h[0], transitionProps = _h[1];
	    if (!rendered) {
	        return null;
	    }
	    var child = React.Children.only(children);
	    var transitionStyle = transitionProps.style;
	    var childStyle = child.props.style;
	    return React.cloneElement(child, __assign$I(__assign$I({}, transitionProps), { style: transitionStyle ? __assign$I(__assign$I({}, transitionStyle), childStyle) : childStyle, className: classnames(transitionProps.className, child.props.className) }));
	}
	{
	    try {
	        var PropTypes$A = require("prop-types");
	        Collapse.propTypes = {
	            style: PropTypes$A.object,
	            className: PropTypes$A.string,
	            collapsed: PropTypes$A.bool.isRequired,
	            minHeight: PropTypes$A.oneOfType([PropTypes$A.string, PropTypes$A.number]),
	            minPaddingTop: PropTypes$A.oneOfType([PropTypes$A.string, PropTypes$A.number]),
	            minPaddingBottom: PropTypes$A.oneOfType([
	                PropTypes$A.string,
	                PropTypes$A.number,
	            ]),
	            timeout: PropTypes$A.oneOfType([
	                PropTypes$A.number,
	                PropTypes$A.shape({
	                    appear: PropTypes$A.number,
	                    enter: PropTypes$A.number,
	                    exit: PropTypes$A.number,
	                }),
	            ]),
	            temporary: PropTypes$A.bool,
	            children: PropTypes$A.oneOfType([PropTypes$A.func, PropTypes$A.element])
	                .isRequired,
	            onEnter: PropTypes$A.func,
	            onEntering: PropTypes$A.func,
	            onEntered: PropTypes$A.func,
	            onExit: PropTypes$A.func,
	            onExiting: PropTypes$A.func,
	            onExited: PropTypes$A.func,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * Gets an object of al the CSS class names to use for the useCSSTransition
	 * hook. This will do some nice things like default the `appear` classes to the
	 * `enter` classes if the provided classNames left the `appear` classes as
	 * undefined but enabled the `appear` state.
	 *
	 * @private
	 */
	function getClassNames(classNames, timeout) {
	    if (typeof classNames === "string") {
	        return {
	            appear: timeout.appear ? classNames + "--appear" : "",
	            appearActive: timeout.appear ? classNames + "--appear-active" : "",
	            appearDone: "",
	            enter: timeout.enter ? classNames + "--enter" : "",
	            enterActive: timeout.enter ? classNames + "--enter-active" : "",
	            enterDone: "",
	            exit: timeout.exit ? classNames + "--exit" : "",
	            exitActive: timeout.exit ? classNames + "--exit-active" : "",
	            exitDone: "",
	        };
	    }
	    return defaults(classNames, {
	        appear: (timeout.appear && classNames.enter) || "",
	        appearActive: (timeout.appear && classNames.enterActive) || "",
	        appearDone: (timeout.appear && classNames.enterDone) || "",
	        enter: "",
	        enterActive: "",
	        enterDone: "",
	        exit: "",
	        exitActive: "",
	        exitDone: "",
	    });
	}

	/**
	 * This hook is heavily inspired by the `CSSTransition` component from
	 * `react-transition-group` since it's really just a hook version for it.
	 *
	 * This hook allows you to transition class names for an element for enter and
	 * exit transitions.
	 *
	 * There are two different ways to create an "appear-only"/"on-mount-only"
	 * transition: use the `onEntered` callback to reset the `transitionIn` to
	 * false, or manually fire the `ENTERED` action with the returned `dispatch`
	 * function when it should be fired again.
	 *
	 * Example changing `transitionIn` for pathname changes:
	 * ```ts
	 * const [transitionIn, setTransitionIn] = useState(true);
	 * const [rendered, transitionProps] = useCSSTransition({
	 *   appear: true,
	 *   timeout: { enter: 200 },
	 *   transitionIn,
	 *   onEntered: () => setTransitionIn(false),
	 * });
	 *
	 * const prevPathname = useRef(pathname);
	 * if (pathname !== prevPathname.current) {
	 *   prevPathname.current = pathname;
	 *   setTransitionIn(true)
	 * }
	 *
	 * return (
	 *   <div {...transitionProps}>
	 *     <Switch>
	 *       <Route path="/" component={Home} />
	 *       <Route path="/other" component={Other} />
	 *    </Switch>
	 *   </div>
	 * );
	 * ```
	 *
	 * Example with `dispatch` for pathname changes:
	 * ```ts
	 * const [rendered, transitionProps, dispatch] = useCSSTransition({
	 *   appear: true,
	 *   timeout: { enter: 200 },
	 *   transitionIn: true,
	 * });
	 *
	 * const prevPathname = useRef(pathname);
	 * if (pathname !== prevPathname.current) {
	 *   prevPathname.current = pathname;
	 *   dispatch(ENTERED);
	 * }
	 *
	 * return (
	 *   <div {...transitionProps}>
	 *     <Switch>
	 *       <Route path="/" component={Home} />
	 *       <Route path="/other" component={Other} />
	 *    </Switch>
	 *   </div>
	 * );
	 * ```
	 *
	 * @see useCrossFade The `useCrossFade` is a good example of using this hook for
	 * a custom CSS Transition.
	 * @param options The transition options
	 * @return An ordered list of a boolean if the component should be rendered,
	 * transition props to provide to the transitioning element, a dispatch function
	 * for triggering the transition manually (should not be used much), and the
	 * current transition stage.
	 */
	function useCSSTransition(_a) {
	    var _b = _a.appear, appear = _b === void 0 ? false : _b, _c = _a.temporary, temporary = _c === void 0 ? false : _c, timeout = _a.timeout, transitionIn = _a.transitionIn, onEnter = _a.onEnter, onEntering = _a.onEntering, onEntered = _a.onEntered, onExit = _a.onExit, onExiting = _a.onExiting, onExited = _a.onExited, className = _a.className, propClassNames = _a.classNames, propRef = _a.ref;
	    var _d = useTransition({
	        ref: propRef,
	        appear: appear,
	        repaint: true,
	        timeout: timeout,
	        temporary: temporary,
	        transitionIn: transitionIn,
	        onEnter: onEnter,
	        onEntering: onEntering,
	        onEntered: onEntered,
	        onExit: onExit,
	        onExiting: onExiting,
	        onExited: onExited,
	    }), rendered = _d.rendered, stage = _d.stage, ref = _d.ref, appearing = _d.appearing, dispatch = _d.dispatch;
	    var classNames = getClassNames(propClassNames, getTimeout(timeout, appear));
	    var isEntering = stage === ENTERING$1;
	    var isEnter = isEntering || stage === ENTER;
	    var isEntered = stage === ENTERED$2;
	    var isExiting = stage === EXITING$1;
	    var isExit = isExiting || stage === EXIT;
	    var isExited = stage === EXITED$1;
	    return [
	        rendered,
	        {
	            ref: ref,
	            className: classnames(className, 
	            // Note: can't use the object syntax for classNames since it'll fail
	            // if the same classes are used for different phases since they'd have
	            // the same key in the object...
	            appearing && classNames.appear, appearing && isEntering && classNames.appearActive, appearing && isEntered && classNames.appearDone, !appearing && isEnter && classNames.enter, !appearing && isEntering && classNames.enterActive, !appearing && isEntered && classNames.enterDone, isExit && classNames.exit, isExiting && classNames.exitActive, isExited && classNames.exitDone) || undefined,
	        },
	        dispatch,
	        stage,
	    ];
	}

	/**
	 * This is a simple wrapper for the `useCSSTransition` that will allow you to
	 * trigger cross fade transitions. The default behavior for this hook triggers
	 * the transition immediately once mounted. This is great if it is being used
	 * for new data appearing in a list, but not super great for route transitions.
	 *
	 * If you want to create a route transition, it's recommended to set the
	 * `appear` option to `false` and then manually fire the `ENTER` transition from
	 * the `dispatch` function. Here's a quick example using the `Layout` component
	 * from `@react-md/layout` and `react-router`.
	 *
	 * ```tsx
	 * import { useLocation, BrowserRouter } from "react-router-dom";
	 * import { useCrossFade, ENTER } from "@react-md/transition";
	 *
	 * const App = () => {
	 *   const { pathname } = useLocation();
	 *   const [, { ref, className }, dispatch] = useCrossFade({
	 *     appear: false,
	 *   });
	 *
	 *   const prevPathname = useRef(pathname);
	 *   if (pathname !== prevPathname.current) {
	 *     prevPathname.current = pathname;
	 *     dispatch(ENTER);
	 *   }
	 *
	 *   return (
	 *     <Layout
	 *       {...useLayoutNavigation(navItems, pathname)}
	 *       appBarTitle="My App"
	 *       mainRef={ref}
	 *       mainClassName={className}
	 *     >
	 *       {children}
	 *     </Layout>
	 *   );
	 * }
	 * ```
	 *
	 * @param options Any additional options and configuration that should be used
	 * for the transition.
	 * @return An ordered list of a boolean if the component should be rendered,
	 * transition props to provide to the transitioning element, a dispatch function
	 * for triggering the transition manually (should not be used much), and the
	 * current transition stage.
	 */
	function useCrossFade(_a) {
	    var _b = _a === void 0 ? {} : _a, _c = _b.appear, appear = _c === void 0 ? false : _c, _d = _b.temporary, temporary = _d === void 0 ? false : _d, _e = _b.transitionIn, transitionIn = _e === void 0 ? true : _e, className = _b.className, onEnter = _b.onEnter, onEntering = _b.onEntering, onEntered = _b.onEntered, onExit = _b.onExit, onExiting = _b.onExiting, onExited = _b.onExited;
	    return useCSSTransition({
	        appear: appear,
	        timeout: CROSS_FADE_TIMEOUT,
	        classNames: CROSS_FADE_CLASSNAMES,
	        transitionIn: transitionIn,
	        className: className,
	        onEnter: onEnter,
	        onEntering: onEntering,
	        onEntered: onEntered,
	        onExit: onExit,
	        onExiting: onExiting,
	        onExited: onExited,
	        temporary: temporary,
	    });
	}

	var __assign$J = (undefined && undefined.__assign) || function () {
	    __assign$J = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$J.apply(this, arguments);
	};
	var __rest$y = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * The `Collapse` is really just a convenience wrapper for the `useCrossFade`
	 * hook that triggers the transition by cloning the `ref` and `className` into
	 * the `children` of this component.
	 *
	 * This transition will only fire on mount and when the `appear` prop is set to
	 * `true`, so the way to trigger new animations is by changing the `key` for
	 * this component so it re-mounts. However it is generally not recommended to
	 * fire this transition on first page load especially when dealing with server
	 * side rendering. A simple way to work around this is have the `CrossFade` near
	 * the root of the app and just disable the `appear` prop until the first
	 * render.
	 *
	 * If you want more fine-grain control over the transition, it is recommended to
	 * use the `useCrossFade` hook instead.
	 */
	var CrossFade = React.forwardRef(function CrossFade(_a, forwardedRef) {
	    var _b = _a.wrap, wrap = _b === void 0 ? false : _b, _c = _a.appear, appear = _c === void 0 ? true : _c, _d = _a.temporary, temporary = _d === void 0 ? false : _d, propClassName = _a.className, _e = _a.transitionIn, transitionIn = _e === void 0 ? true : _e, children = _a.children, onEnter = _a.onEnter, onEntering = _a.onEntering, onEntered = _a.onEntered, onExit = _a.onExit, onExiting = _a.onExiting, onExited = _a.onExited, props = __rest$y(_a, ["wrap", "appear", "temporary", "className", "transitionIn", "children", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited"]);
	    var _f = useCrossFade({
	        ref: forwardedRef,
	        appear: appear,
	        className: propClassName,
	        onEnter: onEnter,
	        onEntering: onEntering,
	        onEntered: onEntered,
	        onExit: onExit,
	        onExiting: onExiting,
	        onExited: onExited,
	        temporary: temporary,
	        transitionIn: transitionIn,
	    }), rendered = _f[0], _g = _f[1], ref = _g.ref, className = _g.className;
	    if (!rendered) {
	        return null;
	    }
	    if (!wrap && React.isValidElement(children)) {
	        var child = React.Children.only(children);
	        return React.cloneElement(child, {
	            ref: ref,
	            className: classnames(child.props.className, className),
	        });
	    }
	    return (React__default.createElement("div", __assign$J({}, props, { className: className, ref: ref }), children));
	});
	{
	    try {
	        var PropTypes$B = require("prop-types");
	        CrossFade.propTypes = {
	            wrap: PropTypes$B.bool,
	            appear: PropTypes$B.bool,
	            temporary: PropTypes$B.bool,
	            style: PropTypes$B.object,
	            className: PropTypes$B.string,
	            transitionIn: PropTypes$B.bool,
	            onEnter: PropTypes$B.func,
	            onEntering: PropTypes$B.func,
	            onEntered: PropTypes$B.func,
	            onExit: PropTypes$B.func,
	            onExiting: PropTypes$B.func,
	            onExited: PropTypes$B.func,
	            children: PropTypes$B.oneOfType([PropTypes$B.node, PropTypes$B.element]),
	        };
	    }
	    catch (e) { }
	}

	var __assign$K = (undefined && undefined.__assign) || function () {
	    __assign$K = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$K.apply(this, arguments);
	};
	var __rest$z = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This `ScaleTransition` component is used to trigger an animation that
	 * switches between an opacity of `0` and `1` and using a `transform: scale(0)`
	 * to `transform: scale(1)`. It is recommended to also manually apply a
	 * `transform-origin` style or use the `useFixedPositioning` hook to generate
	 * for you so that the animation starts from a specific point.
	 *
	 * Since the default scale animation is X and Y, you can enable the `vertical`
	 * prop which will update the transition to use `transform: scaleY(0)` to
	 * `transform: scaleY(1)` instead.
	 */
	function ScaleTransition(_a) {
	    var visible = _a.visible, children = _a.children, propClassNames = _a.classNames, _b = _a.vertical, vertical = _b === void 0 ? false : _b, _c = _a.timeout, timeout = _c === void 0 ? SCALE_TIMEOUT : _c, _d = _a.portal, portal = _d === void 0 ? false : _d, portalInto = _a.portalInto, portalIntoId = _a.portalIntoId, _e = _a.mountOnEnter, mountOnEnter = _e === void 0 ? true : _e, _f = _a.unmountOnExit, unmountOnExit = _f === void 0 ? true : _f, props = __rest$z(_a, ["visible", "children", "classNames", "vertical", "timeout", "portal", "portalInto", "portalIntoId", "mountOnEnter", "unmountOnExit"]);
	    var classNames = propClassNames;
	    if (!classNames) {
	        classNames = vertical ? SCALE_Y_CLASSNAMES : SCALE_CLASSNAMES;
	    }
	    return (React__default.createElement(ConditionalPortal, { portal: portal, portalInto: portalInto, portalIntoId: portalIntoId },
	        React__default.createElement(CSSTransition, __assign$K({}, props, { in: visible, timeout: timeout, classNames: classNames, mountOnEnter: mountOnEnter, unmountOnExit: unmountOnExit }), children)));
	}
	{
	    try {
	        var PropTypes$C = require("prop-types");
	        ScaleTransition.propTypes = {
	            portal: PropTypes$C.bool,
	            portalInto: PropTypes$C.oneOfType([PropTypes$C.object, PropTypes$C.string]),
	            portalIntoId: PropTypes$C.string,
	            mountOnEnter: PropTypes$C.bool,
	            unmountOnExit: PropTypes$C.bool,
	            visible: PropTypes$C.bool.isRequired,
	            vertical: PropTypes$C.bool,
	            timeout: PropTypes$C.oneOfType([
	                PropTypes$C.number,
	                PropTypes$C.shape({
	                    enter: PropTypes$C.number,
	                    exit: PropTypes$C.number,
	                }),
	            ]),
	            classNames: PropTypes$C.oneOfType([
	                PropTypes$C.string,
	                PropTypes$C.shape({
	                    appear: PropTypes$C.string,
	                    appearActive: PropTypes$C.string,
	                    enter: PropTypes$C.string,
	                    enterActive: PropTypes$C.string,
	                    enterDone: PropTypes$C.string,
	                    exit: PropTypes$C.string,
	                    exitActive: PropTypes$C.string,
	                    exitDone: PropTypes$C.string,
	                }),
	            ]),
	            children: PropTypes$C.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$L = (undefined && undefined.__assign) || function () {
	    __assign$L = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$L.apply(this, arguments);
	};
	function getFixedTo(fixedTo) {
	    if (!fixedTo) {
	        return null;
	    }
	    var t = typeof fixedTo;
	    switch (t) {
	        case "string":
	            fixedTo = fixedTo;
	            return (document.getElementById(fixedTo) ||
	                document.querySelector(fixedTo));
	        case "function":
	            return fixedTo();
	        default:
	            return fixedTo;
	    }
	}
	/**
	 * This hook is used to automatically handle fixed positioning when an element is used alongside a
	 * `Transition` from `react-transition-group`. This will provide merged `onEnter`, `onEntering`,
	 * `onEntered`, and `onExited` handlers to pass down as well as the current style object to apply
	 * to the element.
	 *
	 * Until the element has been removed from the DOM and is visible, the position will automatically
	 * update when the user scrolls or resizes the screen.
	 *
	 * > It is recommended to start the exit animation when that happens though.
	 */
	function useFixedPositioning(_a) {
	    var onEnter = _a.onEnter, onEntering = _a.onEntering, onEntered = _a.onEntered, onExited = _a.onExited, fixedTo = _a.fixedTo, getOptions = _a.getOptions, onResize = _a.onResize, onScroll = _a.onScroll, _b = _a.anchor, currentAnchor = _b === void 0 ? {} : _b, initialX = _a.initialX, initialY = _a.initialY, _c = _a.xMargin, xMargin = _c === void 0 ? 0 : _c, _d = _a.vwMargin, vwMargin = _d === void 0 ? 16 : _d, _e = _a.yMargin, yMargin = _e === void 0 ? 0 : _e, _f = _a.vhMargin, vhMargin = _f === void 0 ? 16 : _f, _g = _a.width, width = _g === void 0 ? "auto" : _g, onPositionChange = _a.onPositionChange, _h = _a.transformOrigin, transformOrigin = _h === void 0 ? false : _h, _j = _a.preventOverlap, preventOverlap = _j === void 0 ? false : _j, _k = _a.disableSwapping, disableSwapping = _k === void 0 ? false : _k, _l = _a.disableVHBounds, disableVHBounds = _l === void 0 ? false : _l;
	    var _m = React.useState(), style = _m[0], setStyle = _m[1];
	    var _o = React.useState(null), element = _o[0], setElement = _o[1];
	    var updateStyle = React.useCallback(function (nextElement) {
	        var node = nextElement !== null && nextElement !== void 0 ? nextElement : element;
	        if (typeof nextElement !== "undefined") {
	            setElement(nextElement);
	        }
	        if (!node) {
	            return;
	        }
	        var anchor = {
	            x: currentAnchor.x || "center",
	            y: currentAnchor.y || "below",
	        };
	        var overrides = typeof getOptions === "function" ? getOptions(node) : {};
	        var opts = __assign$L({ initialX: initialX,
	            initialY: initialY,
	            xMargin: xMargin,
	            vwMargin: vwMargin,
	            yMargin: yMargin,
	            vhMargin: vhMargin,
	            width: width,
	            transformOrigin: transformOrigin,
	            preventOverlap: preventOverlap,
	            disableSwapping: disableSwapping,
	            disableVHBounds: disableVHBounds,
	            anchor: anchor, container: getFixedTo(fixedTo), element: node }, overrides);
	        var _a = getFixedPosition(opts), style = _a.style, actualX = _a.actualX, actualY = _a.actualY;
	        var actual = { x: actualX, y: actualY };
	        if (onPositionChange &&
	            (anchor.x !== actual.x || anchor.y !== actual.y)) {
	            onPositionChange(anchor, actual);
	        }
	        setStyle(style);
	    }, [
	        currentAnchor.x,
	        currentAnchor.y,
	        disableSwapping,
	        disableVHBounds,
	        fixedTo,
	        getOptions,
	        initialX,
	        initialY,
	        onPositionChange,
	        preventOverlap,
	        transformOrigin,
	        vhMargin,
	        vwMargin,
	        width,
	        xMargin,
	        yMargin,
	        element,
	    ]);
	    var handleEnter = React.useCallback(function (node, appear) {
	        if (onEnter) {
	            onEnter(node, appear);
	        }
	        updateStyle(node);
	    }, [onEnter, updateStyle]);
	    var handleEntering = React.useCallback(function (node, appear) {
	        if (onEntering) {
	            onEntering(node, appear);
	        }
	        updateStyle(node);
	    }, [onEntering, updateStyle]);
	    var handleEntered = React.useCallback(function (node, appear) {
	        if (onEntered) {
	            onEntered(node, appear);
	        }
	        updateStyle(node);
	    }, [onEntered, updateStyle]);
	    var handleExited = React.useCallback(function (node) {
	        if (onExited) {
	            onExited(node);
	        }
	        setElement(null);
	    }, [onExited]);
	    useResizeListener({
	        enabled: !!element,
	        onResize: function (event) {
	            if (onResize) {
	                onResize(event);
	            }
	            updateStyle();
	        },
	    });
	    useScrollListener({
	        enabled: !!element,
	        onScroll: function (event) {
	            if (onScroll) {
	                var container = getFixedTo(fixedTo);
	                var containerRect = container && container.getBoundingClientRect();
	                var elementRect = element && element.getBoundingClientRect();
	                var visible = false;
	                if (containerRect && elementRect) {
	                    var vh = getViewportSize("height");
	                    var vw = getViewportSize("width");
	                    var top_1 = Math.min(elementRect.top, containerRect.top);
	                    var right = Math.max(elementRect.right, containerRect.right);
	                    var bottom = Math.max(elementRect.bottom, containerRect.bottom);
	                    var left = Math.min(elementRect.left, containerRect.left);
	                    visible = bottom >= 0 && top_1 <= vh && right >= 0 && left <= vw;
	                }
	                onScroll(event, {
	                    element: element,
	                    fixedTo: container,
	                    visible: visible,
	                });
	            }
	            updateStyle();
	        },
	    });
	    React.useEffect(function () {
	        updateStyle();
	        // Need to only update when the initialX and initialY values are changed.
	        // If this is triggered each time the updateStyle is changed, it causes an
	        // infinite loop.
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [initialX, initialY]);
	    return {
	        style: style,
	        updateStyle: updateStyle,
	        onEnter: handleEnter,
	        onEntering: handleEntering,
	        onEntered: handleEntered,
	        onExited: handleExited,
	    };
	}

	var __assign$M = (undefined && undefined.__assign) || function () {
	    __assign$M = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$M.apply(this, arguments);
	};
	var __rest$A = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$n = bem("rmd-list");
	/**
	 * The `List` component creates an unstyled ordered or unordered list that
	 * should be used with the `ListItem`, `ListItemLink`, and `SimpleListItem`
	 * components.
	 */
	var List = React.forwardRef(function List(_a, ref) {
	    var _b = _a.role, role = _b === void 0 ? "none" : _b, _c = _a.dense, dense = _c === void 0 ? false : _c, _d = _a.ordered, ordered = _d === void 0 ? false : _d, _e = _a.horizontal, horizontal = _e === void 0 ? false : _e, className = _a.className, children = _a.children, props = __rest$A(_a, ["role", "dense", "ordered", "horizontal", "className", "children"]);
	    var Component = (ordered ? "ol" : "ul");
	    return (React__default.createElement(Component, __assign$M({}, props, { ref: ref, role: role, className: classnames(block$n({ dense: dense, horizontal: horizontal }), className) }), children));
	});
	{
	    try {
	        var PropTypes$D = require("prop-types");
	        List.propTypes = {
	            role: PropTypes$D.string,
	            dense: PropTypes$D.bool,
	            ordered: PropTypes$D.bool,
	            className: PropTypes$D.string,
	            children: PropTypes$D.node,
	            horizontal: PropTypes$D.bool,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * Gets the expected height for the `ListItem` or `SimpleListItem` based on the
	 * addons and `secondaryText` props.
	 *
	 * Conversions:
	 *
	 * - height !== "auto" -> height
	 * - secondaryText or left/right addon is media/media-large  -> "extra-large"
	 * - left/right addon is avatar -> "large"
	 * - left/right addon is icon -> "medium"
	 * - no addons and no secondary text -> "normal"
	 *
	 * @private
	 */
	function getListItemHeight(_a) {
	    var _b = _a.height, height = _b === void 0 ? "auto" : _b, leftAddon = _a.leftAddon, _c = _a.leftAddonType, leftAddonType = _c === void 0 ? "icon" : _c, rightAddon = _a.rightAddon, _d = _a.rightAddonType, rightAddonType = _d === void 0 ? "icon" : _d, secondaryText = _a.secondaryText;
	    if (height !== "auto") {
	        return height;
	    }
	    var isIcon = (leftAddon && leftAddonType === "icon") ||
	        (rightAddon && rightAddonType === "icon");
	    var isAvatar = (leftAddon && leftAddonType === "avatar") ||
	        (rightAddon && rightAddonType === "avatar");
	    var isGraphic = (leftAddon &&
	        (leftAddonType === "media" || leftAddonType === "large-media")) ||
	        (rightAddon &&
	            (rightAddonType === "media" || rightAddonType === "large-media"));
	    // secondary text will always be extra large due to the default `line-height`
	    if (isGraphic || secondaryText) {
	        return "extra-large";
	    }
	    if (isAvatar) {
	        return "large";
	    }
	    if (isIcon) {
	        return "medium";
	    }
	    return "normal";
	}

	var __assign$N = (undefined && undefined.__assign) || function () {
	    __assign$N = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$N.apply(this, arguments);
	};
	var __rest$B = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var base = bem("rmd-list-item");
	/**
	 * The `ListItemAddon` is used to create an addon to the left or right of the
	 * text/children of a `ListItem`.
	 */
	function ListItemAddon(_a) {
	    var _b;
	    var className = _a.className, children = _a.children, addon = _a.addon, _c = _a.addonAfter, addonAfter = _c === void 0 ? false : _c, _d = _a.type, type = _d === void 0 ? "icon" : _d, _e = _a.position, position = _e === void 0 ? "middle" : _e, forceAddonWrap = _a.forceAddonWrap, props = __rest$B(_a, ["className", "children", "addon", "addonAfter", "type", "position", "forceAddonWrap"]);
	    var isMedia = type === "media" || type === "large-media";
	    var isAvatar = type === "avatar";
	    return (React__default.createElement(TextIconSpacing, __assign$N({}, props, { icon: addon, forceIconWrap: forceAddonWrap !== null && forceAddonWrap !== void 0 ? forceAddonWrap : isMedia, className: classnames(base("addon", (_b = {},
	            _b[position] = position !== "middle",
	            _b.before = !addonAfter,
	            _b["avatar-before"] = !addonAfter && isAvatar,
	            _b.media = isMedia,
	            _b["media-large"] = type === "large-media",
	            _b)), className), iconAfter: addonAfter }), children));
	}
	{
	    try {
	        var PropTypes$E = require("prop-types");
	        ListItemAddon.propTypes = {
	            className: PropTypes$E.string,
	            children: PropTypes$E.node,
	            addon: PropTypes$E.node,
	            addonAfter: PropTypes$E.bool,
	            type: PropTypes$E.oneOf(["icon", "avatar", "media", "large-media"]),
	            position: PropTypes$E.oneOf(["top", "middle", "bottom"]),
	            forceAddonWrap: PropTypes$E.bool,
	        };
	    }
	    catch (e) { }
	}

	var block$o = bem("rmd-list-item");
	/**
	 * This component us used to create the one to three lines of text within a
	 * `ListItem` or `SimpleListItem`.
	 */
	function ListItemText(_a) {
	    var className = _a.className, secondaryTextClassName = _a.secondaryTextClassName, secondaryText = _a.secondaryText, children = _a.children;
	    var secondaryContent;
	    if (secondaryText) {
	        secondaryContent = (React__default.createElement("span", { className: classnames(block$o("text", { secondary: true }), secondaryTextClassName) }, secondaryText));
	    }
	    return (React__default.createElement("span", { className: classnames(block$o("text"), className) },
	        children,
	        secondaryContent));
	}
	{
	    try {
	        var PropTypes$F = require("prop-types");
	        ListItemText.propTypes = {
	            className: PropTypes$F.string,
	            secondaryTextClassName: PropTypes$F.string,
	            secondaryText: PropTypes$F.node,
	            children: PropTypes$F.node,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * The `ListItemChildren` component is used to create a styled list item that
	 * can have optional addons to the left or right of the children in the form of
	 * icons, avatars, or media. The `children` can be replaced by the `primaryText`
	 * and `secondaryText` props to create stacked text spanning two or more lines
	 * with the default behavior of using `line-clamp` at three lines.
	 *
	 * Note: This will return a `React.Fragment` of the children and does not wrap
	 * in a DOM node for styling. The parent component should normally have
	 * `display: flex` for the styling to work.
	 */
	function ListItemChildren(_a) {
	    var textClassName = _a.textClassName, secondaryTextClassName = _a.secondaryTextClassName, textChildren = _a.textChildren, primaryText = _a.primaryText, secondaryText = _a.secondaryText, leftAddon = _a.leftAddon, _b = _a.leftAddonType, leftAddonType = _b === void 0 ? "icon" : _b, _c = _a.leftAddonPosition, leftAddonPosition = _c === void 0 ? "middle" : _c, rightAddon = _a.rightAddon, _d = _a.rightAddonType, rightAddonType = _d === void 0 ? "icon" : _d, _e = _a.rightAddonPosition, rightAddonPosition = _e === void 0 ? "middle" : _e, forceAddonWrap = _a.forceAddonWrap, propChildren = _a.children;
	    var stringifiedChildren = typeof propChildren === "number" ? "" + propChildren : propChildren;
	    var children = stringifiedChildren;
	    if (primaryText || secondaryText || textChildren) {
	        children = (React__default.createElement(ListItemText, { className: textClassName, secondaryText: secondaryText, secondaryTextClassName: secondaryTextClassName }, (textChildren && children) || primaryText));
	    }
	    children = (React__default.createElement(ListItemAddon, { addon: leftAddon, type: leftAddonType, position: leftAddonPosition, forceAddonWrap: forceAddonWrap }, children));
	    children = (React__default.createElement(ListItemAddon, { addon: rightAddon, addonAfter: true, type: rightAddonType, position: rightAddonPosition, forceAddonWrap: forceAddonWrap }, children));
	    return (React__default.createElement(React__default.Fragment, null,
	        children,
	        (primaryText && stringifiedChildren) || null));
	}
	{
	    try {
	        var PropTypes$G = require("prop-types");
	        ListItemChildren.propTypes = {
	            textClassName: PropTypes$G.string,
	            secondaryTextClassName: PropTypes$G.string,
	            textChildren: PropTypes$G.bool,
	            primaryText: PropTypes$G.node,
	            secondaryText: PropTypes$G.node,
	            leftAddon: PropTypes$G.node,
	            leftAddonType: PropTypes$G.oneOf([
	                "icon",
	                "avatar",
	                "media",
	                "large-media",
	            ]),
	            leftAddonPosition: PropTypes$G.oneOf(["top", "middle", "bottom"]),
	            rightAddon: PropTypes$G.node,
	            rightAddonType: PropTypes$G.oneOf([
	                "icon",
	                "avatar",
	                "media",
	                "large-media",
	            ]),
	            rightAddonPosition: PropTypes$G.oneOf(["top", "middle", "bottom"]),
	            forceAddonWrap: PropTypes$G.bool,
	            children: PropTypes$G.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$O = (undefined && undefined.__assign) || function () {
	    __assign$O = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$O.apply(this, arguments);
	};
	var __rest$C = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$p = bem("rmd-list-item");
	/**
	 * The `SimpleListItem` component is used to create a non-clickable item within
	 * a `List`. This is really just useful since it allows for the `ListItem`
	 * styling behavior of left and right icons, avatars, and media.
	 *
	 * Note: Even though this component exists, it is recommended to use the
	 * `ListItemChildren` component instead if you want the "addon" styling/behavior
	 * since screen readers read `li` items within lists differently.
	 */
	var SimpleListItem = React.forwardRef(function SimpleListItem(_a, ref) {
	    var _b;
	    var className = _a.className, textClassName = _a.textClassName, secondaryTextClassName = _a.secondaryTextClassName, textChildren = _a.textChildren, primaryText = _a.primaryText, secondaryText = _a.secondaryText, leftAddon = _a.leftAddon, _c = _a.leftAddonType, leftAddonType = _c === void 0 ? "icon" : _c, _d = _a.leftAddonPosition, leftAddonPosition = _d === void 0 ? "middle" : _d, rightAddon = _a.rightAddon, _e = _a.rightAddonType, rightAddonType = _e === void 0 ? "icon" : _e, _f = _a.rightAddonPosition, rightAddonPosition = _f === void 0 ? "middle" : _f, forceAddonWrap = _a.forceAddonWrap, children = _a.children, _g = _a.height, propHeight = _g === void 0 ? "auto" : _g, _h = _a.threeLines, threeLines = _h === void 0 ? false : _h, _j = _a.clickable, clickable = _j === void 0 ? false : _j, onClick = _a.onClick, _k = _a.disabled, disabled = _k === void 0 ? false : _k, props = __rest$C(_a, ["className", "textClassName", "secondaryTextClassName", "textChildren", "primaryText", "secondaryText", "leftAddon", "leftAddonType", "leftAddonPosition", "rightAddon", "rightAddonType", "rightAddonPosition", "forceAddonWrap", "children", "height", "threeLines", "clickable", "onClick", "disabled"]);
	    var height = getListItemHeight({
	        height: propHeight,
	        leftAddon: leftAddon,
	        leftAddonType: leftAddonType,
	        rightAddon: rightAddon,
	        rightAddonType: rightAddonType,
	        secondaryText: secondaryText,
	    });
	    var ariaDisabled = props["aria-disabled"];
	    var isDisabled = disabled || ariaDisabled === "true" || ariaDisabled === true;
	    return (React__default.createElement("li", __assign$O({}, props, { "aria-disabled": isDisabled || undefined, ref: ref, className: classnames(block$p((_b = {},
	            _b[height] = height !== "auto" && height !== "normal",
	            _b["three-lines"] = threeLines,
	            _b.clickable = clickable,
	            _b.disabled = isDisabled,
	            _b)), className), onClick: isDisabled ? undefined : onClick }),
	        React__default.createElement(ListItemChildren, { textClassName: textClassName, secondaryTextClassName: secondaryTextClassName, textChildren: textChildren, primaryText: primaryText, secondaryText: secondaryText, leftAddon: leftAddon, leftAddonType: leftAddonType, leftAddonPosition: leftAddonPosition, rightAddon: rightAddon, rightAddonType: rightAddonType, rightAddonPosition: rightAddonPosition, forceAddonWrap: forceAddonWrap }, children)));
	});
	{
	    try {
	        var PropTypes$H = require("prop-types");
	        SimpleListItem.propTypes = {
	            "aria-disabled": PropTypes$H.oneOfType([
	                PropTypes$H.bool,
	                PropTypes$H.oneOf(["true", "false"]),
	            ]),
	            className: PropTypes$H.string,
	            disabled: PropTypes$H.bool,
	            clickable: PropTypes$H.bool,
	            threeLines: PropTypes$H.bool,
	            textClassName: PropTypes$H.string,
	            secondaryTextClassName: PropTypes$H.string,
	            textChildren: PropTypes$H.bool,
	            primaryText: PropTypes$H.node,
	            secondaryText: PropTypes$H.node,
	            height: PropTypes$H.oneOf([
	                "auto",
	                "normal",
	                "medium",
	                "large",
	                "extra-large",
	            ]),
	            leftAddon: PropTypes$H.node,
	            leftAddonType: PropTypes$H.oneOf([
	                "icon",
	                "avatar",
	                "media",
	                "large-media",
	            ]),
	            leftAddonPosition: PropTypes$H.oneOf(["top", "middle", "bottom"]),
	            rightAddon: PropTypes$H.node,
	            rightAddonType: PropTypes$H.oneOf([
	                "icon",
	                "avatar",
	                "media",
	                "large-media",
	            ]),
	            rightAddonPosition: PropTypes$H.oneOf(["top", "middle", "bottom"]),
	            forceAddonWrap: PropTypes$H.bool,
	            children: PropTypes$H.node,
	            onClick: PropTypes$H.func,
	        };
	    }
	    catch (e) { }
	}

	var __assign$P = (undefined && undefined.__assign) || function () {
	    __assign$P = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$P.apply(this, arguments);
	};
	var __rest$D = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * The `ListItem` creates a clickable and focusable `<li>` within a `List` that
	 * can optionally render addons to the left and right of the `children` or text.
	 */
	var ListItem = React.forwardRef(function ListItem(_a, ref) {
	    var propClassName = _a.className, textClassName = _a.textClassName, secondaryTextClassName = _a.secondaryTextClassName, _b = _a.textChildren, textChildren = _b === void 0 ? true : _b, primaryText = _a.primaryText, secondaryText = _a.secondaryText, children = _a.children, leftAddon = _a.leftAddon, _c = _a.leftAddonType, leftAddonType = _c === void 0 ? "icon" : _c, _d = _a.leftAddonPosition, leftAddonPosition = _d === void 0 ? "middle" : _d, rightAddon = _a.rightAddon, _e = _a.rightAddonType, rightAddonType = _e === void 0 ? "icon" : _e, _f = _a.rightAddonPosition, rightAddonPosition = _f === void 0 ? "middle" : _f, forceAddonWrap = _a.forceAddonWrap, _g = _a.height, propHeight = _g === void 0 ? "auto" : _g, _h = _a.disableSpacebarClick, disableSpacebarClick = _h === void 0 ? false : _h, _j = _a.disableRipple, disableRipple = _j === void 0 ? false : _j, _k = _a.disableProgrammaticRipple, disableProgrammaticRipple = _k === void 0 ? false : _k, _l = _a.disablePressedFallback, disablePressedFallback = _l === void 0 ? false : _l, rippleTimeout = _a.rippleTimeout, rippleClassNames = _a.rippleClassNames, rippleClassName = _a.rippleClassName, rippleContainerClassName = _a.rippleContainerClassName, _m = _a.role, role = _m === void 0 ? "button" : _m, _o = _a.tabIndex, tabIndex = _o === void 0 ? 0 : _o, props = __rest$D(_a, ["className", "textClassName", "secondaryTextClassName", "textChildren", "primaryText", "secondaryText", "children", "leftAddon", "leftAddonType", "leftAddonPosition", "rightAddon", "rightAddonType", "rightAddonPosition", "forceAddonWrap", "height", "disableSpacebarClick", "disableRipple", "disableProgrammaticRipple", "disablePressedFallback", "rippleTimeout", "rippleClassNames", "rippleClassName", "rippleContainerClassName", "role", "tabIndex"]);
	    var disabled = props.disabled;
	    var _p = useInteractionStates({
	        className: propClassName,
	        handlers: props,
	        disabled: disabled,
	        disableRipple: disableRipple,
	        disableProgrammaticRipple: disableProgrammaticRipple,
	        rippleTimeout: rippleTimeout,
	        rippleClassNames: rippleClassNames,
	        rippleClassName: rippleClassName,
	        rippleContainerClassName: rippleContainerClassName,
	        disableSpacebarClick: disableSpacebarClick,
	        disablePressedFallback: disablePressedFallback,
	    }), ripples = _p.ripples, className = _p.className, handlers = _p.handlers;
	    var height = getListItemHeight({
	        height: propHeight,
	        leftAddon: leftAddon,
	        leftAddonType: leftAddonType,
	        rightAddon: rightAddon,
	        rightAddonType: rightAddonType,
	        secondaryText: secondaryText,
	    });
	    return (React__default.createElement(SimpleListItem, __assign$P({}, props, handlers, { ref: ref, tabIndex: tabIndex, role: role, className: className, clickable: true, height: height }),
	        React__default.createElement(ListItemChildren, { textClassName: textClassName, secondaryTextClassName: secondaryTextClassName, textChildren: textChildren, primaryText: primaryText, secondaryText: secondaryText, leftAddon: leftAddon, leftAddonType: leftAddonType, leftAddonPosition: leftAddonPosition, rightAddon: rightAddon, rightAddonType: rightAddonType, rightAddonPosition: rightAddonPosition, forceAddonWrap: forceAddonWrap }, children),
	        ripples));
	});
	{
	    try {
	        var PropTypes$I = require("prop-types");
	        ListItem.propTypes = {
	            role: PropTypes$I.string,
	            tabIndex: PropTypes$I.number,
	            height: PropTypes$I.oneOf([
	                "auto",
	                "normal",
	                "medium",
	                "large",
	                "extra-large",
	            ]),
	            children: PropTypes$I.node,
	            className: PropTypes$I.string,
	            textClassName: PropTypes$I.string,
	            secondaryTextClassName: PropTypes$I.string,
	            primaryText: PropTypes$I.node,
	            secondaryText: PropTypes$I.node,
	            forceAddonWrap: PropTypes$I.bool,
	            leftAddon: PropTypes$I.node,
	            leftAddonType: PropTypes$I.oneOf([
	                "icon",
	                "avatar",
	                "media",
	                "large-media",
	            ]),
	            leftAddonPosition: PropTypes$I.oneOf(["top", "middle", "bottom"]),
	            rightAddon: PropTypes$I.node,
	            rightAddonType: PropTypes$I.oneOf([
	                "icon",
	                "avatar",
	                "media",
	                "large-media",
	            ]),
	            rightAddonPosition: PropTypes$I.oneOf(["top", "middle", "bottom"]),
	            disabled: PropTypes$I.bool,
	            disableRipple: PropTypes$I.bool,
	            disableProgrammaticRipple: PropTypes$I.bool,
	            rippleTimeout: PropTypes$I.oneOfType([
	                PropTypes$I.number,
	                PropTypes$I.shape({
	                    appear: PropTypes$I.number,
	                    enter: PropTypes$I.number,
	                    exit: PropTypes$I.number,
	                }),
	            ]),
	            rippleClassNames: PropTypes$I.oneOfType([
	                PropTypes$I.string,
	                PropTypes$I.shape({
	                    appear: PropTypes$I.string,
	                    appearActive: PropTypes$I.string,
	                    enter: PropTypes$I.string,
	                    enterActive: PropTypes$I.string,
	                    enterDone: PropTypes$I.string,
	                    exit: PropTypes$I.string,
	                    exitActive: PropTypes$I.string,
	                    exitDone: PropTypes$I.string,
	                }),
	            ]),
	            rippleClassName: PropTypes$I.string,
	            rippleContainerClassName: PropTypes$I.string,
	            enablePressedAndRipple: PropTypes$I.bool,
	            disableSpacebarClick: PropTypes$I.bool,
	            disablePressedFallback: PropTypes$I.bool,
	            textChildren: PropTypes$I.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$Q = (undefined && undefined.__assign) || function () {
	    __assign$Q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$Q.apply(this, arguments);
	};
	var __rest$E = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This component is a really bad attempt at creating a `Link` within a `List`
	 * that has the main `ListItem` styles. It will probably be better to just use
	 * the `ListItemChildren` within your `Link` component instead.
	 */
	var ListItemLink = React.forwardRef(function ListItemLink(_a, ref) {
	    var _b;
	    var propClassName = _a.className, textClassName = _a.textClassName, secondaryTextClassName = _a.secondaryTextClassName, textChildren = _a.textChildren, primaryText = _a.primaryText, secondaryText = _a.secondaryText, children = _a.children, leftAddon = _a.leftAddon, _c = _a.leftAddonType, leftAddonType = _c === void 0 ? "icon" : _c, _d = _a.leftAddonPosition, leftAddonPosition = _d === void 0 ? "middle" : _d, rightAddon = _a.rightAddon, _e = _a.rightAddonType, rightAddonType = _e === void 0 ? "icon" : _e, _f = _a.rightAddonPosition, rightAddonPosition = _f === void 0 ? "middle" : _f, forceAddonWrap = _a.forceAddonWrap, _g = _a.height, propHeight = _g === void 0 ? "auto" : _g, _h = _a.threeLines, threeLines = _h === void 0 ? false : _h, _j = _a.component, Component = _j === void 0 ? "a" : _j, disableSpacebarClick = _a.disableSpacebarClick, disableRipple = _a.disableRipple, disableProgrammaticRipple = _a.disableProgrammaticRipple, disablePressedFallback = _a.disablePressedFallback, rippleTimeout = _a.rippleTimeout, rippleClassNames = _a.rippleClassNames, rippleClassName = _a.rippleClassName, rippleContainerClassName = _a.rippleContainerClassName, props = __rest$E(_a, ["className", "textClassName", "secondaryTextClassName", "textChildren", "primaryText", "secondaryText", "children", "leftAddon", "leftAddonType", "leftAddonPosition", "rightAddon", "rightAddonType", "rightAddonPosition", "forceAddonWrap", "height", "threeLines", "component", "disableSpacebarClick", "disableRipple", "disableProgrammaticRipple", "disablePressedFallback", "rippleTimeout", "rippleClassNames", "rippleClassName", "rippleContainerClassName"]);
	    var height = getListItemHeight({
	        height: propHeight,
	        leftAddon: leftAddon,
	        leftAddonType: leftAddonType,
	        rightAddon: rightAddon,
	        rightAddonType: rightAddonType,
	        secondaryText: secondaryText,
	    });
	    var _k = useInteractionStates({
	        className: propClassName,
	        handlers: props,
	        disableRipple: disableRipple,
	        disableProgrammaticRipple: disableProgrammaticRipple,
	        rippleTimeout: rippleTimeout,
	        rippleClassNames: rippleClassNames,
	        rippleClassName: rippleClassName,
	        rippleContainerClassName: rippleContainerClassName,
	        disableSpacebarClick: disableSpacebarClick,
	        disablePressedFallback: disablePressedFallback,
	    }), ripples = _k.ripples, className = _k.className, handlers = _k.handlers;
	    return (React__default.createElement(Component, __assign$Q({}, props, handlers, { ref: ref, className: classnames("rmd-list-item rmd-list-item--clickable rmd-list-item--link", (_b = {},
	            _b["rmd-list-item--" + height] = height !== "auto" && height !== "normal",
	            _b["rmd-list-item--three-lines"] = !!secondaryText && threeLines,
	            _b), className) }),
	        React__default.createElement(ListItemChildren, { textClassName: textClassName, secondaryTextClassName: secondaryTextClassName, textChildren: textChildren, primaryText: primaryText, secondaryText: secondaryText, leftAddon: leftAddon, leftAddonType: leftAddonType, leftAddonPosition: leftAddonPosition, rightAddon: rightAddon, rightAddonType: rightAddonType, rightAddonPosition: rightAddonPosition, forceAddonWrap: forceAddonWrap }, children),
	        ripples));
	});
	{
	    ListItemLink.displayName = "ListItemLink";
	    try {
	        var PropTypes$J = require("prop-types");
	        ListItemLink.propTypes = {
	            component: PropTypes$J.oneOfType([
	                PropTypes$J.string,
	                PropTypes$J.func,
	                PropTypes$J.object,
	            ]),
	            height: PropTypes$J.oneOf([
	                "auto",
	                "normal",
	                "medium",
	                "large",
	                "extra-large",
	            ]),
	            children: PropTypes$J.node,
	            className: PropTypes$J.string,
	            textClassName: PropTypes$J.string,
	            secondaryTextClassName: PropTypes$J.string,
	            primaryText: PropTypes$J.node,
	            secondaryText: PropTypes$J.node,
	            forceAddonWrap: PropTypes$J.bool,
	            leftAddon: PropTypes$J.node,
	            leftAddonType: PropTypes$J.oneOf([
	                "icon",
	                "avatar",
	                "media",
	                "large-media",
	            ]),
	            leftAddonPosition: PropTypes$J.oneOf(["top", "middle", "bottom"]),
	            rightAddon: PropTypes$J.node,
	            rightAddonType: PropTypes$J.oneOf([
	                "icon",
	                "avatar",
	                "media",
	                "large-media",
	            ]),
	            rightAddonPosition: PropTypes$J.oneOf(["top", "middle", "bottom"]),
	            disabled: PropTypes$J.bool,
	            disableRipple: PropTypes$J.bool,
	            disableProgrammaticRipple: PropTypes$J.bool,
	            rippleTimeout: PropTypes$J.oneOfType([
	                PropTypes$J.number,
	                PropTypes$J.shape({
	                    appear: PropTypes$J.number,
	                    enter: PropTypes$J.number,
	                    exit: PropTypes$J.number,
	                }),
	            ]),
	            rippleClassNames: PropTypes$J.oneOfType([
	                PropTypes$J.string,
	                PropTypes$J.shape({
	                    appear: PropTypes$J.string,
	                    appearActive: PropTypes$J.string,
	                    enter: PropTypes$J.string,
	                    enterActive: PropTypes$J.string,
	                    enterDone: PropTypes$J.string,
	                    exit: PropTypes$J.string,
	                    exitActive: PropTypes$J.string,
	                    exitDone: PropTypes$J.string,
	                }),
	            ]),
	            rippleClassName: PropTypes$J.string,
	            rippleContainerClassName: PropTypes$J.string,
	            enablePressedAndRipple: PropTypes$J.bool,
	            disableSpacebarClick: PropTypes$J.bool,
	            disablePressedFallback: PropTypes$J.bool,
	            textChildren: PropTypes$J.bool,
	            threeLines: PropTypes$J.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$R = (undefined && undefined.__assign) || function () {
	    __assign$R = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$R.apply(this, arguments);
	};
	var __rest$F = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$q = bem("rmd-list-subheader");
	/**
	 * This is a simple component that will render a `<li>` with the subheader
	 * typography styles. It also supports an `inset` variant that adds some spacing
	 * to the left of the text to align with other `ListItem` that have left addons.
	 */
	var ListSubheader = React.forwardRef(function ListSubheader(_a, ref) {
	    var className = _a.className, _b = _a.inset, inset = _b === void 0 ? false : _b, props = __rest$F(_a, ["className", "inset"]);
	    return (React__default.createElement("li", __assign$R({}, props, { ref: ref, className: classnames(block$q({ inset: inset }), className) })));
	});
	{
	    try {
	        var PropTypes$K = require("prop-types");
	        ListSubheader.propTypes = {
	            className: PropTypes$K.string,
	            inset: PropTypes$K.bool,
	            children: PropTypes$K.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$S = (undefined && undefined.__assign) || function () {
	    __assign$S = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$S.apply(this, arguments);
	};
	var __rest$G = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$r = bem("rmd-option");
	/**
	 * The Option component is a simple wrapper for the `SimpleListItem` that adds
	 * some required a11y for behaving as the `option` role.
	 */
	var Option = React.forwardRef(function Option(_a, ref) {
	    var className = _a.className, _b = _a.selected, selected = _b === void 0 ? false : _b, focused = _a.focused, children = _a.children, _c = _a.textChildren, textChildren = _c === void 0 ? true : _c, props = __rest$G(_a, ["className", "selected", "focused", "children", "textChildren"]);
	    return (React__default.createElement(SimpleListItem, __assign$S({}, props, { ref: ref, role: "option", "aria-selected": selected || undefined, clickable: true, className: classnames(block$r({
	            selected: selected,
	            focused: focused,
	        }), className), textChildren: textChildren }), children));
	});
	{
	    try {
	        var PropTypes$L = require("prop-types");
	        Option.propTypes = {
	            className: PropTypes$L.string,
	            focused: PropTypes$L.bool.isRequired,
	            selected: PropTypes$L.bool,
	            children: PropTypes$L.node,
	            textChildren: PropTypes$L.bool,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * A type guard that simply checks if the option is considered an object of list
	 * item props.
	 *
	 * @param option The option to check
	 * @return true if the option is considered a object of list item props and will
	 * ensure that the option is typed as ListboxOptionProps
	 * @private
	 */
	function isListboxOptionProps(option) {
	    return (option !== "" && option !== 0 && !!option && typeof option === "object");
	}
	/**
	 * The default implementation to check if an option is disabled. It will just
	 * check if the option is an object and if it has the disabled prop enabled.
	 *
	 * @param option The option to check
	 * @return true if the option is disabled
	 * @private
	 */
	function defaultIsOptionDisabled(option) {
	    return isListboxOptionProps(option) && !!option.disabled;
	}
	/**
	 * The default way to generate a "unique" id for each option within the listbox
	 * by concatenating the current index with a base id.
	 *
	 * Note: The index will be incremented by 1 so the ids start from 1 instead of
	 * 0. This is so that it matches how paginated results work with `aria-posinset`
	 * + `aria-setsize`.
	 *
	 * @param baseId The base id of the listbox.
	 * @param index The current index of the option
	 * @return a "unique" id for the option
	 */
	function getOptionId(baseId, index) {
	    return baseId + "-option-" + (index + 1);
	}
	/**
	 * A function that will get the label for an option. The default behavior is to
	 * check if the option is an object. If it is, it'll use the `labelKey` property
	 * and fallback to the `children` property. If it is anything else, the option
	 * itself will be returned.
	 *
	 * This is used in both the select's button element to show the current value as
	 * well as rendering each option within the listbox component.
	 *
	 * @param option The option that should be converted into a renderable label
	 * element.
	 * @param labelKey The object key to use to extract the label from an option
	 * object.
	 * @return a renderable label to display.
	 */
	function getOptionLabel(option, labelKey) {
	    if (isListboxOptionProps(option)) {
	        if (typeof option.children !== "undefined") {
	            return option.children;
	        }
	        var label = option[labelKey];
	        return typeof label === "undefined" ? null : label;
	    }
	    return option;
	}
	/**
	 * A function that will get the display value for the `Select` field based on
	 * the current selected option. The default behavior will be to return null if
	 * an option is not currently selected so the placeholder text can be shown
	 * instead. If there is an option selected, it will:
	 * - get the option's label using the general `getOptionLabel` util
	 * - check if includeLeft is enabled and the option is an object with
	 *   `leftAddon`
	 *   - if there is a `leftAddon`, use the `TextIconSpacing` of
	 *     the label + the icon or avatar.
	 *
	 * @param option The option to get a display label for
	 * @param labelKey The key to use to extract a label from the option when it is
	 * an object
	 * @param includeLeft Boolean if a `leftAddon` should be added with
	 * `TextIconSpacing` to the result.
	 * @return A renderable node to display in a `Select` field.
	 */
	function getDisplayLabel(option, labelKey, includeLeft) {
	    if (!option) {
	        return null;
	    }
	    var label = getOptionLabel(option, labelKey);
	    if (!includeLeft || !isListboxOptionProps(option)) {
	        return label;
	    }
	    var leftAddon = option.leftAddon;
	    return React.createElement(TextIconSpacing, { icon: leftAddon }, label);
	}

	var __assign$T = (undefined && undefined.__assign) || function () {
	    __assign$T = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$T.apply(this, arguments);
	};
	var __rest$H = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$s = bem("rmd-listbox");
	var warned;
	/**
	 * This component is used to render the list part of a `<select>` element with
	 * built-in accessibility and the ability to add custom styles. This should
	 * probably not be used much outside of `react-md` itself and the `Select`
	 * component, but I'm planning on adding support for an inline listbox at some
	 * point.
	 */
	var Listbox = React.forwardRef(function Listbox(_a, ref) {
	    var className = _a.className, _b = _a.visible, visible = _b === void 0 ? true : _b, _c = _a.temporary, temporary = _c === void 0 ? false : _c, _d = _a.labelKey, labelKey = _d === void 0 ? "label" : _d, _e = _a.valueKey, valueKey = _e === void 0 ? "value" : _e, _f = _a.getOptionId, getOptionId$1 = _f === void 0 ? getOptionId : _f, _g = _a.getOptionLabel, getOptionLabel$1 = _g === void 0 ? getOptionLabel : _g, _h = _a.getOptionValue, getOptionValue = _h === void 0 ? DEFAULT_GET_ITEM_VALUE : _h, _j = _a.isOptionDisabled, isOptionDisabled = _j === void 0 ? defaultIsOptionDisabled : _j, _k = _a.disableMovementChange, disableMovementChange = _k === void 0 ? false : _k, onFocus = _a.onFocus, propOnKeyDown = _a.onKeyDown, name = _a.name, options = _a.options, value = _a.value, onChange = _a.onChange, propTabIndex = _a.tabIndex, portal = _a.portal, portalInto = _a.portalInto, portalIntoId = _a.portalIntoId, onRequestClose = _a.onRequestClose, timeout = _a.timeout, readOnly = _a.readOnly, classNames = _a.classNames, mountOnEnter = _a.mountOnEnter, unmountOnExit = _a.unmountOnExit, onEnter = _a.onEnter, onEntering = _a.onEntering, onEntered = _a.onEntered, onExit = _a.onExit, onExiting = _a.onExiting, onExited = _a.onExited, props = __rest$H(_a, ["className", "visible", "temporary", "labelKey", "valueKey", "getOptionId", "getOptionLabel", "getOptionValue", "isOptionDisabled", "disableMovementChange", "onFocus", "onKeyDown", "name", "options", "value", "onChange", "tabIndex", "portal", "portalInto", "portalIntoId", "onRequestClose", "timeout", "readOnly", "classNames", "mountOnEnter", "unmountOnExit", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited"]);
	    var id = props.id;
	    var tabIndex = propTabIndex;
	    if (temporary) {
	        tabIndex = -1;
	    }
	    else if (typeof propTabIndex === "undefined") {
	        tabIndex = 0;
	    }
	    /**
	     * Gets the current index of the option that has the same value as the
	     * provided prop value.
	     */
	    var getIndex = React.useCallback(function () {
	        return options.findIndex(function (option) { return value === getOptionValue(option, valueKey); });
	    }, [getOptionValue, options, value, valueKey]);
	    /**
	     * Conditionally calls the onChange callback with the new value and option if
	     * the value has changed. This will be called when:
	     * - the user presses the enter or space key while "focusing" an option
	     * - the user keyboard navigates to a new option while the
	     *   `disableMovementChange` prop is `false`
	     * - the user clicks the option with a mouse or touch
	     */
	    var handleChange = React.useCallback(function (index) {
	        if (readOnly) {
	            return;
	        }
	        var option = options[index];
	        if (!option || isOptionDisabled(option)) {
	            return;
	        }
	        var optionValue = getOptionValue(option, valueKey);
	        if (value !== optionValue) {
	            onChange(optionValue, options[index], {
	                id: id,
	                name: name,
	                value: value,
	                valueKey: valueKey,
	                options: options,
	            });
	        }
	    }, [
	        getOptionValue,
	        id,
	        isOptionDisabled,
	        name,
	        onChange,
	        options,
	        readOnly,
	        value,
	        valueKey,
	    ]);
	    var handleKeyboardClick = React.useCallback(function (focusedIndex) {
	        handleChange(focusedIndex);
	        if (temporary && onRequestClose) {
	            onRequestClose();
	        }
	    }, [handleChange, onRequestClose, temporary]);
	    var _l = useActiveDescendantMovement(__assign$T(__assign$T({}, VERTICAL_LISTBOX), { defaultFocusedIndex: getIndex, items: options, baseId: id, valueKey: labelKey, getId: getOptionId$1, getItemValue: function (option, key) {
	            if (!isListboxOptionProps(option)) {
	                return "" + option;
	            }
	            var search = option[key];
	            if (typeof search === "number" || typeof search === "string") {
	                return "" + search;
	            }
	            {
	                if (!warned) {
	                    warned = new Set();
	                }
	                if (!warned.has(id)) {
	                    /* eslint-disable no-console */
	                    console.warn("A listbox with an id of \"" + id + "\" has an option that does not have a searchable label string. " +
	                        "Users will be unable to use the typeahead feature in the Listbox component until this is fixed. " +
	                        "To fix this warning, you can use the `labelKey` prop on the `Listbox`/`Select` component to point " +
	                        "to a string on the following option:", option);
	                    warned.add(id);
	                }
	            }
	            return "";
	        },
	        onChange: function (data) {
	            if (disableMovementChange) {
	                return;
	            }
	            handleChange(data.index);
	        }, onEnter: handleKeyboardClick, onSpace: handleKeyboardClick, onKeyDown: function (event) {
	            if (propOnKeyDown) {
	                propOnKeyDown(event);
	            }
	            switch (event.key) {
	                case "Tab":
	                case "Escape":
	                    if (event.key === "Escape") {
	                        event.stopPropagation();
	                    }
	                    if (temporary && onRequestClose) {
	                        onRequestClose();
	                    }
	                    break;
	                // no default
	            }
	        } })), activeId = _l.activeId, itemRefs = _l.itemRefs, onKeyDown = _l.onKeyDown, focusedIndex = _l.focusedIndex, setFocusedIndex = _l.setFocusedIndex;
	    var prevVisible = React.useRef(visible);
	    if (visible !== prevVisible.current) {
	        prevVisible.current = visible;
	        // whenever it gains visibility, try to set the focused index to the
	        // current active value
	        if (visible) {
	            setFocusedIndex(getIndex());
	        }
	    }
	    var handleFocus = React.useCallback(function (event) {
	        if (onFocus) {
	            onFocus(event);
	        }
	        var item = itemRefs[focusedIndex] && itemRefs[focusedIndex].current;
	        if (item) {
	            scrollIntoView(event.currentTarget, item);
	        }
	    }, [focusedIndex, itemRefs, onFocus]);
	    return (React__default.createElement(ScaleTransition, { portal: portal, portalInto: portalInto, portalIntoId: portalIntoId, visible: !temporary || visible, vertical: true, timeout: timeout, classNames: classNames, mountOnEnter: mountOnEnter, unmountOnExit: unmountOnExit, onEnter: onEnter, onEntering: onEntering, onEntered: onEntered, onExit: onExit, onExiting: onExiting, onExited: onExited },
	        React__default.createElement(List, __assign$T({}, props, { "aria-activedescendant": activeId, ref: ref, role: "listbox", tabIndex: tabIndex, className: classnames(block$s({ temporary: temporary }), className), onFocus: handleFocus, onKeyDown: onKeyDown }), options.map(function (option, i) {
	            var optionId = getOptionId$1(id, i);
	            var optionValue = getOptionValue(option, valueKey);
	            var optionLabel = getOptionLabel$1(option, labelKey);
	            var optionProps;
	            if (isListboxOptionProps(option)) {
	                optionProps = omit(option, [labelKey, valueKey]);
	            }
	            var disabled = isOptionDisabled(option);
	            var onClick;
	            if (!readOnly && !disabled) {
	                onClick = function () {
	                    handleChange(i);
	                    setFocusedIndex(i);
	                };
	            }
	            return (React__default.createElement(Option, __assign$T({ key: optionValue, id: optionId, disabled: disabled }, optionProps, { ref: itemRefs[i], focused: optionId === activeId, selected: value === optionValue, onClick: onClick }), optionLabel));
	        }))));
	});
	{
	    try {
	        var PropTypes$M = require("prop-types");
	        Listbox.propTypes = {
	            id: PropTypes$M.string.isRequired,
	            value: PropTypes$M.string.isRequired,
	            onChange: PropTypes$M.func.isRequired,
	            className: PropTypes$M.string,
	            labelKey: PropTypes$M.string,
	            valueKey: PropTypes$M.string,
	            getOptionId: PropTypes$M.func,
	            getOptionLabel: PropTypes$M.func,
	            getOptionValue: PropTypes$M.func,
	            isOptionDisabled: PropTypes$M.func,
	            visible: PropTypes$M.bool,
	            temporary: PropTypes$M.bool,
	            onRequestClose: PropTypes$M.func,
	            disableMovementChange: PropTypes$M.bool,
	            timeout: PropTypes$M.oneOfType([
	                PropTypes$M.number,
	                PropTypes$M.shape({
	                    enter: PropTypes$M.number,
	                    exit: PropTypes$M.number,
	                }),
	            ]),
	            classNames: PropTypes$M.oneOfType([
	                PropTypes$M.string,
	                PropTypes$M.shape({
	                    appear: PropTypes$M.string,
	                    appearActive: PropTypes$M.string,
	                    enter: PropTypes$M.string,
	                    enterActive: PropTypes$M.string,
	                    enterDone: PropTypes$M.string,
	                    exit: PropTypes$M.string,
	                    exitActive: PropTypes$M.string,
	                    exitDone: PropTypes$M.string,
	                }),
	            ]),
	            readOnly: PropTypes$M.bool,
	            mountOnEnter: PropTypes$M.bool,
	            unmountOnExit: PropTypes$M.bool,
	            onEnter: PropTypes$M.func,
	            onEntering: PropTypes$M.func,
	            onEntered: PropTypes$M.func,
	            onExit: PropTypes$M.func,
	            onExiting: PropTypes$M.func,
	            onExited: PropTypes$M.func,
	            portal: PropTypes$M.bool,
	            portalInto: PropTypes$M.oneOfType([PropTypes$M.object, PropTypes$M.string]),
	            portalIntoId: PropTypes$M.string,
	            tabIndex: PropTypes$M.number,
	            onFocus: PropTypes$M.func,
	            onKeyDown: PropTypes$M.func,
	            name: PropTypes$M.string,
	            options: PropTypes$M.arrayOf(PropTypes$M.oneOfType([
	                PropTypes$M.string,
	                PropTypes$M.number,
	                PropTypes$M.object,
	            ])).isRequired,
	        };
	    }
	    catch (e) { }
	}

	var __assign$U = (undefined && undefined.__assign) || function () {
	    __assign$U = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$U.apply(this, arguments);
	};
	var __rest$I = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$t = bem("rmd-select");
	/**
	 * This component is an accessible version of the `<select>` element that allows
	 * for some more custom styles by using the `@react-md/list` package to render
	 * the list of options.
	 *
	 * The `Select` component **must be controlled** with a `value` and `onChange`
	 * handler.
	 *
	 * Note: Since this is not a native `<select>` component, the current value will
	 * be rendered in an `<input type="hidden" />` element so that the value can be
	 * sent along in forms. It is highly recommended to always provide a `name` prop
	 * so this value is sent.
	 */
	var Select = React.forwardRef(function Select(_a, forwardedRef) {
	    var onBlur = _a.onBlur, onFocus = _a.onFocus, onKeyDown = _a.onKeyDown, onClick = _a.onClick, className = _a.className, label = _a.label, labelStyle = _a.labelStyle, labelClassName = _a.labelClassName, displayLabelStyle = _a.displayLabelStyle, displayLabelClassName = _a.displayLabelClassName, listboxStyle = _a.listboxStyle, listboxClassName = _a.listboxClassName, _b = _a.anchor, anchor = _b === void 0 ? BELOW_CENTER_ANCHOR : _b, propTheme = _a.theme, _c = _a.dense, dense = _c === void 0 ? false : _c, _d = _a.inline, inline = _d === void 0 ? false : _d, _e = _a.error, error = _e === void 0 ? false : _e, _f = _a.disabled, disabled = _f === void 0 ? false : _f, _g = _a.isLeftAddon, isLeftAddon = _g === void 0 ? true : _g, _h = _a.isRightAddon, isRightAddon = _h === void 0 ? true : _h, propUnderlineDirection = _a.underlineDirection, _j = _a.listboxWidth, listboxWidth = _j === void 0 ? "equal" : _j, _k = _a.portal, portal = _k === void 0 ? true : _k, portalInto = _a.portalInto, portalIntoId = _a.portalIntoId, name = _a.name, options = _a.options, _l = _a.labelKey, labelKey = _l === void 0 ? "label" : _l, _m = _a.valueKey, valueKey = _m === void 0 ? "value" : _m, _o = _a.getOptionId, getOptionId$1 = _o === void 0 ? getOptionId : _o, _p = _a.getOptionLabel, getOptionLabel$1 = _p === void 0 ? getOptionLabel : _p, _q = _a.getOptionValue, getOptionValue = _q === void 0 ? DEFAULT_GET_ITEM_VALUE : _q, _r = _a.getDisplayLabel, getDisplayLabel$1 = _r === void 0 ? getDisplayLabel : _r, _s = _a.isOptionDisabled, isOptionDisabled = _s === void 0 ? defaultIsOptionDisabled : _s, _t = _a.disableLeftAddon, disableLeftAddon = _t === void 0 ? false : _t, _u = _a.disableMovementChange, disableMovementChange = _u === void 0 ? false : _u, _v = _a.closeOnResize, closeOnResize = _v === void 0 ? false : _v, _w = _a.closeOnScroll, closeOnScroll = _w === void 0 ? false : _w, readOnly = _a.readOnly, placeholder = _a.placeholder, value = _a.value, onChange = _a.onChange, propRightChildren = _a.rightChildren, props = __rest$I(_a, ["onBlur", "onFocus", "onKeyDown", "onClick", "className", "label", "labelStyle", "labelClassName", "displayLabelStyle", "displayLabelClassName", "listboxStyle", "listboxClassName", "anchor", "theme", "dense", "inline", "error", "disabled", "isLeftAddon", "isRightAddon", "underlineDirection", "listboxWidth", "portal", "portalInto", "portalIntoId", "name", "options", "labelKey", "valueKey", "getOptionId", "getOptionLabel", "getOptionValue", "getDisplayLabel", "isOptionDisabled", "disableLeftAddon", "disableMovementChange", "closeOnResize", "closeOnScroll", "readOnly", "placeholder", "value", "onChange", "rightChildren"]);
	    var id = props.id;
	    var rightChildren = useIcon("dropdown", propRightChildren);
	    var _x = useFormTheme({
	        theme: propTheme,
	        underlineDirection: propUnderlineDirection,
	    }), theme = _x.theme, underlineDirection = _x.underlineDirection;
	    var valued = typeof value === "number" || !!value;
	    var displayValue = React.useMemo(function () {
	        var currentOption = options.find(function (option) { return getOptionValue(option, valueKey) === value; }) ||
	            null;
	        return getDisplayLabel$1(currentOption, labelKey, !disableLeftAddon);
	    }, [
	        options,
	        getDisplayLabel$1,
	        labelKey,
	        disableLeftAddon,
	        getOptionValue,
	        valueKey,
	        value,
	    ]);
	    var _y = useToggle(false), visible = _y[0], show = _y[1], hide = _y[2];
	    var _z = useFocusState({ onBlur: onBlur, onFocus: onFocus }), focused = _z[0], handleFocus = _z[1], handleBlur = _z[2];
	    var handleKeyDown = React.useCallback(function (event) {
	        if (onKeyDown) {
	            onKeyDown(event);
	        }
	        if (disabled) {
	            return;
	        }
	        switch (event.key) {
	            case " ":
	            case "ArrowUp":
	            case "ArrowDown":
	                // prevent page scroll
	                event.preventDefault();
	                show();
	                break;
	            case "Enter": {
	                var form = event.currentTarget.closest("form");
	                if (form) {
	                    // the default behavior of pressing the "Enter" key on a form
	                    // control (input, textarea, select) is to submit a form, so that's
	                    // what this is attempting to polyfill. Unfortunately, using the
	                    // form.submit() ignores any `onSubmit` handlers like
	                    // event.preventDefault() so to work around that, try to first find
	                    // a submit button and click that instead. If there isn't a submit
	                    // button as a child of the form, try to find a submit button that
	                    // has the form attribute set to this current form's id.
	                    var submit = form.querySelector('[type="submit"]');
	                    if (!submit && form.id) {
	                        submit = document.querySelector("[type=\"submit\"][form=\"" + form.id + "\"]");
	                    }
	                    if (submit) {
	                        submit.click();
	                    }
	                }
	                break;
	            }
	            // no default
	        }
	    }, [onKeyDown, disabled, show]);
	    var selectRef = React.useRef(null);
	    var ref = React.useCallback(function (instance) {
	        applyRef(instance, forwardedRef);
	        selectRef.current = instance;
	    }, [forwardedRef]);
	    useCloseOnOutsideClick({
	        enabled: visible,
	        element: selectRef.current,
	        onOutsideClick: hide,
	    });
	    var _0 = useFixedPositioning({
	        fixedTo: function () { return selectRef.current; },
	        anchor: anchor,
	        onScroll: closeOnScroll ? hide : undefined,
	        onResize: closeOnResize ? hide : undefined,
	        transformOrigin: true,
	        width: listboxWidth,
	        onEntering: function (node) {
	            // can't do onEnter since the positioning styles haven't been applied to the
	            // dom node at this time. this means the list is the last element in the DOM
	            // when portalled, which causes the page to scroll to the end. Moving it to
	            // onEntering will ensure the styles have been applied and won't cause page
	            // scrolling
	            node.focus();
	        },
	    }), fixedStyle = _0.style, onEnter = _0.onEnter, onEntering = _0.onEntering, onEntered = _0.onEntered, onExited = _0.onExited;
	    var handleClick = React.useCallback(function (event) {
	        if (onClick) {
	            onClick(event);
	        }
	        show();
	    }, [onClick, show]);
	    var handleKeyboardClose = React.useCallback(function () {
	        hide();
	        if (selectRef.current) {
	            selectRef.current.focus();
	        }
	    }, [hide]);
	    var labelId = id + "-label";
	    var valueId = id + "-value";
	    var listboxId = id + "-listbox";
	    var displayValueId = id + "-display-value";
	    return (React__default.createElement(React__default.Fragment, null,
	        React__default.createElement(TextFieldContainer, __assign$U({}, props, { "aria-haspopup": "listbox", "aria-disabled": disabled || undefined, ref: ref, role: "button", tabIndex: disabled ? undefined : 0, label: !!label, onFocus: handleFocus, onBlur: handleBlur, onKeyDown: disabled ? undefined : handleKeyDown, onClick: disabled ? undefined : handleClick, theme: theme, error: error, active: focused || visible, inline: inline, disabled: disabled, underlineDirection: underlineDirection, isLeftAddon: isLeftAddon, isRightAddon: isRightAddon, rightChildren: rightChildren, className: classnames(block$t({ disabled: disabled }), className) }),
	            React__default.createElement(FloatingLabel, { id: labelId, style: labelStyle, className: classnames(block$t("label"), labelClassName), htmlFor: id, error: error, active: valued && (focused || visible), valued: valued, floating: focused || valued || visible, dense: dense, disabled: disabled, component: "span" }, label),
	            React__default.createElement("span", { id: displayValueId, style: displayLabelStyle, className: classnames(block$t("value", {
	                    disabled: disabled,
	                    readonly: readOnly,
	                    placeholder: !valued && placeholder,
	                    "placeholder-active": !valued && placeholder && (focused || visible),
	                }), displayLabelClassName) }, displayValue || (!valued && placeholder)),
	            React__default.createElement("input", { id: valueId, type: "hidden", name: name, value: value })),
	        React__default.createElement(Listbox, { id: listboxId, "aria-labelledby": id, style: __assign$U(__assign$U({}, fixedStyle), listboxStyle), className: listboxClassName, name: name, portal: portal, portalInto: portalInto, portalIntoId: portalIntoId, onEnter: onEnter, onEntering: onEntering, onEntered: onEntered, onExited: onExited, value: value, onChange: onChange, visible: visible, temporary: true, onRequestClose: handleKeyboardClose, options: options, labelKey: labelKey, valueKey: valueKey, getOptionId: getOptionId$1, getOptionLabel: getOptionLabel$1, getOptionValue: getOptionValue, isOptionDisabled: isOptionDisabled, disableMovementChange: disableMovementChange })));
	});
	{
	    try {
	        var PropTypes$N = require("prop-types");
	        Select.propTypes = {
	            id: PropTypes$N.string.isRequired,
	            style: PropTypes$N.object,
	            className: PropTypes$N.string,
	            labelStyle: PropTypes$N.object,
	            labelClassName: PropTypes$N.string,
	            listboxStyle: PropTypes$N.object,
	            listboxClassName: PropTypes$N.string,
	            displayLabelStyle: PropTypes$N.object,
	            displayLabelClassName: PropTypes$N.string,
	            label: PropTypes$N.node,
	            portal: PropTypes$N.bool,
	            portalInto: PropTypes$N.oneOfType([
	                PropTypes$N.string,
	                PropTypes$N.object,
	                PropTypes$N.func,
	            ]),
	            portalIntoId: PropTypes$N.string,
	            labelKey: PropTypes$N.string,
	            valueKey: PropTypes$N.string,
	            getOptionId: PropTypes$N.func,
	            getOptionLabel: PropTypes$N.func,
	            getOptionValue: PropTypes$N.func,
	            getDisplayLabel: PropTypes$N.func,
	            isOptionDisabled: PropTypes$N.func,
	            disableLeftAddon: PropTypes$N.bool,
	            disableMovementChange: PropTypes$N.bool,
	            theme: PropTypes$N.oneOf(["none", "underline", "filled", "outline"]),
	            dense: PropTypes$N.bool,
	            error: PropTypes$N.bool,
	            inline: PropTypes$N.bool,
	            readOnly: PropTypes$N.bool,
	            disabled: PropTypes$N.bool,
	            placeholder: PropTypes$N.node,
	            underlineDirection: PropTypes$N.oneOf(["left", "center", "right"]),
	            leftChildren: PropTypes$N.node,
	            rightChildren: PropTypes$N.node,
	            isLeftAddon: PropTypes$N.bool,
	            isRightAddon: PropTypes$N.bool,
	            closeOnResize: PropTypes$N.bool,
	            closeOnScroll: PropTypes$N.bool,
	            anchor: PropTypes$N.shape({
	                x: PropTypes$N.oneOf([
	                    "inner-left",
	                    "inner-right",
	                    "center",
	                    "left",
	                    "right",
	                ]),
	                y: PropTypes$N.oneOf(["above", "below", "center", "top", "bottom"]),
	            }),
	            listboxWidth: PropTypes$N.oneOf(["equal", "min", "auto"]),
	            name: PropTypes$N.string,
	            options: PropTypes$N.arrayOf(PropTypes$N.oneOfType([
	                PropTypes$N.string,
	                PropTypes$N.number,
	                PropTypes$N.object,
	            ])).isRequired,
	            onBlur: PropTypes$N.func,
	            onFocus: PropTypes$N.func,
	            onKeyDown: PropTypes$N.func,
	            onClick: PropTypes$N.func,
	            value: PropTypes$N.string.isRequired,
	            onChange: PropTypes$N.func.isRequired,
	        };
	    }
	    catch (e) { }
	}

	var __assign$V = (undefined && undefined.__assign) || function () {
	    __assign$V = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$V.apply(this, arguments);
	};
	var __rest$J = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$u = bem("rmd-text-field");
	var SPECIAL_TYPES = [
	    "date",
	    "time",
	    "datetime-local",
	    "month",
	    "week",
	    "color",
	];
	/**
	 * The text field is a wrapper of the `<input type="text" />` component with
	 * some nice default themes. It can also be used to render other text input
	 * types with _some_ support.
	 */
	var TextField = React.forwardRef(function TextField(_a, ref) {
	    var style = _a.style, className = _a.className, inputStyle = _a.inputStyle, inputClassName = _a.inputClassName, label = _a.label, labelStyle = _a.labelStyle, labelClassName = _a.labelClassName, _b = _a.type, type = _b === void 0 ? "text" : _b, propTheme = _a.theme, _c = _a.dense, dense = _c === void 0 ? false : _c, _d = _a.inline, inline = _d === void 0 ? false : _d, _e = _a.error, error = _e === void 0 ? false : _e, _f = _a.disabled, disabled = _f === void 0 ? false : _f, propOnBlur = _a.onBlur, propOnFocus = _a.onFocus, propOnChange = _a.onChange, containerRef = _a.containerRef, _g = _a.isLeftAddon, isLeftAddon = _g === void 0 ? true : _g, _h = _a.isRightAddon, isRightAddon = _h === void 0 ? true : _h, leftChildren = _a.leftChildren, rightChildren = _a.rightChildren, propUnderlineDirection = _a.underlineDirection, containerProps = _a.containerProps, props = __rest$J(_a, ["style", "className", "inputStyle", "inputClassName", "label", "labelStyle", "labelClassName", "type", "theme", "dense", "inline", "error", "disabled", "onBlur", "onFocus", "onChange", "containerRef", "isLeftAddon", "isRightAddon", "leftChildren", "rightChildren", "underlineDirection", "containerProps"]);
	    var id = props.id, value = props.value, defaultValue = props.defaultValue;
	    var _j = useFocusState({
	        onBlur: propOnBlur,
	        onFocus: propOnFocus,
	    }), focused = _j[0], onFocus = _j[1], onBlur = _j[2];
	    var _k = useValuedState({
	        value: value,
	        defaultValue: defaultValue,
	        onChange: propOnChange,
	    }), valued = _k[0], onChange = _k[1];
	    var _l = useFormTheme({
	        theme: propTheme,
	        underlineDirection: propUnderlineDirection,
	    }), theme = _l.theme, underlineDirection = _l.underlineDirection;
	    return (React__default.createElement(TextFieldContainer, __assign$V({}, containerProps, { style: style, className: className, ref: containerRef, theme: theme, error: error, active: focused, label: !!label, dense: dense, inline: inline, disabled: disabled, isLeftAddon: isLeftAddon, isRightAddon: isRightAddon, leftChildren: leftChildren, rightChildren: rightChildren, underlineDirection: underlineDirection }),
	        React__default.createElement(FloatingLabel, { style: labelStyle, className: labelClassName, htmlFor: id, error: error, active: focused, floating: focused || valued || SPECIAL_TYPES.includes(type), valued: valued, dense: dense, disabled: disabled }, label),
	        React__default.createElement("input", __assign$V({}, props, { ref: ref, type: type, disabled: disabled, onFocus: onFocus, onBlur: onBlur, onChange: onChange, style: inputStyle, className: classnames(block$u({
	                floating: label && theme !== "none",
	            }), inputClassName) }))));
	});
	{
	    try {
	        var PropTypes$O = require("prop-types");
	        TextField.propTypes = {
	            id: PropTypes$O.string.isRequired,
	            type: PropTypes$O.oneOf([
	                "text",
	                "password",
	                "number",
	                "tel",
	                "email",
	                "date",
	                "time",
	                "datetime-local",
	                "month",
	                "week",
	                "url",
	                "color",
	            ]),
	            style: PropTypes$O.object,
	            className: PropTypes$O.string,
	            inputStyle: PropTypes$O.object,
	            inputClassName: PropTypes$O.string,
	            labelStyle: PropTypes$O.object,
	            labelClassName: PropTypes$O.string,
	            label: PropTypes$O.node,
	            value: PropTypes$O.string,
	            defaultValue: PropTypes$O.string,
	            theme: PropTypes$O.oneOf(["none", "underline", "filled", "outline"]),
	            dense: PropTypes$O.bool,
	            error: PropTypes$O.bool,
	            inline: PropTypes$O.bool,
	            disabled: PropTypes$O.bool,
	            placeholder: PropTypes$O.string,
	            underlineDirection: PropTypes$O.oneOf(["left", "center", "right"]),
	            leftChildren: PropTypes$O.node,
	            rightChildren: PropTypes$O.node,
	            isLeftAddon: PropTypes$O.bool,
	            isRightAddon: PropTypes$O.bool,
	            onBlur: PropTypes$O.func,
	            onFocus: PropTypes$O.func,
	            onChange: PropTypes$O.func,
	            containerRef: PropTypes$O.oneOfType([PropTypes$O.func, PropTypes$O.object]),
	            containerProps: PropTypes$O.object,
	        };
	    }
	    catch (e) { }
	}

	var __assign$W = (undefined && undefined.__assign) || function () {
	    __assign$W = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$W.apply(this, arguments);
	};
	var __rest$K = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$v = bem("rmd-password");
	function isConfigurableIcon(icon) {
	    return !!icon && !React.isValidElement(icon);
	}
	/**
	 * This component is a simple wrapper of the `TextField` that can only be
	 * rendered for password inputs. There is built-in functionality to be able to
	 * temporarily show the password's value by swapping the `type` to `"text"`.
	 */
	var Password = React.forwardRef(function Password(_a, ref) {
	    var className = _a.className, inputClassName = _a.inputClassName, propVisibilityIcon = _a.visibilityIcon, visibilityStyle = _a.visibilityStyle, visibilityClassName = _a.visibilityClassName, _b = _a.visibilityLabel, visibilityLabel = _b === void 0 ? "Show password" : _b, onVisibilityClick = _a.onVisibilityClick, getVisibilityIcon = _a.getVisibilityIcon, _c = _a.disableVisibility, disableVisibility = _c === void 0 ? false : _c, props = __rest$K(_a, ["className", "inputClassName", "visibilityIcon", "visibilityStyle", "visibilityClassName", "visibilityLabel", "onVisibilityClick", "getVisibilityIcon", "disableVisibility"]);
	    var id = props.id;
	    var _d = React.useState("password"), type = _d[0], setType = _d[1];
	    var toggle = React.useCallback(function (event) {
	        if (onVisibilityClick) {
	            onVisibilityClick(event);
	        }
	        setType(function (prevType) { return (prevType === "password" ? "text" : "password"); });
	    }, [onVisibilityClick]);
	    var visible = type === "text";
	    var visibilityIcon = useIcon("password", propVisibilityIcon);
	    if (isConfigurableIcon(propVisibilityIcon)) {
	        visibilityIcon = visible
	            ? propVisibilityIcon.visible
	            : propVisibilityIcon.invisible;
	    }
	    return (React__default.createElement(TextField, __assign$W({}, props, { className: classnames(block$v({ offset: !disableVisibility }), className), inputClassName: classnames(block$v("input", { offset: !disableVisibility }), inputClassName), ref: ref, type: type, isRightAddon: false, rightChildren: !disableVisibility && (React__default.createElement(Button, { id: id + "-password-toggle", "aria-label": visibilityLabel, "aria-pressed": visible, buttonType: "icon", onClick: toggle, style: visibilityStyle, className: classnames(block$v("toggle"), visibilityClassName) }, typeof getVisibilityIcon === "function"
	            ? getVisibilityIcon(type)
	            : visibilityIcon)) })));
	});
	{
	    try {
	        var PropTypes$P = require("prop-types");
	        Password.propTypes = {
	            id: PropTypes$P.string.isRequired,
	            className: PropTypes$P.string,
	            inputClassName: PropTypes$P.string,
	            visibilityIcon: PropTypes$P.oneOfType([
	                PropTypes$P.node,
	                PropTypes$P.shape({
	                    visible: PropTypes$P.node,
	                    invisible: PropTypes$P.node,
	                }),
	            ]),
	            visibilityStyle: PropTypes$P.object,
	            visibilityClassName: PropTypes$P.string,
	            visibilityLabel: PropTypes$P.string,
	            disableVisibility: PropTypes$P.bool,
	            onVisibilityClick: PropTypes$P.func,
	            getVisibilityIcon: PropTypes$P.func,
	        };
	    }
	    catch (e) { }
	}

	var __assign$X = (undefined && undefined.__assign) || function () {
	    __assign$X = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$X.apply(this, arguments);
	};
	var __rest$L = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$w = bem("rmd-textarea");
	var container$1 = bem("rmd-textarea-container");
	var PADDING_VARIABLES = "var(--rmd-form-text-padding-top, 0px) + var(--rmd-form-textarea-padding, 0px)";
	// this is the default of 1.5rem line-height in the styles
	var DEFAULT_LINE_HEIGHT = "24";
	var TextArea = React.forwardRef(function TextArea(_a, forwardedRef) {
	    var style = _a.style, className = _a.className, areaStyle = _a.areaStyle, areaClassName = _a.areaClassName, containerRef = _a.containerRef, label = _a.label, labelStyle = _a.labelStyle, labelClassName = _a.labelClassName, _b = _a.rows, rows = _b === void 0 ? 2 : _b, _c = _a.maxRows, maxRows = _c === void 0 ? -1 : _c, _d = _a.resize, resize = _d === void 0 ? "auto" : _d, propTheme = _a.theme, _e = _a.dense, dense = _e === void 0 ? false : _e, _f = _a.inline, propInline = _f === void 0 ? false : _f, _g = _a.error, error = _g === void 0 ? false : _g, _h = _a.disabled, disabled = _h === void 0 ? false : _h, _j = _a.animate, animate = _j === void 0 ? true : _j, _k = _a.isLeftAddon, isLeftAddon = _k === void 0 ? true : _k, _l = _a.isRightAddon, isRightAddon = _l === void 0 ? true : _l, propUnderlineDirection = _a.underlineDirection, propOnBlur = _a.onBlur, propOnFocus = _a.onFocus, propOnChange = _a.onChange, leftChildren = _a.leftChildren, rightChildren = _a.rightChildren, props = __rest$L(_a, ["style", "className", "areaStyle", "areaClassName", "containerRef", "label", "labelStyle", "labelClassName", "rows", "maxRows", "resize", "theme", "dense", "inline", "error", "disabled", "animate", "isLeftAddon", "isRightAddon", "underlineDirection", "onBlur", "onFocus", "onChange", "leftChildren", "rightChildren"]);
	    var id = props.id, value = props.value, defaultValue = props.defaultValue;
	    var _m = useFormTheme({
	        theme: propTheme,
	        underlineDirection: propUnderlineDirection,
	    }), theme = _m.theme, underlineDirection = _m.underlineDirection;
	    var _o = useFocusState({
	        onBlur: propOnBlur,
	        onFocus: propOnFocus,
	    }), focused = _o[0], onFocus = _o[1], onBlur = _o[2];
	    var _p = React.useState(), height = _p[0], setHeight = _p[1];
	    if (resize !== "auto" && typeof height === "number") {
	        setHeight(undefined);
	    }
	    var _q = React.useState(null), mask = _q[0], setMask = _q[1];
	    var _r = React.useState(false), scrollable = _r[0], setScrollable = _r[1];
	    var updateHeight = function () {
	        if (!mask) {
	            return;
	        }
	        var nextHeight = mask.scrollHeight;
	        if (maxRows > 0) {
	            var lineHeight = parseFloat(window.getComputedStyle(mask).lineHeight || DEFAULT_LINE_HEIGHT);
	            var maxHeight = maxRows * lineHeight;
	            nextHeight = Math.min(maxHeight, nextHeight);
	            // only want the textarea to be scrollable if there's a limit on the rows
	            // since it'll flash the scrollbar on most OS during the height transition
	            if (nextHeight === maxHeight && !scrollable) {
	                setScrollable(true);
	            }
	            else if (nextHeight !== maxHeight && scrollable) {
	                setScrollable(false);
	            }
	        }
	        if (height !== nextHeight) {
	            setHeight(nextHeight);
	        }
	    };
	    // the window can be resized while there is text inside the textarea so need to
	    // recalculate the height when the width changes as well.
	    useResizeObserver({
	        disableHeight: true,
	        target: mask,
	        onResize: updateHeight,
	    });
	    var _s = useValuedState({
	        value: value,
	        defaultValue: defaultValue,
	        onChange: function (event) {
	            if (propOnChange) {
	                propOnChange(event);
	            }
	            if (!mask || resize !== "auto") {
	                return;
	            }
	            // to get the height transition to work, you have to set the height on:
	            // - the main container element (including padding) that has the height
	            //    transition enabled
	            // - a child div wrapper (without padding) that has the height transition
	            //    enabled
	            // - the textarea element (without padding) and without a height transition
	            //
	            // if it isn't done this way, the height transition will look weird since
	            // the text will be fixed to the bottom of the area and more text at the top
	            // will become visible as the height transition completes. applying the
	            // transition on the two parent elements work because:
	            // - the height is set immediately on the text field so it expands to show all
	            //    the text
	            // - the height is correctly applied to both parent elements, but their height
	            //    haven't fully been adjusted due to the animation
	            // - the parent divs have overflow visible by default, so the textarea's text
	            //    will expand past the boundaries of the divs and not cause the upwards
	            //    animation weirdness.
	            mask.value = event.currentTarget.value;
	            updateHeight();
	        },
	    }), valued = _s[0], onChange = _s[1];
	    var areaRef = React.useRef(null);
	    var refHandler = React.useCallback(function (instance) {
	        applyRef(instance, forwardedRef);
	        areaRef.current = instance;
	    }, [forwardedRef]);
	    // the container element adds some padding so that the content can scroll and
	    // not be covered by the floating label. unfortunately, this means that the entire
	    // container is no longer clickable to focus the input. This is used to add that
	    // functionality back.
	    var handleClick = React.useCallback(function (event) {
	        if (areaRef.current && event.target === event.currentTarget) {
	            areaRef.current.focus();
	        }
	    }, []);
	    var area = (React__default.createElement("textarea", __assign$X({}, props, { ref: refHandler, rows: rows, disabled: disabled, onFocus: onFocus, onBlur: onBlur, onChange: onChange, style: __assign$X(__assign$X({}, areaStyle), { height: height }), className: classnames(block$w({
	            scrollable: scrollable || resize === "none",
	            floating: label && theme !== "none",
	            rh: resize === "horizontal",
	            rv: resize === "vertical",
	            rn: resize === "auto" || resize === "none",
	        }), areaClassName) })));
	    var children = area;
	    if (resize === "auto") {
	        children = (React__default.createElement("div", { style: { height: height }, className: container$1("inner", { animate: animate }) },
	            area,
	            React__default.createElement("textarea", { "aria-hidden": true, defaultValue: value || defaultValue, id: id + "-mask", ref: setMask, readOnly: true, rows: rows, tabIndex: -1, style: areaStyle, className: classnames(block$w({
	                    rn: true,
	                    mask: true,
	                    floating: label && theme !== "none",
	                }), areaClassName) })));
	    }
	    var inline = propInline;
	    if (resize === "horizontal" || resize === "both") {
	        // have to force it inline or else you won't be able to resize
	        // it horizontally.
	        inline = true;
	    }
	    return (React__default.createElement(TextFieldContainer, { style: __assign$X(__assign$X({}, style), { height: height
	                ? "calc(" + PADDING_VARIABLES + " + " + height + "px)"
	                : undefined }), className: classnames(container$1({
	            animate: animate && resize === "auto",
	            cursor: !disabled,
	        }), className), ref: containerRef, theme: theme, error: error, active: focused, label: !!label, dense: dense, inline: inline, disabled: disabled, isLeftAddon: isLeftAddon, isRightAddon: isRightAddon, leftChildren: leftChildren, rightChildren: rightChildren, underlineDirection: underlineDirection, onClick: !disabled ? handleClick : undefined },
	        React__default.createElement(FloatingLabel, { style: labelStyle, className: labelClassName, htmlFor: id, error: error, active: focused, floating: focused || valued, valued: valued, dense: dense, disabled: disabled }, label),
	        children));
	});
	{
	    try {
	        var PropTypes$Q = require("prop-types");
	        TextArea.propTypes = {
	            id: PropTypes$Q.string.isRequired,
	            style: PropTypes$Q.object,
	            className: PropTypes$Q.string,
	            areaStyle: PropTypes$Q.object,
	            areaClassName: PropTypes$Q.string,
	            labelStyle: PropTypes$Q.object,
	            labelClassName: PropTypes$Q.string,
	            label: PropTypes$Q.node,
	            value: PropTypes$Q.string,
	            defaultValue: PropTypes$Q.string,
	            theme: PropTypes$Q.oneOf(["none", "underline", "filled", "outline"]),
	            dense: PropTypes$Q.bool,
	            error: PropTypes$Q.bool,
	            inline: PropTypes$Q.bool,
	            disabled: PropTypes$Q.bool,
	            placeholder: PropTypes$Q.string,
	            underlineDirection: PropTypes$Q.oneOf(["left", "center", "right"]),
	            leftChildren: PropTypes$Q.node,
	            rightChildren: PropTypes$Q.node,
	            isLeftAddon: PropTypes$Q.bool,
	            isRightAddon: PropTypes$Q.bool,
	            animate: PropTypes$Q.bool,
	            rows: PropTypes$Q.number,
	            maxRows: PropTypes$Q.number,
	            resize: PropTypes$Q.oneOf([
	                "none",
	                "auto",
	                "horizontal",
	                "vertical",
	                "both",
	            ]),
	            containerRef: PropTypes$Q.oneOfType([PropTypes$Q.func, PropTypes$Q.object]),
	            onBlur: PropTypes$Q.func,
	            onFocus: PropTypes$Q.func,
	            onChange: PropTypes$Q.func,
	        };
	    }
	    catch (e) { }
	}

	var __assign$Y = (undefined && undefined.__assign) || function () {
	    __assign$Y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$Y.apply(this, arguments);
	};
	var __rest$M = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$x = bem("rmd-form-message");
	/**
	 * The `FormMessage` component is used to create additional helper messages or
	 * error messages and generally placed below the related `TextField`. If a
	 * `length` (of the `value`) and `maxLength` are provided, a counter will also
	 * be displayed to the right of the `children`.
	 *
	 * This component can also be used to create form-level validation messages by
	 * setting the `role` prop to `"alert"`.
	 */
	var FormMessage = React.forwardRef(function FormMessage(_a, ref) {
	    var _b;
	    var id = _a.id, role = _a.role, className = _a.className, counterStyle = _a.counterStyle, counterClassName = _a.counterClassName, messageStyle = _a.messageStyle, messageClassName = _a.messageClassName, _c = _a.error, error = _c === void 0 ? false : _c, _d = _a.disableWrap, disableWrap = _d === void 0 ? false : _d, propTheme = _a.theme, children = _a.children, length = _a.length, maxLength = _a.maxLength, props = __rest$M(_a, ["id", "role", "className", "counterStyle", "counterClassName", "messageStyle", "messageClassName", "error", "disableWrap", "theme", "children", "length", "maxLength"]);
	    var theme = useFormTheme({ theme: propTheme }).theme;
	    var message = children;
	    if (!disableWrap && children) {
	        message = (React__default.createElement("p", { id: id + "-message", style: messageStyle, className: classnames(block$x("message"), messageClassName) }, children));
	    }
	    return (React__default.createElement("div", __assign$Y({}, props, { id: id, ref: ref, "aria-live": role !== "alert" ? "polite" : undefined, role: role, className: classnames(block$x((_b = {
	                error: error
	            },
	            _b[theme] = theme !== "none",
	            _b)), className) }),
	        message,
	        typeof length === "number" && typeof maxLength === "number" && (React__default.createElement("span", { id: id + "-counter", style: counterStyle, className: classnames(block$x("counter"), counterClassName) }, length + " / " + maxLength))));
	});
	{
	    try {
	        var PropTypes$R = require("prop-types");
	        FormMessage.propTypes = {
	            id: PropTypes$R.string.isRequired,
	            role: PropTypes$R.oneOf(["alert"]),
	            className: PropTypes$R.string,
	            messageStyle: PropTypes$R.object,
	            messageClassName: PropTypes$R.string,
	            counterStyle: PropTypes$R.object,
	            counterClassName: PropTypes$R.string,
	            error: PropTypes$R.bool,
	            length: PropTypes$R.number,
	            maxLength: PropTypes$R.number,
	            disableWrap: PropTypes$R.bool,
	            children: PropTypes$R.node,
	            theme: PropTypes$R.oneOf(["none", "underline", "filled", "outline"]),
	            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
	            // @ts-ignore
	            _counterValidator: function (props, _propName, component) {
	                var length = props.length, maxLength = props.maxLength;
	                var lengthType = typeof length;
	                var maxLengthType = typeof length;
	                if (lengthType === maxLengthType) {
	                    return null;
	                }
	                return new Error("Both the `length` and `maxLength` props are required to be defined " +
	                    ("and a number to create a counter in the `" + component + " component, but ") +
	                    ("received `length: " + length + "` and `maxLength: " + maxLength + "`"));
	            },
	        };
	    }
	    catch (e) { }
	}

	var __assign$Z = (undefined && undefined.__assign) || function () {
	    __assign$Z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$Z.apply(this, arguments);
	};
	var __rest$N = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$y = bem("rmd-toggle-container");
	/**
	 * The `ToggleContainer` component should generally be used around a
	 * custom `"checkbox"`, `"radio"`, or `"switch"` component to help with
	 * additional styles. This is mostly an internal component so I'm not
	 * sure useful it will be though.
	 */
	var ToggleContainer = React.forwardRef(function ToggleContainer(_a, ref) {
	    var className = _a.className, _b = _a.inline, inline = _b === void 0 ? false : _b, _c = _a.stacked, stacked = _c === void 0 ? false : _c, children = _a.children, props = __rest$N(_a, ["className", "inline", "stacked", "children"]);
	    return (React__default.createElement("div", __assign$Z({}, props, { ref: ref, className: classnames(block$y({ stacked: stacked, inline: inline }), className) }), children));
	});
	{
	    try {
	        var PropTypes$S = require("prop-types");
	        ToggleContainer.propTypes = {
	            inline: PropTypes$S.bool,
	            stacked: PropTypes$S.bool,
	            className: PropTypes$S.string,
	            children: PropTypes$S.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$_ = (undefined && undefined.__assign) || function () {
	    __assign$_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$_.apply(this, arguments);
	};
	var __rest$O = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$z = bem("rmd-toggle");
	var InputToggle = React.forwardRef(function InputToggle(allProps, ref) {
	    var _a = allProps, style = _a.style, className = _a.className, iconStyle = _a.iconStyle, iconClassName = _a.iconClassName, toggleStyle = _a.toggleStyle, propToggleClassName = _a.toggleClassName, icon = _a.icon, propOnFocus = _a.onFocus, propOnBlur = _a.onBlur, _b = _a.error, error = _b === void 0 ? false : _b, _c = _a.inline, inline = _c === void 0 ? false : _c, _d = _a.stacked, stacked = _d === void 0 ? false : _d, _e = _a.disabled, disabled = _e === void 0 ? false : _e, label = _a.label, labelStyle = _a.labelStyle, labelClassName = _a.labelClassName, labelDisabled = _a.labelDisabled, _f = _a.iconAfter, iconAfter = _f === void 0 ? false : _f, _g = _a.disableIconOverlay, disableIconOverlay = _g === void 0 ? false : _g, disableRipple = _a.disableRipple, disableProgrammaticRipple = _a.disableProgrammaticRipple, rippleTimeout = _a.rippleTimeout, rippleClassNames = _a.rippleClassNames, children = _a.children, indeterminate = _a.indeterminate, props = __rest$O(_a, ["style", "className", "iconStyle", "iconClassName", "toggleStyle", "toggleClassName", "icon", "onFocus", "onBlur", "error", "inline", "stacked", "disabled", "label", "labelStyle", "labelClassName", "labelDisabled", "iconAfter", "disableIconOverlay", "disableRipple", "disableProgrammaticRipple", "rippleTimeout", "rippleClassNames", "children", "indeterminate"]);
	    var id = props.id, type = props.type;
	    var _h = useInteractionStates({
	        handlers: props,
	        disabled: disabled,
	        className: propToggleClassName,
	        disableRipple: disableRipple,
	        disableProgrammaticRipple: disableProgrammaticRipple,
	        rippleTimeout: rippleTimeout,
	        rippleClassNames: rippleClassNames,
	    }), ripples = _h.ripples, handlers = _h.handlers, toggleClassName = _h.className;
	    var _j = useFocusState({
	        onFocus: propOnFocus,
	        onBlur: propOnBlur,
	    }), focused = _j[0], onFocus = _j[1], onBlur = _j[2];
	    var labelEl = (React__default.createElement(Label, { style: labelStyle, className: labelClassName, htmlFor: id, error: error, disabled: typeof labelDisabled === "boolean" ? labelDisabled : disabled }, label));
	    return (React__default.createElement(ToggleContainer, { style: style, className: className, inline: inline, stacked: stacked },
	        iconAfter && labelEl,
	        React__default.createElement("span", { style: toggleStyle, className: classnames(block$z({
	                focused: focused,
	                disabled: disabled,
	            }), toggleClassName) },
	            React__default.createElement("input", __assign$_({}, props, handlers, { ref: ref, disabled: disabled, onFocus: onFocus, onBlur: onBlur, className: block$z("input") })),
	            React__default.createElement("span", { style: iconStyle, className: classnames(block$z("icon", {
	                    circle: !disableIconOverlay && type === "radio",
	                    disabled: disabled,
	                    overlay: !disableIconOverlay,
	                    indeterminate: indeterminate,
	                }), iconClassName) }, icon),
	            ripples,
	            children),
	        !iconAfter && labelEl));
	});
	{
	    try {
	        var PropTypes$T = require("prop-types");
	        InputToggle.propTypes = {
	            id: PropTypes$T.string.isRequired,
	            style: PropTypes$T.object,
	            className: PropTypes$T.string,
	            type: PropTypes$T.oneOf(["radio", "checkbox"]).isRequired,
	            icon: PropTypes$T.node,
	            iconStyle: PropTypes$T.object,
	            iconClassName: PropTypes$T.string,
	            toggleStyle: PropTypes$T.object,
	            toggleClassName: PropTypes$T.string,
	            error: PropTypes$T.bool,
	            label: PropTypes$T.node,
	            labelStyle: PropTypes$T.object,
	            labelClassName: PropTypes$T.string,
	            labelDisabled: PropTypes$T.bool,
	            inline: PropTypes$T.bool,
	            stacked: PropTypes$T.bool,
	            disabled: PropTypes$T.bool,
	            iconAfter: PropTypes$T.bool,
	            onBlur: PropTypes$T.func,
	            onFocus: PropTypes$T.func,
	            disableIconOverlay: PropTypes$T.bool,
	            disableRipple: PropTypes$T.bool,
	            disableProgrammaticRipple: PropTypes$T.bool,
	            rippleTimeout: PropTypes$T.oneOfType([
	                PropTypes$T.number,
	                PropTypes$T.shape({
	                    appear: PropTypes$T.number,
	                    enter: PropTypes$T.number,
	                    exit: PropTypes$T.number,
	                }),
	            ]),
	            rippleClassNames: PropTypes$T.oneOfType([
	                PropTypes$T.string,
	                PropTypes$T.shape({
	                    appear: PropTypes$T.string,
	                    appearActive: PropTypes$T.string,
	                    enter: PropTypes$T.string,
	                    enterActive: PropTypes$T.string,
	                    enterDone: PropTypes$T.string,
	                    exit: PropTypes$T.string,
	                    exitActive: PropTypes$T.string,
	                    exitDone: PropTypes$T.string,
	                }),
	            ]),
	            children: PropTypes$T.node,
	            indeterminate: PropTypes$T.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$$ = (undefined && undefined.__assign) || function () {
	    __assign$$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$$.apply(this, arguments);
	};
	var __rest$P = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * The `Checkbox` component is just a wrapper for the `InputToggle` that
	 * defaults to reasonable defaults for a checkbox input.
	 */
	var Checkbox = React.forwardRef(function Checkbox(_a, ref) {
	    var propIcon = _a.icon, _b = _a.indeterminate, indeterminate = _b === void 0 ? false : _b, props = __rest$P(_a, ["icon", "indeterminate"]);
	    var icon = useIcon("checkbox", propIcon);
	    return (React__default.createElement(InputToggle, __assign$$({}, props, { icon: icon, ref: ref, type: "checkbox", indeterminate: indeterminate })));
	});
	{
	    try {
	        var PropTypes$U = require("prop-types");
	        Checkbox.propTypes = {
	            indeterminate: PropTypes$U.bool,
	            icon: PropTypes$U.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$10 = (undefined && undefined.__assign) || function () {
	    __assign$10 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$10.apply(this, arguments);
	};
	var __rest$Q = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * The `Radio` component is just a wrapper for the `InputToggle` that
	 * defaults to reasonable defaults for a radio input.
	 */
	var Radio = React.forwardRef(function Radio(_a, ref) {
	    var propIcon = _a.icon, props = __rest$Q(_a, ["icon"]);
	    var icon = useIcon("radio", propIcon);
	    return React__default.createElement(InputToggle, __assign$10({}, props, { icon: icon, ref: ref, type: "radio" }));
	});
	{
	    try {
	        var PropTypes$V = require("prop-types");
	        Radio.propTypes = {
	            id: PropTypes$V.string.isRequired,
	            name: PropTypes$V.string,
	            icon: PropTypes$V.node,
	            value: PropTypes$V.oneOfType([
	                PropTypes$V.arrayOf(PropTypes$V.string),
	                PropTypes$V.string,
	                PropTypes$V.number,
	            ]).isRequired,
	        };
	    }
	    catch (e) { }
	}

	var __assign$11 = (undefined && undefined.__assign) || function () {
	    __assign$11 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$11.apply(this, arguments);
	};
	var __rest$R = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$A = bem("rmd-switch");
	var Switch = React.forwardRef(function Switch(_a, ref) {
	    var style = _a.style, className = _a.className, ballStyle = _a.ballStyle, ballClassName = _a.ballClassName, trackStyle = _a.trackStyle, trackClassName = _a.trackClassName, label = _a.label, labelStyle = _a.labelStyle, labelClassName = _a.labelClassName, labelDisabled = _a.labelDisabled, _b = _a.error, error = _b === void 0 ? false : _b, _c = _a.disabled, disabled = _c === void 0 ? false : _c, _d = _a.stacked, stacked = _d === void 0 ? false : _d, _e = _a.inline, inline = _e === void 0 ? false : _e, _f = _a.iconAfter, iconAfter = _f === void 0 ? false : _f, children = _a.children, props = __rest$R(_a, ["style", "className", "ballStyle", "ballClassName", "trackStyle", "trackClassName", "label", "labelStyle", "labelClassName", "labelDisabled", "error", "disabled", "stacked", "inline", "iconAfter", "children"]);
	    var id = props.id;
	    return (React__default.createElement(ToggleContainer, { style: style, className: classnames("rmd-switch-container", className), inline: inline, stacked: stacked },
	        React__default.createElement(TextIconSpacing, { icon: React__default.createElement(Label, { style: labelStyle, className: labelClassName, htmlFor: id, error: error, disabled: typeof labelDisabled === "boolean" ? labelDisabled : disabled }, label), iconAfter: !iconAfter },
	            React__default.createElement("span", { style: trackStyle, className: classnames(block$A(), trackClassName) },
	                React__default.createElement("input", __assign$11({}, props, { ref: ref, type: "checkbox", className: classnames(block$A("input")), disabled: disabled })),
	                React__default.createElement("label", { htmlFor: id, "aria-hidden": true, style: ballStyle, className: classnames(block$A("ball"), ballClassName) }, children)))));
	});
	{
	    try {
	        var PropTypes$W = require("prop-types");
	        Switch.propTypes = {
	            id: PropTypes$W.string.isRequired,
	            style: PropTypes$W.object,
	            className: PropTypes$W.string,
	            ballStyle: PropTypes$W.object,
	            ballClassName: PropTypes$W.string,
	            trackStyle: PropTypes$W.object,
	            trackClassName: PropTypes$W.string,
	            label: PropTypes$W.node,
	            labelStyle: PropTypes$W.object,
	            labelClassName: PropTypes$W.string,
	            labelDisabled: PropTypes$W.bool,
	            error: PropTypes$W.bool,
	            inline: PropTypes$W.bool,
	            disabled: PropTypes$W.bool,
	            stacked: PropTypes$W.bool,
	            iconAfter: PropTypes$W.bool,
	            children: PropTypes$W.node,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * Gets the current progress based on the min, max, and current value.
	 *
	 * @param min the min progress value
	 * @param max the max progress value
	 * @param value the current value for the progress bar
	 * @return the progress as a percentage or undefined if there was no value
	 * provided
	 */
	function getProgress(min, max, value) {
	    if (min >= max) {
	        throw new RangeError("A progress range must have the min value less than the max value");
	    }
	    if (typeof value !== "number") {
	        return undefined;
	    }
	    if (value > max || value < min) {
	        throw new RangeError("A progress value must be between the min and max values");
	    }
	    var absMin = Math.abs(min);
	    var absMax = Math.abs(max);
	    var absValue = Math.abs(value);
	    var trueMin = Math.min(absMin, absMax);
	    var trueMax = Math.max(absMin, absMax);
	    return Math.max(0, Math.min(1, absValue / (trueMax - trueMin)));
	}

	var __assign$12 = (undefined && undefined.__assign) || function () {
	    __assign$12 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$12.apply(this, arguments);
	};
	var __rest$S = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$B = bem("rmd-linear-progress");
	var LinearProgress = React.forwardRef(function LinearProgress(_a, ref) {
	    var propStyle = _a.style, className = _a.className, propBarStyle = _a.barStyle, barClassName = _a.barClassName, _b = _a.min, min = _b === void 0 ? 0 : _b, _c = _a.max, max = _c === void 0 ? 100 : _c, value = _a.value, _d = _a.reverse, reverse = _d === void 0 ? false : _d, _e = _a.animate, animate = _e === void 0 ? true : _e, _f = _a.vertical, vertical = _f === void 0 ? false : _f, _g = _a.verticalHeight, verticalHeight = _g === void 0 ? 240 : _g, props = __rest$S(_a, ["style", "className", "barStyle", "barClassName", "min", "max", "value", "reverse", "animate", "vertical", "verticalHeight"]);
	    var style = React.useMemo(function () {
	        if (!vertical || verticalHeight === null) {
	            return propStyle;
	        }
	        return __assign$12(__assign$12({}, propStyle), { height: verticalHeight });
	    }, [propStyle, vertical, verticalHeight]);
	    var progress = getProgress(min, max, value);
	    var barStyle = React.useMemo(function () {
	        var _a;
	        if (typeof progress !== "number") {
	            return propBarStyle;
	        }
	        var key = vertical ? "height" : "width";
	        return __assign$12(__assign$12({}, propBarStyle), (_a = {}, _a[key] = progress * 100 + "%", _a));
	    }, [progress, propBarStyle, vertical]);
	    var determinate = typeof progress === "number";
	    var indeterminate = !determinate;
	    return (React__default.createElement("span", __assign$12({}, props, { ref: ref, style: style, role: "progressbar", "aria-valuemin": min, "aria-valuemax": max, "aria-valuenow": value, className: classnames(block$B({
	            vertical: vertical,
	            determinate: determinate,
	            indeterminate: indeterminate,
	        }), className) }),
	        React__default.createElement("span", { style: barStyle, className: classnames(block$B("bar", {
	                vertical: vertical,
	                "vertical-reverse": vertical && reverse,
	                horizontal: !vertical,
	                "horizontal-reverse": !vertical && reverse,
	                animate: animate && determinate,
	                determinate: determinate,
	                indeterminate: indeterminate,
	                "determinate-reverse": determinate && reverse && !vertical,
	                "determinate-vertical-reverse": determinate && reverse && vertical,
	                "indeterminate-reverse": indeterminate && reverse && !vertical,
	                "indeterminate-vertical": indeterminate && vertical,
	                "indeterminate-vertical-reverse": indeterminate && reverse && vertical,
	            }), barClassName) })));
	});
	{
	    try {
	        var PropTypes$X = require("prop-types");
	        LinearProgress.propTypes = {
	            id: PropTypes$X.string.isRequired,
	            style: PropTypes$X.object,
	            className: PropTypes$X.string,
	            min: PropTypes$X.number,
	            max: PropTypes$X.number,
	            value: PropTypes$X.number,
	            animate: PropTypes$X.bool,
	            barStyle: PropTypes$X.object,
	            barClassName: PropTypes$X.string,
	            reverse: PropTypes$X.bool,
	            vertical: PropTypes$X.bool,
	            verticalHeight: PropTypes$X.number,
	        };
	    }
	    catch (e) { }
	}

	var __assign$13 = (undefined && undefined.__assign) || function () {
	    __assign$13 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$13.apply(this, arguments);
	};
	var __rest$T = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$C = bem("rmd-circular-progress");
	var CircularProgress = React.forwardRef(function CircularProgress(_a, ref) {
	    var className = _a.className, propSvgStyle = _a.svgStyle, svgClassName = _a.svgClassName, propCircleStyle = _a.circleStyle, circleClassName = _a.circleClassName, value = _a.value, _b = _a.min, min = _b === void 0 ? 0 : _b, _c = _a.max, max = _c === void 0 ? 100 : _c, _d = _a.radius, radius = _d === void 0 ? 30 : _d, _e = _a.center, center = _e === void 0 ? 33 : _e, _f = _a.viewBox, viewBox = _f === void 0 ? "0 0 66 66" : _f, _g = _a.dashoffset, dashoffset = _g === void 0 ? 187 : _g, _h = _a.animate, animate = _h === void 0 ? true : _h, _j = _a.centered, centered = _j === void 0 ? true : _j, _k = _a.maxRotation, maxRotation = _k === void 0 ? 360 * 1.75 : _k, props = __rest$T(_a, ["className", "svgStyle", "svgClassName", "circleStyle", "circleClassName", "value", "min", "max", "radius", "center", "viewBox", "dashoffset", "animate", "centered", "maxRotation"]);
	    var progress = getProgress(min, max, value);
	    var svgStyle = React.useMemo(function () {
	        if (typeof progress !== "number") {
	            return propSvgStyle;
	        }
	        var transform = propSvgStyle && propSvgStyle.transform;
	        if (maxRotation > 0) {
	            var rotate = "rotate(" + maxRotation * progress + "deg)";
	            transform = "" + rotate + (transform ? " " + transform : "");
	        }
	        return __assign$13(__assign$13({}, propSvgStyle), { WebkitTransform: transform, MozTransform: transform, transform: transform });
	    }, [progress, maxRotation, propSvgStyle]);
	    var circleStyle = React.useMemo(function () {
	        if (typeof progress !== "number") {
	            return propCircleStyle;
	        }
	        return __assign$13(__assign$13({}, propCircleStyle), { strokeDashoffset: dashoffset - dashoffset * progress });
	    }, [progress, propCircleStyle, dashoffset]);
	    var determinate = typeof progress === "number";
	    var indeterminate = !determinate;
	    return (React__default.createElement("span", __assign$13({}, props, { ref: ref, role: "progressbar", "aria-valuemin": min, "aria-valuemax": max, "aria-valuenow": value, className: classnames(block$C({ centered: centered }), className) }),
	        React__default.createElement("svg", { style: svgStyle, className: classnames(block$C("svg", {
	                animate: animate && determinate,
	                determinate: determinate,
	                indeterminate: indeterminate,
	            }), svgClassName), viewBox: viewBox },
	            React__default.createElement("circle", { style: circleStyle, className: classnames(block$C("circle", {
	                    animate: animate && determinate,
	                    determinate: determinate,
	                    indeterminate: indeterminate,
	                }), circleClassName), r: radius, cx: center, cy: center }))));
	});
	{
	    try {
	        var PropTypes$Y = require("prop-types");
	        CircularProgress.propTypes = {
	            id: PropTypes$Y.string.isRequired,
	            className: PropTypes$Y.string,
	            min: PropTypes$Y.number,
	            max: PropTypes$Y.number,
	            value: PropTypes$Y.number,
	            animate: PropTypes$Y.bool,
	            svgStyle: PropTypes$Y.object,
	            svgClassName: PropTypes$Y.string,
	            circleStyle: PropTypes$Y.object,
	            circleClassName: PropTypes$Y.string,
	            radius: PropTypes$Y.number,
	            center: PropTypes$Y.number,
	            centered: PropTypes$Y.bool,
	            maxRotation: PropTypes$Y.number,
	            dashoffset: PropTypes$Y.number,
	            viewBox: PropTypes$Y.string,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * An extremely simple util that can be used to get the required a11y props for
	 * another component that relies on a progress component.
	 *
	 * @param progressId The id for the progress bar
	 * @param progressing Boolean if the progress bar is visible and progressing
	 */
	function getProgressA11y(progressId, progressing) {
	    if (!progressing) {
	        return undefined;
	    }
	    return {
	        "aria-busy": true,
	        "aria-describedby": progressId,
	    };
	}

	var __assign$14 = (undefined && undefined.__assign) || function () {
	    __assign$14 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$14.apply(this, arguments);
	};
	var __rest$U = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	// this is used while the loading state is enabled to "disable" the switch
	// toggle. If we disable the entire switch, keyboard focus is lost which is not
	// desired.
	var noop$2 = function () { };
	/**
	 * This component will create an async switch that will show a loading indicator
	 * and prevent the switch from being toggled while the loading state is true.
	 */
	var AsyncSwitch = React.forwardRef(function AsyncSwitch(_a, ref) {
	    var id = _a.id, disabled = _a.disabled, className = _a.className, progressStyle = _a.progressStyle, progressClassName = _a.progressClassName, loading = _a.loading, onChange = _a.onChange, props = __rest$U(_a, ["id", "disabled", "className", "progressStyle", "progressClassName", "loading", "onChange"]);
	    var progressId = id + "-loading";
	    return (React__default.createElement(Switch, __assign$14({}, props, getProgressA11y(progressId, loading), { id: id, ref: ref, disabled: disabled, className: classnames("rmd-switch--async", className), labelDisabled: disabled || false, onChange: loading ? noop$2 : onChange }), loading && (React__default.createElement(CircularProgress, { id: progressId, style: progressStyle, className: classnames("rmd-switch__progress", progressClassName), centered: false }))));
	});

	/**
	 * A small hook that can be used for controlling the state of a single Checkbox
	 * component.
	 *
	 * @param defaultChecked Boolean if the input should be checked by default.
	 * Changing this value will not update the state after initial render.
	 * @param onChange An optional change event handler to also call when the
	 * checked state changes.
	 * @return a list containing the checked state, a change event handler, and then
	 * a manual set checked action.
	 */
	function useChecked(defaultChecked, onChange) {
	    var _a = React.useState(defaultChecked), checked = _a[0], setChecked = _a[1];
	    var handleChange = React.useCallback(function (event) {
	        if (onChange) {
	            onChange(event);
	        }
	        setChecked(event.currentTarget.checked);
	    }, [onChange]);
	    return [checked, handleChange, setChecked];
	}

	/**
	 * This hook can be used to control the state of a radio group or a select
	 * element.
	 *
	 * @param defaultValue The default value. If you want the user to specifically
	 * choose a value, set this to the empty string.
	 * @param onChange An optional change event handler to also call when the change
	 * event is triggered.
	 * @return a list containing the current value, a change event handler, and then
	 * a manual value setter.
	 */
	function useChoice(defaultValue, onChange) {
	    var _a = React.useState(defaultValue), value = _a[0], setValue = _a[1];
	    var handleChange = React.useCallback(function (event) {
	        if (onChange) {
	            onChange(event);
	        }
	        setValue(event.currentTarget.value);
	    }, [onChange]);
	    return [value, handleChange, setValue];
	}

	/**
	 * This is a simple hook that will allow you to "strongly" type a `Select`
	 * component's value since the `onChange` handler only returns a `string`.
	 *
	 * @param defaultValue The default value to use
	 * @return an ordered list containing the current value followed by the dispatch
	 * function to update the state.
	 */
	function useSelectState(defaultValue) {
	    var _a = React.useState(defaultValue), value = _a[0], setValue = _a[1];
	    var setTypedValue = React.useCallback(function (nextValue) {
	        setValue(nextValue);
	    }, []);
	    return [value, setTypedValue];
	}

	/**
	 * This hook allows you to toggle the state of multiple checkboxes in a single
	 * place along with an indeterminate checkbox that can check/uncheck all
	 * checkboxes at once.
	 *
	 * ### Examples:
	 *
	 * #### Simple value list with labels lookup:
	 *
	 * ```tsx
	 * const values = ["a", "b", "c", "d"];
	 * const LABELS = { a: "Label 1", b: "Label 2", c: "Label 3", d: "Label 4" };
	 * const { getProps, rootProps } = useIndeterminateChecked(values);
	 *
	 * return (
	 *   <>
	 *     <Checkbox id="root-checkbox" {...rootProps} label="Root Checkbox" />
	 *     {values.map((value, i) => (
	 *       <Checkbox
	 *         id={`child-checkbox-${i + 1}`}
	 *         label={LABELS[value]}
	 *         {...getProps(value)}
	 *       />
	 *     ))}
	 *   </>
	 * );
	 * ```
	 *
	 * #### Fetch Data From Server and check first result
	 * ```tsx
	 * interface ServerFetchedData {
	 *   id: Guid;
	 *   name: string;
	 * }
	 *
	 *
	 * const [data, setData] = useState<ServerFetchedData[]>([]);
	 * const { getProps, rootProps, setCheckedValues } = useIndeterminateChecked(
	 *   data.map(({ id }) => id),
	 * );
	 *
	 * useEffect(() => {
	 *   let cancelled = false;
	 *   (async function load() {
	 *     const response = await fetch("/my-api");
	 *     const json = await response.json();
	 *     if (!cancelled) {
	 *       // pretend validation and sanity checks
	 *       setData(json as ServerFetchedData[]);
	 *       setCheckedValues(json[0].id);
	 *     }
	 *   })();

	 *   return () => {
	 *     cancelled = true;
	 *   };
	 * }, []);
	 *
	 * return (
	 *   <>
	 *     <Checkbox id="root-checkbox" {...rootProps} label="Root Checkbox" />
	 *     {data.map(({ id, name }, i) => (
	 *       <Checkbox
	 *         id={`child-checkbox-${i + 1}`}
	 *         label={name}
	 *         {...getProps(id)}
	 *       />
	 *     ))}
	 *   </>
	 * );
	 * ```
	 *
	 * @param values All the checkbox values that the indeterminate checkbox can
	 * control. The values will **need** to be unique as they are passed to each
	 * checkbox to determine if it is checked or not. This will directly map to
	 * the `value` attribute for each checkbox.
	 * @param defaultCheckedValues An optional list of all the values that are
	 * checked on first render. Changing this value will not update the checked
	 * values.
	 * @param onChange An optional function to call whenever the checked values list
	 * updates that will provide the next list of all the checked values. This isn't
	 * a super helpful prop since this hook will always return the checked values
	 * anyways.
	 * @return An object containing a function to get the props for each controlled
	 * checkbox, the props for the root indeterminate checkbox, a list of all the
	 * checked values, and a general `setCheckboxValues` function from `useState` if
	 * the list of values can be changed from external sources as well.
	 */
	function useIndeterminateChecked(values, defaultCheckedValues, onChange) {
	    if (defaultCheckedValues === void 0) { defaultCheckedValues = []; }
	    var _a = React.useState(defaultCheckedValues), checkedValues = _a[0], setCheckedValues = _a[1];
	    var checked = checkedValues.length > 0;
	    var indeterminate = checked && checkedValues.length < values.length;
	    var updateCheckedValues = function (values) {
	        if (onChange) {
	            onChange(values);
	        }
	        setCheckedValues(values);
	    };
	    var rootProps = {
	        "aria-checked": indeterminate ? "mixed" : undefined,
	        checked: checked,
	        indeterminate: indeterminate,
	        onChange: function () {
	            return updateCheckedValues(checkedValues.length === 0 || indeterminate ? values : []);
	        },
	    };
	    var getProps = function (value) { return ({
	        value: value,
	        checked: checkedValues.includes(value),
	        onChange: function () {
	            var i = checkedValues.indexOf(value);
	            var nextChecked = checkedValues.slice();
	            if (i === -1) {
	                nextChecked.push(value);
	            }
	            else {
	                nextChecked.splice(i, 1);
	            }
	            updateCheckedValues(nextChecked);
	        },
	    }); };
	    return {
	        getProps: getProps,
	        rootProps: rootProps,
	        checkedValues: checkedValues,
	        setCheckedValues: setCheckedValues,
	    };
	}

	/**
	 * The `HighlightedResult` component can be used to bold specific letters
	 * within the `children` if the `children` is a string.
	 */
	var HighlightedResult = function (_a) {
	    var propId = _a.id, style = _a.style, className = _a.className, _b = _a.enabled, enabled = _b === void 0 ? true : _b, value = _a.value, children = _a.children, _c = _a.repeatable, repeatable = _c === void 0 ? false : _c, _d = _a.index, index = _d === void 0 ? 0 : _d;
	    if (!enabled || !value || typeof children !== "string") {
	        return React__default.createElement(React__default.Fragment, null, children);
	    }
	    var i = children.toLowerCase().indexOf(value.toLowerCase());
	    if (i === -1) {
	        return React__default.createElement(React__default.Fragment, null, children);
	    }
	    var end = i + value.length;
	    var id = propId;
	    if (id && index > 0) {
	        id = id + "-" + index;
	    }
	    return (React__default.createElement(React__default.Fragment, null,
	        i > 0 && children.substring(0, i),
	        React__default.createElement("span", { id: id, style: style, className: classnames("rmd-typography--bold", className) }, children.substring(i, end)),
	        end < children.length && (React__default.createElement(HighlightedResult, { style: style, className: className, value: value, enabled: enabled && repeatable, repeatable: repeatable, index: index + 1 }, children.substring(end)))));
	};
	{
	    try {
	        var PropTypes$Z = require("prop-types");
	        HighlightedResult.propTypes = {
	            id: PropTypes$Z.string,
	            index: PropTypes$Z.number,
	            value: PropTypes$Z.string.isRequired,
	            style: PropTypes$Z.object,
	            className: PropTypes$Z.string,
	            children: PropTypes$Z.node,
	            enabled: PropTypes$Z.bool,
	            repeatable: PropTypes$Z.bool,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * Generates an id for each result in the autocomplete's listbox.
	 *
	 * @param id The listbox's id
	 * @param index The index of the result in the list
	 * @return an id string
	 */
	function getResultId(id, index) {
	    return id + "-result-" + (index + 1);
	}
	/**
	 * Gets a renderable label for each result in the autocomplete's listbox. This
	 * will be applied as the `children` for the `Option` element.
	 *
	 * @param datum The current result datum to get a label for
	 * @param labelKey The key to extract a label from if the datum is an object
	 * @param query The current search query. This is useful if you want to
	 * implement text "highlighting" (bold) of all the letters that match in the
	 * item.
	 * @return a renderable node to display
	 */
	function getResultLabel(datum, labelKey, _query) {
	    if (typeof datum === "string") {
	        return datum;
	    }
	    var label = datum[labelKey];
	    return datum.children || (typeof label === "undefined" ? null : label);
	}
	/**
	 * Gets a value string from each result that can be searched.
	 *
	 * @param datum The current result datum that should have a string extracted
	 * @param valueKey The key to use to extract a string value from if the datum is
	 * an object
	 * @return a searchable string.
	 */
	function getResultValue(datum, valueKey) {
	    if (typeof datum === "string") {
	        return datum;
	    }
	    var value = datum[valueKey];
	    if (
	        typeof value !== "string" &&
	        typeof value !== "number") {
	        throw new Error("Unable to extract a result value string");
	    }
	    return "" + value;
	}
	/**
	 * This is used to disable filtering and just return the data list immediately.
	 * Useful when the filtering is done somewhere else like a server/API
	 * @private
	 */
	var noFilter = function (_, data) { return data; };
	/**
	 * Gets the filter function to use within the Autocomplete based on the provided
	 * filter prop
	 *
	 * @private
	 */
	function getFilterFunction(filter) {
	    if (typeof filter === "function") {
	        return filter;
	    }
	    switch (filter) {
	        case "fuzzy":
	            return fuzzyFilter;
	        case "case-insensitive":
	            return caseInsensitiveFilter;
	        case "none":
	            return noFilter;
	        default:
	            {
	                throw new Error("Invalid filter function: \"" + filter + "\". Supported values are: \"fuzzy\", \"case-insenitive\", \"none\", or a custom function.");
	            }
	    }
	}
	/**
	 * This is an extremely simple type guard that is useful when using the
	 * `onAutoComplete` handler since I'm terrible at typescript types. This will
	 * ensure that if the result is an object, it will match the provided data type
	 * of your data list.
	 *
	 * Example:
	 *
	 * ```ts
	 * interface Example {
	 *   name: string;
	 *   value: string;
	 * }
	 *
	 *
	 * const [example, setExample] = useState<Example | null>(null);
	 * const onAutoComplete = useCallback<AuoCompleteHandler>((_name, example) => {
	 *   if (isResultOf<Example>(example)) {
	 *     setExample(example);
	 *   }
	 * }, [])
	 * ```
	 *
	 * @param datum The result data to type guard against.
	 */
	function isResultOf(datum) {
	    return !!datum && typeof datum === "object";
	}

	var __assign$15 = (undefined && undefined.__assign) || function () {
	    __assign$15 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$15.apply(this, arguments);
	};
	/**
	 * This hook handles all the autocomplete's "logic" and behavior.
	 *
	 * @private
	 */
	function useAutoComplete(_a) {
	    var _b;
	    var suggestionsId = _a.suggestionsId, data = _a.data, propValue = _a.propValue, _c = _a.defaultValue, defaultValue = _c === void 0 ? "" : _c, filterFn = _a.filter, filterOptions = _a.filterOptions, filterOnNoValue = _a.filterOnNoValue, valueKey = _a.valueKey, getResultId = _a.getResultId, getResultValue = _a.getResultValue, onBlur = _a.onBlur, onFocus = _a.onFocus, onClick = _a.onClick, onChange = _a.onChange, onKeyDown = _a.onKeyDown, forwardedRef = _a.forwardedRef, onAutoComplete = _a.onAutoComplete, clearOnAutoComplete = _a.clearOnAutoComplete, anchor = _a.anchor, xMargin = _a.xMargin, yMargin = _a.yMargin, vwMargin = _a.vwMargin, vhMargin = _a.vhMargin, transformOrigin = _a.transformOrigin, listboxWidth = _a.listboxWidth, listboxStyle = _a.listboxStyle, preventOverlap = _a.preventOverlap, disableSwapping = _a.disableSwapping, disableVHBounds = _a.disableVHBounds, closeOnResize = _a.closeOnResize, closeOnScroll = _a.closeOnScroll, propDisableShowOnFocus = _a.disableShowOnFocus, isListAutocomplete = _a.isListAutocomplete, isInlineAutocomplete = _a.isInlineAutocomplete;
	    var inputRef = React.useRef(null);
	    var ref = React.useCallback(function (instance) {
	        applyRef(instance, forwardedRef);
	        inputRef.current = instance;
	    }, [forwardedRef]);
	    var filter = getFilterFunction(filterFn);
	    var _d = React.useState(function () {
	        var _a;
	        var options = __assign$15(__assign$15({}, filterOptions), { valueKey: valueKey, getItemValue: getResultValue, startsWith: (_a = filterOptions === null || filterOptions === void 0 ? void 0 : filterOptions.startsWith) !== null && _a !== void 0 ? _a : isInlineAutocomplete });
	        var value = propValue !== null && propValue !== void 0 ? propValue : defaultValue;
	        var filteredData = filterOnNoValue || value ? filter(value, data, options) : data;
	        var match = value;
	        if (isInlineAutocomplete && filteredData.length) {
	            match = getResultValue(filteredData[0], valueKey);
	        }
	        return {
	            value: value,
	            match: match,
	            filteredData: filteredData,
	        };
	    }), _e = _d[0], stateValue = _e.value, match = _e.match, stateFilteredData = _e.filteredData, setState = _d[1];
	    var filteredData = filterFn === "none" ? data : stateFilteredData;
	    var startsWith = (_b = filterOptions === null || filterOptions === void 0 ? void 0 : filterOptions.startsWith) !== null && _b !== void 0 ? _b : isInlineAutocomplete;
	    var value = propValue !== null && propValue !== void 0 ? propValue : stateValue;
	    var setValue = React.useCallback(function (nextValue) {
	        var isBackspace = value.length > nextValue.length ||
	            (!!match && value.length === nextValue.length);
	        var filtered = data;
	        if (nextValue || filterOnNoValue) {
	            var options = __assign$15(__assign$15({}, filterOptions), { valueKey: valueKey, getItemValue: getResultValue, startsWith: startsWith });
	            filtered = filter(nextValue, data, options);
	        }
	        var nextMatch = nextValue;
	        if (isInlineAutocomplete && filtered.length && !isBackspace) {
	            nextMatch = getResultValue(filtered[0], valueKey);
	            var input = inputRef.current;
	            if (input && !isBackspace) {
	                input.value = nextMatch;
	                input.setSelectionRange(nextValue.length, nextMatch.length);
	            }
	        }
	        setState({ value: nextValue, match: nextMatch, filteredData: filtered });
	    }, [
	        data,
	        filter,
	        filterOnNoValue,
	        filterOptions,
	        isInlineAutocomplete,
	        getResultValue,
	        value,
	        match,
	        startsWith,
	        valueKey,
	    ]);
	    // this is really just a hacky way to make sure that once a value has been
	    // autocompleted, the menu doesn't immediately re-appear due to the hook below
	    // for showing when the value/ filtered data list change
	    var autocompleted = React.useRef(false);
	    var handleChange = React.useCallback(function (event) {
	        if (onChange) {
	            onChange(event);
	        }
	        autocompleted.current = false;
	        setValue(event.currentTarget.value);
	    }, [setValue, onChange]);
	    var _f = useToggle(false), visible = _f[0], show = _f[1], hide = _f[2];
	    var isTouch = useIsUserInteractionMode("touch");
	    var disableShowOnFocus = propDisableShowOnFocus !== null && propDisableShowOnFocus !== void 0 ? propDisableShowOnFocus : isTouch;
	    var focused = React.useRef(false);
	    var handleBlur = React.useCallback(function (event) {
	        if (onBlur) {
	            onBlur(event);
	        }
	        focused.current = false;
	    }, [onBlur]);
	    var handleFocus = React.useCallback(function (event) {
	        if (onFocus) {
	            onFocus(event);
	        }
	        if (disableShowOnFocus) {
	            return;
	        }
	        focused.current = true;
	        if (isListAutocomplete && filteredData.length) {
	            show();
	        }
	    }, [filteredData, isListAutocomplete, onFocus, show, disableShowOnFocus]);
	    var handleClick = React.useCallback(function (event) {
	        if (onClick) {
	            onClick(event);
	        }
	        // since click events also trigger focus events right beforehand, want to
	        // skip the first click handler and require a second click to show it.
	        // this is why the focused.current isn't set onFocus for
	        // disableShowOnFocus
	        if (disableShowOnFocus && !focused.current) {
	            focused.current = true;
	            return;
	        }
	        if (isListAutocomplete && filteredData.length) {
	            show();
	        }
	    }, [disableShowOnFocus, filteredData.length, isListAutocomplete, onClick, show]);
	    var handleAutoComplete = React.useCallback(function (index) {
	        var result = filteredData[index];
	        var resultValue = getResultValue(result, valueKey);
	        if (onAutoComplete) {
	            onAutoComplete({
	                value: resultValue,
	                index: index,
	                result: result,
	                dataIndex: data.findIndex(function (datum) { return getResultValue(datum, valueKey) === resultValue; }),
	                filteredData: filteredData,
	            });
	        }
	        setValue(clearOnAutoComplete ? "" : resultValue);
	        autocompleted.current = true;
	    }, [
	        clearOnAutoComplete,
	        data,
	        filteredData,
	        getResultValue,
	        onAutoComplete,
	        valueKey,
	        setValue,
	    ]);
	    var listboxRef = React.useRef(null);
	    var _g = useActiveDescendantMovement(__assign$15(__assign$15({}, VERTICAL_COMBOBOX), { getId: getResultId, items: filteredData, baseId: suggestionsId, onChange: function (_a, itemRefs) {
	            var index = _a.index, items = _a.items, target = _a.target;
	            // the default scroll into view behavior for aria-activedescendant
	            // movement won't work here since the "target" element will actually be
	            // the input element instead of the listbox. So need to implement the
	            // scroll into view behavior manually from the listbox instead.
	            var item = itemRefs[index] && itemRefs[index].current;
	            var listbox = listboxRef.current;
	            if (item && listbox && listbox.scrollHeight > listbox.offsetHeight) {
	                scrollIntoView(listbox, item);
	            }
	            if (!isInlineAutocomplete) {
	                return;
	            }
	            var nextMatch = getResultValue(items[index], valueKey);
	            target.value = nextMatch;
	            target.setSelectionRange(0, nextMatch.length);
	            setState(function (prevState) { return (__assign$15(__assign$15({}, prevState), { value: nextMatch, match: nextMatch })); });
	        },
	        onKeyDown: function (event) {
	            if (onKeyDown) {
	                onKeyDown(event);
	            }
	            var input = event.currentTarget;
	            switch (event.key) {
	                case "ArrowDown":
	                    if (isListAutocomplete &&
	                        event.altKey &&
	                        !visible &&
	                        filteredData.length) {
	                        // don't want the cursor to move if there is text
	                        event.preventDefault();
	                        event.stopPropagation();
	                        show();
	                        setFocusedIndex(-1);
	                    }
	                    break;
	                case "ArrowUp":
	                    if (isListAutocomplete && event.altKey && visible) {
	                        // don't want the cursor to move if there is text
	                        event.preventDefault();
	                        event.stopPropagation();
	                        hide();
	                    }
	                    break;
	                case "Tab":
	                    event.stopPropagation();
	                    hide();
	                    break;
	                case "ArrowRight":
	                    if (isInlineAutocomplete &&
	                        input.selectionStart !== input.selectionEnd) {
	                        var index = focusedIndex !== -1 ? focusedIndex : 0;
	                        hide();
	                        handleAutoComplete(index);
	                    }
	                    break;
	                case "Enter":
	                    if (visible && focusedIndex >= 0) {
	                        event.stopPropagation();
	                        handleAutoComplete(focusedIndex);
	                        hide();
	                    }
	                    break;
	                case "Escape":
	                    if (visible) {
	                        event.stopPropagation();
	                        hide();
	                    }
	                    else if (value) {
	                        event.stopPropagation();
	                        setValue("");
	                    }
	                    break;
	                // no default
	            }
	        } })), activeId = _g.activeId, itemRefs = _g.itemRefs, handleKeyDown = _g.onKeyDown, focusedIndex = _g.focusedIndex, setFocusedIndex = _g.setFocusedIndex;
	    useCloseOnOutsideClick({
	        enabled: visible,
	        element: inputRef.current,
	        onOutsideClick: hide,
	    });
	    var _h = useFixedPositioning({
	        fixedTo: function () { return inputRef.current; },
	        anchor: anchor,
	        onScroll: function (_event, _a) {
	            var visible = _a.visible;
	            if (closeOnScroll || !visible) {
	                hide();
	            }
	        },
	        onResize: closeOnResize ? hide : undefined,
	        width: listboxWidth,
	        xMargin: xMargin,
	        yMargin: yMargin,
	        vwMargin: vwMargin,
	        vhMargin: vhMargin,
	        transformOrigin: transformOrigin,
	        preventOverlap: preventOverlap,
	        disableSwapping: disableSwapping,
	        disableVHBounds: disableVHBounds,
	    }), style = _h.style, onEnter = _h.onEnter, onEntering = _h.onEntering, onEntered = _h.onEntered, onExited = _h.onExited, updateStyle = _h.updateStyle;
	    React.useEffect(function () {
	        if (!focused.current || autocompleted.current) {
	            return;
	        }
	        if (filteredData.length && !visible && value.length && isListAutocomplete) {
	            show();
	        }
	        else if (!filteredData.length && visible) {
	            hide();
	        }
	        // this effect is just for toggling the visibility states as needed if the
	        // value or filter data list changes
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [filteredData, value]);
	    React.useEffect(function () {
	        if (!visible) {
	            setFocusedIndex(-1);
	            return;
	        }
	        updateStyle();
	        // only want to trigger on data changes and setFocusedIndex shouldn't change
	        // anyways
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [visible, filteredData]);
	    return {
	        ref: ref,
	        value: value,
	        match: match,
	        visible: visible,
	        activeId: activeId,
	        itemRefs: itemRefs,
	        filteredData: filteredData,
	        fixedStyle: __assign$15(__assign$15({}, style), listboxStyle),
	        transitionHooks: {
	            onEnter: onEnter,
	            onEntering: onEntering,
	            onEntered: onEntered,
	            onExited: onExited,
	        },
	        listboxRef: listboxRef,
	        handleBlur: handleBlur,
	        handleFocus: handleFocus,
	        handleClick: handleClick,
	        handleChange: handleChange,
	        handleKeyDown: handleKeyDown,
	        handleAutoComplete: handleAutoComplete,
	    };
	}

	var __assign$16 = (undefined && undefined.__assign) || function () {
	    __assign$16 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$16.apply(this, arguments);
	};
	var __rest$V = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var __spreadArrays$3 = (undefined && undefined.__spreadArrays) || function () {
	    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	    for (var r = Array(s), k = 0, i = 0; i < il; i++)
	        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
	            r[k] = a[j];
	    return r;
	};
	var block$D = bem("rmd-autocomplate");
	var listbox = bem("rmd-listbox");
	var DEFAULT_FILTER_OPTIONS = {
	    trim: true,
	    ignoreWhitespace: true,
	};
	var EMPTY_LIST = [];
	/**
	 * An AutoComplete is an accessible combobox widget that allows for real-time
	 * suggestions as the user types.
	 */
	var AutoComplete = React.forwardRef(function AutoComplete(_a, forwardedRef) {
	    var _b = _a.autoComplete, autoComplete = _b === void 0 ? "list" : _b, data = _a.data, _c = _a.filter, filter = _c === void 0 ? "case-insensitive" : _c, _d = _a.filterOptions, filterOptions = _d === void 0 ? DEFAULT_FILTER_OPTIONS : _d, _e = _a.filterOnNoValue, filterOnNoValue = _e === void 0 ? false : _e, className = _a.className, onBlur = _a.onBlur, onFocus = _a.onFocus, onClick = _a.onClick, onKeyDown = _a.onKeyDown, onChange = _a.onChange, containerProps = _a.containerProps, _f = _a.portal, portal = _f === void 0 ? false : _f, portalInto = _a.portalInto, portalIntoId = _a.portalIntoId, listboxStyle = _a.listboxStyle, listboxClassName = _a.listboxClassName, onAutoComplete = _a.onAutoComplete, _g = _a.clearOnAutoComplete, clearOnAutoComplete = _g === void 0 ? false : _g, _h = _a.labelKey, labelKey = _h === void 0 ? "label" : _h, _j = _a.valueKey, valueKey = _j === void 0 ? "value" : _j, _k = _a.getResultId, getResultId$1 = _k === void 0 ? getResultId : _k, _l = _a.getResultLabel, getResultLabel$1 = _l === void 0 ? getResultLabel : _l, _m = _a.getResultValue, getResultValue$1 = _m === void 0 ? getResultValue : _m, _o = _a.highlight, highlight = _o === void 0 ? false : _o, _p = _a.highlightReapeating, highlightReapeating = _p === void 0 ? false : _p, highlightStyle = _a.highlightStyle, highlightClassName = _a.highlightClassName, _q = _a.anchor, anchor = _q === void 0 ? BELOW_CENTER_ANCHOR : _q, _r = _a.listboxWidth, listboxWidth = _r === void 0 ? "equal" : _r, _s = _a.xMargin, xMargin = _s === void 0 ? 0 : _s, _t = _a.yMargin, yMargin = _t === void 0 ? 0 : _t, _u = _a.vwMargin, vwMargin = _u === void 0 ? 16 : _u, _v = _a.vhMargin, vhMargin = _v === void 0 ? 16 : _v, _w = _a.transformOrigin, transformOrigin = _w === void 0 ? true : _w, _x = _a.preventOverlap, preventOverlap = _x === void 0 ? true : _x, _y = _a.disableVHBounds, disableVHBounds = _y === void 0 ? false : _y, _z = _a.disableSwapping, disableSwapping = _z === void 0 ? true : _z, disableShowOnFocus = _a.disableShowOnFocus, _0 = _a.closeOnResize, closeOnResize = _0 === void 0 ? false : _0, _1 = _a.closeOnScroll, closeOnScroll = _1 === void 0 ? false : _1, _2 = _a.omitKeys, omitKeys = _2 === void 0 ? EMPTY_LIST : _2, propValue = _a.value, defaultValue = _a.defaultValue, beforeResultsChildren = _a.beforeResultsChildren, afterResultsChildren = _a.afterResultsChildren, props = __rest$V(_a, ["autoComplete", "data", "filter", "filterOptions", "filterOnNoValue", "className", "onBlur", "onFocus", "onClick", "onKeyDown", "onChange", "containerProps", "portal", "portalInto", "portalIntoId", "listboxStyle", "listboxClassName", "onAutoComplete", "clearOnAutoComplete", "labelKey", "valueKey", "getResultId", "getResultLabel", "getResultValue", "highlight", "highlightReapeating", "highlightStyle", "highlightClassName", "anchor", "listboxWidth", "xMargin", "yMargin", "vwMargin", "vhMargin", "transformOrigin", "preventOverlap", "disableVHBounds", "disableSwapping", "disableShowOnFocus", "closeOnResize", "closeOnScroll", "omitKeys", "value", "defaultValue", "beforeResultsChildren", "afterResultsChildren"]);
	    var id = props.id;
	    var comboboxId = id + "-combobox";
	    var suggestionsId = id + "-listbox";
	    var isListAutocomplete = autoComplete === "list" || autoComplete === "both";
	    var isInlineAutocomplete = autoComplete === "inline" || autoComplete === "both";
	    var _3 = useAutoComplete({
	        suggestionsId: suggestionsId,
	        defaultValue: defaultValue,
	        data: data,
	        filter: filter,
	        filterOptions: filterOptions,
	        filterOnNoValue: filterOnNoValue,
	        valueKey: valueKey,
	        getResultId: getResultId$1,
	        getResultValue: getResultValue$1,
	        onBlur: onBlur,
	        onFocus: onFocus,
	        onClick: onClick,
	        onChange: onChange,
	        onKeyDown: onKeyDown,
	        forwardedRef: forwardedRef,
	        onAutoComplete: onAutoComplete,
	        clearOnAutoComplete: clearOnAutoComplete,
	        isListAutocomplete: isListAutocomplete,
	        isInlineAutocomplete: isInlineAutocomplete,
	        anchor: anchor,
	        xMargin: xMargin,
	        yMargin: yMargin,
	        vwMargin: vwMargin,
	        vhMargin: vhMargin,
	        transformOrigin: transformOrigin,
	        listboxWidth: listboxWidth,
	        listboxStyle: listboxStyle,
	        preventOverlap: preventOverlap,
	        disableSwapping: disableSwapping,
	        disableVHBounds: disableVHBounds,
	        closeOnResize: closeOnResize,
	        closeOnScroll: closeOnScroll,
	        disableShowOnFocus: disableShowOnFocus,
	    }), ref = _3.ref, match = _3.match, value = _3.value, visible = _3.visible, activeId = _3.activeId, itemRefs = _3.itemRefs, filteredData = _3.filteredData, listboxRef = _3.listboxRef, fixedStyle = _3.fixedStyle, transitionHooks = _3.transitionHooks, handleBlur = _3.handleBlur, handleFocus = _3.handleFocus, handleClick = _3.handleClick, handleChange = _3.handleChange, handleKeyDown = _3.handleKeyDown, handleAutoComplete = _3.handleAutoComplete;
	    return (React__default.createElement(React__default.Fragment, null,
	        React__default.createElement(TextField, __assign$16({}, props, { "aria-autocomplete": autoComplete, "aria-controls": comboboxId, "aria-activedescendant": activeId, autoComplete: "off", value: propValue !== null && propValue !== void 0 ? propValue : match, onBlur: handleBlur, onFocus: handleFocus, onClick: handleClick, onKeyDown: handleKeyDown, onChange: handleChange, ref: ref, className: classnames(block$D(), className), containerProps: __assign$16(__assign$16({}, containerProps), { "aria-haspopup": "listbox", "aria-owns": suggestionsId, "aria-expanded": visible, id: comboboxId, role: "combobox" }) })),
	        React__default.createElement(ScaleTransition, __assign$16({ portal: portal, portalInto: portalInto, portalIntoId: portalIntoId, vertical: true, visible: visible }, transitionHooks),
	            React__default.createElement(List, { id: suggestionsId, role: "listbox", ref: listboxRef, style: fixedStyle, className: classnames(listbox({ temporary: true }), listboxClassName) },
	                beforeResultsChildren,
	                filteredData.map(function (datum, i) {
	                    var resultId = getResultId$1(suggestionsId, i);
	                    var optionProps;
	                    if (isListboxOptionProps(datum)) {
	                        optionProps = omit(datum, __spreadArrays$3([labelKey, valueKey], omitKeys));
	                    }
	                    return (React__default.createElement(Option, __assign$16({ key: resultId }, optionProps, { id: resultId, selected: false, focused: resultId === activeId, ref: itemRefs[i], onClick: function () { return handleAutoComplete(i); } }),
	                        React__default.createElement(HighlightedResult, { id: resultId + "-match", style: highlightStyle, className: highlightClassName, value: propValue !== null && propValue !== void 0 ? propValue : value, enabled: highlight, repeatable: highlightReapeating }, getResultLabel$1(datum, labelKey, value))));
	                }),
	                afterResultsChildren))));
	});
	{
	    try {
	        var PropTypes$_ = require("prop-types");
	        AutoComplete.propTypes = {
	            id: PropTypes$_.string.isRequired,
	            data: PropTypes$_.arrayOf(PropTypes$_.oneOfType([PropTypes$_.string, PropTypes$_.object])).isRequired,
	            filter: PropTypes$_.oneOfType([
	                PropTypes$_.oneOf(["none", "fuzzy", "case-insensitive"]),
	                PropTypes$_.func,
	            ]),
	            filterOptions: PropTypes$_.object,
	            filterOnNoValue: PropTypes$_.bool,
	            labelKey: PropTypes$_.string,
	            valueKey: PropTypes$_.string,
	            getResultId: PropTypes$_.func,
	            getResultLabel: PropTypes$_.func,
	            getResultValue: PropTypes$_.func,
	            highlight: PropTypes$_.bool,
	            autoComplete: PropTypes$_.oneOf(["none", "inline", "list", "both"]),
	            onAutoComplete: PropTypes$_.func,
	            clearOnAutoComplete: PropTypes$_.bool,
	            portal: PropTypes$_.bool,
	            portalInto: PropTypes$_.oneOfType([
	                PropTypes$_.func,
	                PropTypes$_.string,
	                PropTypes$_.object,
	            ]),
	            portalIntoId: PropTypes$_.string,
	            anchor: PropTypes$_.shape({
	                x: PropTypes$_.oneOf([
	                    "inner-left",
	                    "inner-right",
	                    "center",
	                    "left",
	                    "right",
	                ]),
	                y: PropTypes$_.oneOf(["above", "below", "center", "top", "bottom"]),
	            }),
	            listboxWidth: PropTypes$_.oneOf(["auto", "equal", "min"]),
	            vwMargin: PropTypes$_.number,
	            vhMargin: PropTypes$_.number,
	            xMargin: PropTypes$_.number,
	            yMargin: PropTypes$_.number,
	            transformOrigin: PropTypes$_.bool,
	            preventOverlap: PropTypes$_.bool,
	            disableSwapping: PropTypes$_.bool,
	            disableVHBounds: PropTypes$_.bool,
	            closeOnResize: PropTypes$_.bool,
	            closeOnScroll: PropTypes$_.bool,
	            style: PropTypes$_.object,
	            className: PropTypes$_.string,
	            inputStyle: PropTypes$_.object,
	            inputClassName: PropTypes$_.string,
	            labelStyle: PropTypes$_.object,
	            labelClassName: PropTypes$_.string,
	            label: PropTypes$_.node,
	            theme: PropTypes$_.oneOf(["none", "underline", "filled", "outline"]),
	            dense: PropTypes$_.bool,
	            error: PropTypes$_.bool,
	            inline: PropTypes$_.bool,
	            disabled: PropTypes$_.bool,
	            placeholder: PropTypes$_.string,
	            underlineDirection: PropTypes$_.oneOf(["left", "center", "right"]),
	            leftChildren: PropTypes$_.node,
	            rightChildren: PropTypes$_.node,
	            isLeftAddon: PropTypes$_.bool,
	            isRightAddon: PropTypes$_.bool,
	            onBlur: PropTypes$_.func,
	            onFocus: PropTypes$_.func,
	            onClick: PropTypes$_.func,
	            onKeyDown: PropTypes$_.func,
	            onChange: PropTypes$_.func,
	            containerProps: PropTypes$_.object,
	            listboxStyle: PropTypes$_.object,
	            listboxClassName: PropTypes$_.string,
	            highlightReapeating: PropTypes$_.bool,
	            highlightStyle: PropTypes$_.object,
	            highlightClassName: PropTypes$_.string,
	            disableShowOnFocus: PropTypes$_.bool,
	            omitKeys: PropTypes$_.arrayOf(PropTypes$_.string),
	            value: PropTypes$_.string,
	            defaultValue: PropTypes$_.string,
	            beforeResultsChildren: PropTypes$_.node,
	            afterResultsChildren: PropTypes$_.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$17 = (undefined && undefined.__assign) || function () {
	    __assign$17 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$17.apply(this, arguments);
	};
	var __rest$W = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$E = bem("rmd-avatar");
	/**
	 * An `Avatar` is generally used to represent objects or people within your app.
	 * The avatar can consist of an image, an icon, or some text to display. When
	 * the avatar is not an image, different themes can be applied to make the
	 * avatar more unique.
	 */
	var Avatar = React.forwardRef(function Avatar(_a, ref) {
	    var _b;
	    var className = _a.className, children = _a.children, src = _a.src, _c = _a.alt, alt = _c === void 0 ? "" : _c, _d = _a.color, color = _d === void 0 ? "" : _d, props = __rest$W(_a, ["className", "children", "src", "alt", "color"]);
	    var img;
	    if (src) {
	        img = React__default.createElement("img", { src: src, alt: alt, className: block$E("image") });
	    }
	    return (React__default.createElement("span", __assign$17({}, props, { ref: ref, className: classnames(block$E((_b = {}, _b[color] = color, _b)), className) }),
	        img,
	        children));
	});
	{
	    try {
	        var PropTypes$$ = require("prop-types");
	        Avatar.propTypes = {
	            alt: PropTypes$$.string,
	            src: PropTypes$$.string,
	            color: PropTypes$$.string,
	            className: PropTypes$$.string,
	            children: PropTypes$$.node,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * A small util to check if the badge is considered empty.
	 *
	 * @private
	 */
	function isEmpty(children, disableNullOnZero) {
	    return (!disableNullOnZero &&
	        (children === 0 || children === "0" || children === null));
	}

	var __assign$18 = (undefined && undefined.__assign) || function () {
	    __assign$18 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$18.apply(this, arguments);
	};
	var __rest$X = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$F = bem("rmd-badge");
	/**
	 * This component is generally used for displaying notifications with a count
	 * relative to another element with the `BadgeContainer` component. However, it
	 * can be used by itself to display any subpplementary content if needed.
	 */
	var Badge = React.forwardRef(function Badge(_a, ref) {
	    var _b;
	    var className = _a.className, _c = _a.theme, theme = _c === void 0 ? "default" : _c, _d = _a.children, children = _d === void 0 ? null : _d, _e = _a.disableNullOnZero, disableNullOnZero = _e === void 0 ? false : _e, props = __rest$X(_a, ["className", "theme", "children", "disableNullOnZero"]);
	    if (isEmpty(children, disableNullOnZero)) {
	        return null;
	    }
	    return (React__default.createElement("span", __assign$18({}, props, { ref: ref, className: classnames(block$F((_b = {}, _b[theme] = theme !== "clear", _b)), className) }), children));
	});
	{
	    try {
	        var PropTypes$10 = require("prop-types");
	        Badge.propTypes = {
	            id: PropTypes$10.string.isRequired,
	            theme: PropTypes$10.oneOf(["primary", "secondary", "default", "clear"]),
	            className: PropTypes$10.string,
	            children: PropTypes$10.node,
	            disableNullOnZero: PropTypes$10.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$19 = (undefined && undefined.__assign) || function () {
	    __assign$19 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$19.apply(this, arguments);
	};
	var __rest$Y = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$G = bem("rmd-badge-container");
	/**
	 * This is a really simple component that will just allow you to position a
	 * badge relative to another component.
	 */
	var BadgeContainer = React.forwardRef(function BadgeContainer(_a, ref) {
	    var className = _a.className, children = _a.children, props = __rest$Y(_a, ["className", "children"]);
	    return (React__default.createElement("span", __assign$19({}, props, { className: classnames(block$G(), className), ref: ref }), children));
	});

	var __assign$1a = (undefined && undefined.__assign) || function () {
	    __assign$1a = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1a.apply(this, arguments);
	};
	var __rest$Z = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This is a small wrapper for the `Button` component that will automatically
	 * apply the `aria-describedby` attribute when it has been "badged". It also
	 * adds some reasonable defaults for the most common use-case for badges:
	 * notifications.
	 */
	var BadgedButton = React.forwardRef(function BadgedButton(_a, ref) {
	    var _b = _a["aria-label"], ariaLabel = _b === void 0 ? "Notifications" : _b, badgeStyle = _a.badgeStyle, badgeClassName = _a.badgeClassName, badgeRef = _a.badgeRef, propBadgeId = _a.badgeId, propButtonChildren = _a.buttonChildren, _c = _a.buttonType, buttonType = _c === void 0 ? "icon" : _c, badgeTheme = _a.badgeTheme, _d = _a.children, children = _d === void 0 ? null : _d, _e = _a.disableNullOnZero, disableNullOnZero = _e === void 0 ? false : _e, propDescribedBy = _a["aria-describedby"], props = __rest$Z(_a, ["aria-label", "badgeStyle", "badgeClassName", "badgeRef", "badgeId", "buttonChildren", "buttonType", "badgeTheme", "children", "disableNullOnZero", "aria-describedby"]);
	    var id = props.id;
	    var buttonChildren = useIcon("notification", propButtonChildren);
	    var badgeId = propBadgeId || "";
	    if (!badgeId && id) {
	        badgeId = id + "-badge";
	    }
	    var describedBy = propDescribedBy;
	    if (!isEmpty(children, disableNullOnZero)) {
	        describedBy = classnames(describedBy, badgeId);
	    }
	    return (React__default.createElement(Button, __assign$1a({}, props, { "aria-label": ariaLabel, "aria-describedby": describedBy, ref: ref, buttonType: buttonType }),
	        buttonChildren,
	        React__default.createElement(Badge, { id: badgeId, ref: badgeRef, theme: badgeTheme, style: badgeStyle, className: badgeClassName, disableNullOnZero: disableNullOnZero }, children)));
	});
	{
	    try {
	        var PropTypes$11 = require("prop-types");
	        BadgedButton.propTypes = {
	            id: PropTypes$11.string,
	            "aria-label": PropTypes$11.string,
	            "aria-describedby": PropTypes$11.string,
	            buttonType: PropTypes$11.oneOf(["text", "icon"]),
	            children: PropTypes$11.node,
	            disableNullOnZero: PropTypes$11.bool,
	            badgeId: PropTypes$11.string,
	            badgeRef: PropTypes$11.oneOfType([PropTypes$11.func, PropTypes$11.object]),
	            badgeStyle: PropTypes$11.object,
	            badgeClassName: PropTypes$11.string,
	            badgeTheme: PropTypes$11.oneOf(["primary", "secondary", "default", "clear"]),
	            buttonChildren: PropTypes$11.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1b = (undefined && undefined.__assign) || function () {
	    __assign$1b = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1b.apply(this, arguments);
	};
	var __rest$_ = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$H = bem("rmd-card");
	/**
	 * This is the root card component that should be used along side all the other
	 * card parts. It adds some general styles and elevation to help show
	 * prominence.
	 */
	var Card = React.forwardRef(function Card(_a, ref) {
	    var className = _a.className, children = _a.children, _b = _a.raiseable, raiseable = _b === void 0 ? false : _b, _c = _a.fullWidth, fullWidth = _c === void 0 ? false : _c, _d = _a.bordered, bordered = _d === void 0 ? false : _d, props = __rest$_(_a, ["className", "children", "raiseable", "fullWidth", "bordered"]);
	    return (React__default.createElement("div", __assign$1b({}, props, { ref: ref, className: classnames(block$H({
	            bordered: bordered,
	            shadowed: !bordered,
	            raiseable: !bordered && raiseable,
	            "full-width": fullWidth,
	        }), className) }), children));
	});
	{
	    try {
	        var PropTypes$12 = require("prop-types");
	        Card.propTypes = {
	            className: PropTypes$12.string,
	            bordered: PropTypes$12.bool,
	            raiseable: PropTypes$12.bool,
	            fullWidth: PropTypes$12.bool,
	            children: PropTypes$12.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1c = (undefined && undefined.__assign) || function () {
	    __assign$1c = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1c.apply(this, arguments);
	};
	var __rest$$ = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$I = bem("rmd-card");
	/**
	 * This component is used to dynamically add addons to the `CardHeader`
	 * component. When no children are provided, nothing will be rendered.
	 *
	 * @private
	 */
	var CardHeaderAddon = function (_a) {
	    var className = _a.className, children = _a.children, props = __rest$$(_a, ["className", "children"]);
	    if (!children) {
	        return null;
	    }
	    return (React__default.createElement("span", __assign$1c({}, props, { className: classnames(block$I("header-addon"), className) }), children));
	};

	var __assign$1d = (undefined && undefined.__assign) || function () {
	    __assign$1d = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1d.apply(this, arguments);
	};
	var __rest$10 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$J = bem("rmd-card");
	/**
	 * The header for a `Card`. There should only be up to 1 `CardHeader` within a
	 * card and normally contains the `CardTitle` and optionally `CardSubtitle`
	 * components. There is also additional functionality built in to render items
	 * before or after the main children with some additional spacing.
	 */
	var CardHeader = React.forwardRef(function CardHeader(_a, ref) {
	    var _b;
	    var _c = _a.align, align = _c === void 0 ? "center" : _c, className = _a.className, contentClassName = _a.contentClassName, children = _a.children, beforeChildren = _a.beforeChildren, afterChildren = _a.afterChildren, props = __rest$10(_a, ["align", "className", "contentClassName", "children", "beforeChildren", "afterChildren"]);
	    return (React__default.createElement("header", __assign$1d({}, props, { ref: ref, className: classnames(block$J("header", (_b = {},
	            _b[align] = align !== "none",
	            _b)), className) }),
	        React__default.createElement(TextIconSpacing, { icon: React__default.createElement(CardHeaderAddon, null, beforeChildren) },
	            React__default.createElement(TextIconSpacing, { icon: React__default.createElement(CardHeaderAddon, null, afterChildren), iconAfter: true },
	                React__default.createElement("span", { className: classnames(block$J("header-content"), contentClassName) }, children)))));
	});
	{
	    try {
	        var PropTypes$13 = require("prop-types");
	        CardHeader.propTypes = {
	            align: PropTypes$13.oneOf(["top", "center", "bottom", "none"]),
	            className: PropTypes$13.string,
	            beforeChildren: PropTypes$13.node,
	            afterChildren: PropTypes$13.node,
	            contentClassName: PropTypes$13.string,
	            children: PropTypes$13.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1e = (undefined && undefined.__assign) || function () {
	    __assign$1e = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1e.apply(this, arguments);
	};
	var __rest$11 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$K = bem("rmd-card");
	/**
	 * The `Cardtitle` component should normally be used within the `CardHeader` to
	 * create a nicely styled `<h5>` title for your card. This can also be used
	 * along with the `CardSubtitle` component within the `CardHeader` for a main
	 * title and a subtitle.
	 */
	var CardTitle = React.forwardRef(function CardTitle(_a, ref) {
	    var className = _a.className, children = _a.children, _b = _a.small, small = _b === void 0 ? false : _b, _c = _a.noWrap, noWrap = _c === void 0 ? false : _c, props = __rest$11(_a, ["className", "children", "small", "noWrap"]);
	    return (React__default.createElement("h5", __assign$1e({}, props, { ref: ref, className: classnames(block$K("title", { small: small }), {
	            "rmd-card--no-wrap": noWrap,
	        }, className) }), children));
	});
	{
	    try {
	        var PropTypes$14 = require("prop-types");
	        CardTitle.propTypes = {
	            small: PropTypes$14.bool,
	            noWrap: PropTypes$14.bool,
	            className: PropTypes$14.string,
	            children: PropTypes$14.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1f = (undefined && undefined.__assign) || function () {
	    __assign$1f = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1f.apply(this, arguments);
	};
	var __rest$12 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$L = bem("rmd-card");
	/**
	 * A subtitle for the `Card`. This is usually used with the `CardHeader`
	 * component after the `CardTitle`.
	 */
	var CardSubtitle = React.forwardRef(function CardSubtitle(_a, ref) {
	    var className = _a.className, children = _a.children, _b = _a.noWrap, noWrap = _b === void 0 ? false : _b, _c = _a.disableSecondaryColor, disableSecondaryColor = _c === void 0 ? false : _c, props = __rest$12(_a, ["className", "children", "noWrap", "disableSecondaryColor"]);
	    return (React__default.createElement("h6", __assign$1f({}, props, { ref: ref, className: classnames(block$L("subtitle", {
	            secondary: !disableSecondaryColor,
	        }), {
	            "rmd-card--no-wrap": noWrap,
	        }, className) }), children));
	});
	{
	    try {
	        var PropTypes$15 = require("prop-types");
	        CardSubtitle.propTypes = {
	            className: PropTypes$15.string,
	            noWrap: PropTypes$15.bool,
	            disableSecondaryColor: PropTypes$15.bool,
	            children: PropTypes$15.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1g = (undefined && undefined.__assign) || function () {
	    __assign$1g = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1g.apply(this, arguments);
	};
	var __rest$13 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$M = bem("rmd-card");
	/**
	 * The main content for the `Card`. This adds some additional padding and removes
	 * margin from `<p>` tags by default.
	 */
	var CardContent = React.forwardRef(function CardContent(_a, ref) {
	    var _b = _a.disablePadding, disablePadding = _b === void 0 ? false : _b, _c = _a.disableExtraPadding, disableExtraPadding = _c === void 0 ? false : _c, _d = _a.disableSecondaryColor, disableSecondaryColor = _d === void 0 ? false : _d, _e = _a.disableParagraphMargin, disableParagraphMargin = _e === void 0 ? false : _e, className = _a.className, children = _a.children, props = __rest$13(_a, ["disablePadding", "disableExtraPadding", "disableSecondaryColor", "disableParagraphMargin", "className", "children"]);
	    return (React__default.createElement("div", __assign$1g({}, props, { ref: ref, className: classnames(block$M("content", {
	            padded: !disablePadding,
	            "extra-padding": !disablePadding && !disableExtraPadding,
	            "remove-margin": !disableParagraphMargin,
	            secondary: !disableSecondaryColor,
	        }), className) }), children));
	});
	{
	    try {
	        var PropTypes$16 = require("prop-types");
	        CardContent.propTypes = {
	            className: PropTypes$16.string,
	            disablePadding: PropTypes$16.bool,
	            disableExtraPadding: PropTypes$16.bool,
	            disableParagraphMargin: PropTypes$16.bool,
	            disableSecondaryColor: PropTypes$16.bool,
	            children: PropTypes$16.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1h = (undefined && undefined.__assign) || function () {
	    __assign$1h = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1h.apply(this, arguments);
	};
	var __rest$14 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$N = bem("rmd-card");
	/**
	 * This component is generally used to hold the main actions for the `Card`.
	 * It's a good place to add additional buttons or expansion toggles.
	 */
	var CardActions = React.forwardRef(function CardActions(_a, ref) {
	    var _b;
	    var className = _a.className, _c = _a.align, align = _c === void 0 ? "end" : _c, children = _a.children, props = __rest$14(_a, ["className", "align", "children"]);
	    return (React__default.createElement("div", __assign$1h({}, props, { ref: ref, className: classnames(block$N("actions", (_b = {},
	            _b[align] = align !== "end",
	            _b)), className) }), children));
	});
	{
	    try {
	        var PropTypes$17 = require("prop-types");
	        CardActions.propTypes = {
	            align: PropTypes$17.oneOf(["start", "end", "center"]),
	            className: PropTypes$17.string,
	            children: PropTypes$17.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1i = (undefined && undefined.__assign) || function () {
	    __assign$1i = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1i.apply(this, arguments);
	};
	var __rest$15 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$O = bem("rmd-chip");
	/**
	 * A chip is a simplified and condensed button component that be used to create
	 * compact radio groups, checkboxes, and trigger actions. The chip only has a
	 * `"solid"` and `"outline"` theme but can be raisable once clicked or
	 * selectable with an inline icon. A chip also supports rendering icons, avatars,
	 * or circular progress bars to the left and right of the children.
	 */
	var Chip = React.forwardRef(function Chip(_a, ref) {
	    var _b;
	    var ariaPressed = _a["aria-pressed"], propClassName = _a.className, children = _a.children, _c = _a.theme, theme = _c === void 0 ? "solid" : _c, propLeftIcon = _a.leftIcon, rightIcon = _a.rightIcon, _d = _a.raisable, raisable = _d === void 0 ? false : _d, _e = _a.disabled, disabled = _e === void 0 ? false : _e, selected = _a.selected, _f = _a.selectedThemed, selectedThemed = _f === void 0 ? false : _f, contentStyle = _a.contentStyle, contentClassName = _a.contentClassName, _g = _a.disableContentWrap, disableContentWrap = _g === void 0 ? false : _g, propSelectedIcon = _a.selectedIcon, _h = _a.disableIconTransition, disableIconTransition = _h === void 0 ? false : _h, props = __rest$15(_a, ["aria-pressed", "className", "children", "theme", "leftIcon", "rightIcon", "raisable", "disabled", "selected", "selectedThemed", "contentStyle", "contentClassName", "disableContentWrap", "selectedIcon", "disableIconTransition"]);
	    var _j = useInteractionStates({
	        handlers: props,
	        className: propClassName,
	        disabled: disabled,
	        enablePressedAndRipple: raisable,
	    }), ripples = _j.ripples, className = _j.className, handlers = _j.handlers;
	    var content = children;
	    if (!disableContentWrap) {
	        content = (React__default.createElement("span", { style: contentStyle, className: classnames(block$O("content"), contentClassName) }, children));
	    }
	    var leftIcon = propLeftIcon;
	    var selectable = typeof selected === "boolean";
	    var selectedIcon = useIcon("selected", propSelectedIcon);
	    var isHiddenIcon = false;
	    if (selectable &&
	        !selectedThemed &&
	        typeof leftIcon === "undefined" &&
	        selectedIcon) {
	        leftIcon = selectedIcon;
	        if (!disableIconTransition && React.isValidElement(selectedIcon)) {
	            isHiddenIcon = !selected;
	            leftIcon = React.cloneElement(selectedIcon, {
	                className: block$O("selected-icon", { visible: selected }),
	            });
	        }
	        else if (disableIconTransition && !selected) {
	            // don't want to render it when not selected if there's no transition
	            leftIcon = null;
	        }
	    }
	    var leading = leftIcon && !isHiddenIcon;
	    var trailing = rightIcon;
	    return (React__default.createElement("button", __assign$1i({}, props, handlers, { ref: ref, "aria-pressed": ariaPressed !== null && ariaPressed !== void 0 ? ariaPressed : (!!selected || undefined), type: "button", className: classnames(block$O((_b = {},
	            _b[theme] = true,
	            _b.disabled = disabled,
	            _b.selected = !disabled && selected && !selectedThemed,
	            _b.themed = !disabled && selected && selectedThemed,
	            _b["solid-disabled"] = disabled && theme === "solid",
	            _b["leading-icon"] = leading && !trailing,
	            _b["trailing-icon"] = trailing && !leading,
	            _b.surrounded = leading && trailing,
	            _b)), className), disabled: disabled }),
	        React__default.createElement(TextIconSpacing, { icon: leftIcon, beforeClassName: isHiddenIcon ? "" : undefined },
	            React__default.createElement(TextIconSpacing, { icon: rightIcon, iconAfter: true }, content)),
	        ripples));
	});
	{
	    try {
	        var PropTypes$18 = require("prop-types");
	        Chip.propTypes = {
	            "aria-pressed": PropTypes$18.oneOfType([
	                PropTypes$18.bool,
	                PropTypes$18.oneOf(["true", "false"]),
	            ]),
	            className: PropTypes$18.string,
	            theme: PropTypes$18.oneOf(["outline", "solid"]),
	            disabled: PropTypes$18.bool,
	            leftIcon: PropTypes$18.node,
	            rightIcon: PropTypes$18.node,
	            raisable: PropTypes$18.bool,
	            contentStyle: PropTypes$18.object,
	            contentClassName: PropTypes$18.string,
	            disableContentWrap: PropTypes$18.bool,
	            selected: PropTypes$18.bool,
	            selectedThemed: PropTypes$18.bool,
	            children: PropTypes$18.node,
	            selectedIcon: PropTypes$18.node,
	            disableIconTransition: PropTypes$18.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1j = (undefined && undefined.__assign) || function () {
	    __assign$1j = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1j.apply(this, arguments);
	};
	var __rest$16 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$P = bem("rmd-overlay");
	var DEFAULT_OVERLAY_CLASSNAMES = {
	    appearActive: "rmd-overlay--active",
	    enterActive: "rmd-overlay--active",
	    enterDone: "rmd-overlay--active",
	};
	/**
	 * The `Overlay` component is a simple component used to render a full page
	 * overlay in the page with an enter and exit animation. If there are overflow
	 * issues or you need to portal the overlay to a different area within your app,
	 * you should use the `OverlayPortal` component instead.
	 */
	var Overlay = React.forwardRef(function Overlay(_a, ref) {
	    var className = _a.className, visible = _a.visible, _b = _a.hidden, hidden = _b === void 0 ? false : _b, _c = _a.clickable, clickable = _c === void 0 ? true : _c, _d = _a.timeout, timeout = _d === void 0 ? 150 : _d, children = _a.children, _e = _a.mountOnEnter, mountOnEnter = _e === void 0 ? true : _e, _f = _a.unmountOnExit, unmountOnExit = _f === void 0 ? true : _f, onRequestClose = _a.onRequestClose, onEnter = _a.onEnter, onEntering = _a.onEntering, onEntered = _a.onEntered, onExit = _a.onExit, onExiting = _a.onExiting, onExited = _a.onExited, portal = _a.portal, portalInto = _a.portalInto, portalIntoId = _a.portalIntoId, _g = _a.classNames, classNames = _g === void 0 ? DEFAULT_OVERLAY_CLASSNAMES : _g, _h = _a.tabIndex, tabIndex = _h === void 0 ? -1 : _h, props = __rest$16(_a, ["className", "visible", "hidden", "clickable", "timeout", "children", "mountOnEnter", "unmountOnExit", "onRequestClose", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "portal", "portalInto", "portalIntoId", "classNames", "tabIndex"]);
	    return (React__default.createElement(ConditionalPortal, { portal: portal, portalInto: portalInto, portalIntoId: portalIntoId },
	        React__default.createElement(CSSTransition, { appear: true, in: visible, classNames: hidden ? "" : classNames, timeout: hidden ? 0 : timeout, mountOnEnter: mountOnEnter, unmountOnExit: unmountOnExit, onEnter: onEnter, onEntering: onEntering, onEntered: onEntered, onExit: onExit, onExiting: onExiting, onExited: onExited }, function (state) { return (React__default.createElement("span", __assign$1j({}, props, { ref: ref, className: classnames(block$P({
	                // have to manually set the active state here since react-transition-group doesn't
	                // clone in the transition `classNames` and if the overlay re-renders while the
	                // animation has finished, the active className will disappear
	                active: !hidden && state === "entered",
	                visible: visible,
	                clickable: clickable,
	            }), className), onClick: onRequestClose, tabIndex: tabIndex }), children)); })));
	});
	{
	    try {
	        var PropTypes$19 = require("prop-types");
	        Overlay.propTypes = {
	            className: PropTypes$19.string,
	            classNames: PropTypes$19.oneOfType([
	                PropTypes$19.string,
	                PropTypes$19.shape({
	                    appear: PropTypes$19.string,
	                    appearActive: PropTypes$19.string,
	                    enter: PropTypes$19.string,
	                    enterActive: PropTypes$19.string,
	                    enterDone: PropTypes$19.string,
	                    exit: PropTypes$19.string,
	                    exitActive: PropTypes$19.string,
	                    exitDone: PropTypes$19.string,
	                }),
	            ]),
	            timeout: PropTypes$19.oneOfType([
	                PropTypes$19.number,
	                PropTypes$19.shape({
	                    enter: PropTypes$19.number,
	                    exit: PropTypes$19.number,
	                }),
	            ]),
	            mountOnEnter: PropTypes$19.bool,
	            unmountOnExit: PropTypes$19.bool,
	            onEnter: PropTypes$19.func,
	            onEntering: PropTypes$19.func,
	            onEntered: PropTypes$19.func,
	            onExit: PropTypes$19.func,
	            onExiting: PropTypes$19.func,
	            onExited: PropTypes$19.func,
	            portal: PropTypes$19.bool,
	            portalInto: PropTypes$19.oneOfType([
	                PropTypes$19.string,
	                PropTypes$19.func,
	                PropTypes$19.object,
	            ]),
	            portalIntoId: PropTypes$19.string,
	            children: PropTypes$19.node,
	            tabIndex: PropTypes$19.number,
	            visible: PropTypes$19.bool.isRequired,
	            onRequestClose: PropTypes$19.func.isRequired,
	            hidden: PropTypes$19.bool,
	            clickable: PropTypes$19.bool,
	        };
	    }
	    catch (e) { }
	}

	/* eslint-disable react/prop-types */
	var context$2 = React.createContext({
	    stack: [],
	    add: function () { },
	    remove: function () { },
	});
	{
	    context$2.displayName = "NestedDialogContext";
	}
	var Provider$2 = context$2.Provider;
	/**
	 * This component is used to help with handling nested dialogs by:
	 * - preventing all dialogs to be closed when the escape key is pressed
	 * - hiding the overlays for dialogs that are not the top-most focus
	 *
	 * This should be added to the root of your app if you would like to enable this
	 * feature.
	 */
	var NestedDialogContextProvider = function (_a) {
	    var children = _a.children;
	    var _b = React.useState([]), stack = _b[0], setStack = _b[1];
	    var add = React.useCallback(function (dialogId) {
	        setStack(function (prevStack) {
	            if (
	                prevStack.includes(dialogId)) {
	                /* eslint-disable no-console */
	                console.warn("Tried to add a duplicate dialog id to the `NestedDialogContext`.");
	                console.warn("This means that you have two dialogs with the same id: `" + dialogId + "`.");
	                console.warn("This should be fixed before moving to production since this will break accessibility and is technically invalid.");
	            }
	            return prevStack.concat(dialogId);
	        });
	    }, []);
	    var remove = React.useCallback(function (dialogId) {
	        setStack(function (prevStack) { return prevStack.filter(function (id) { return id !== dialogId; }); });
	    }, []);
	    var value = React.useMemo(function () { return ({ stack: stack, add: add, remove: remove }); }, [add, remove, stack]);
	    return React__default.createElement(Provider$2, { value: value }, children);
	};
	/**
	 * Gets the current nested dialog context. This shouldn't really be used
	 * externally and is a private context hook.
	 *
	 * @private
	 */
	function useNestedDialogContext() {
	    return React.useContext(context$2);
	}

	/**
	 * This hook is used to fix the nested overlays and the escape keypress when multiple
	 * dialogs are rendered at the same time on a page. All it really does is keep a stack
	 * of the dialog ids that are current visible. If there is more than 1 dialog visible
	 * and the dialog is not at the top of the stack, the overlay and escape keypress will
	 * be disabled.
	 *
	 * NOTE: This will not work if you nest dialogs together and have them become visible at
	 * the same time because the ids will get added from child -> parent instead of parent -> child.
	 * This flow shouldn't really happen though so it isn't planned on being fixed.
	 */
	function useNestedDialogFixes(_a) {
	    var id = _a.id, visible = _a.visible, disabled = _a.disabled, propDisableEscapeClose = _a.disableEscapeClose;
	    var _b = useNestedDialogContext(), add = _b.add, remove = _b.remove, stack = _b.stack;
	    React.useEffect(function () {
	        if (disabled || !visible) {
	            return;
	        }
	        add(id);
	        return function () {
	            remove(id);
	        };
	    }, [visible, disabled, id, add, remove]);
	    return React.useMemo(function () {
	        var disableOverlay = false;
	        var disableEscapeClose = propDisableEscapeClose;
	        if (!disabled && visible && stack.length > 1) {
	            var lastIndex = stack.length - 1;
	            var i = stack.findIndex(function (dialogId) { return id === dialogId; });
	            disableOverlay = i < lastIndex;
	            if (!propDisableEscapeClose) {
	                disableEscapeClose = i < lastIndex;
	            }
	        }
	        return {
	            disableOverlay: disableOverlay,
	            disableEscapeClose: disableEscapeClose,
	        };
	    }, [id, propDisableEscapeClose, disabled, visible, stack]);
	}

	var __assign$1k = (undefined && undefined.__assign) || function () {
	    __assign$1k = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1k.apply(this, arguments);
	};
	var __rest$17 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	// used to disable the overlay click-to-close functionality when the `modal` prop is enabled.
	var noop$3 = function () { };
	var block$Q = bem("rmd-dialog");
	var DEFAULT_DIALOG_CLASSNAMES = {
	    appear: "rmd-dialog--enter",
	    appearActive: "rmd-dialog--enter-active",
	    enter: "rmd-dialog--enter",
	    enterActive: "rmd-dialog--enter-active",
	    exit: "rmd-dialog--exit",
	    exitActive: "rmd-dialog--exit-active",
	};
	var DEFAULT_DIALOG_TIMEOUT = {
	    enter: 200,
	    exit: 150,
	};
	var Dialog = React.forwardRef(function Dialog(_a, ref) {
	    var _b = _a.component, component = _b === void 0 ? "div" : _b, _c = _a.tabIndex, tabIndex = _c === void 0 ? -1 : _c, children = _a.children, className = _a.className, containerStyle = _a.containerStyle, containerClassName = _a.containerClassName, propOverlay = _a.overlay, overlayStyle = _a.overlayStyle, overlayClassName = _a.overlayClassName, _d = _a.overlayHidden, overlayHidden = _d === void 0 ? false : _d, visible = _a.visible, onRequestClose = _a.onRequestClose, _e = _a.forceContainer, forceContainer = _e === void 0 ? false : _e, _f = _a.defaultFocus, defaultFocus = _f === void 0 ? "first" : _f, _g = _a.portal, portal = _g === void 0 ? true : _g, portalInto = _a.portalInto, portalIntoId = _a.portalIntoId, _h = _a.appear, appear = _h === void 0 ? false : _h, _j = _a.enter, enter = _j === void 0 ? true : _j, _k = _a.exit, exit = _k === void 0 ? true : _k, _l = _a.disableTransition, disableTransition = _l === void 0 ? false : _l, _m = _a.classNames, classNames = _m === void 0 ? DEFAULT_DIALOG_CLASSNAMES : _m, _o = _a.timeout, timeout = _o === void 0 ? DEFAULT_DIALOG_TIMEOUT : _o, _p = _a.mountOnEnter, mountOnEnter = _p === void 0 ? true : _p, _q = _a.unmountOnExit, unmountOnExit = _q === void 0 ? true : _q, onEnter = _a.onEnter, onEntering = _a.onEntering, onEntered = _a.onEntered, onExit = _a.onExit, onExiting = _a.onExiting, onExited = _a.onExited, _r = _a.modal, modal = _r === void 0 ? false : _r, _s = _a.role, role = _s === void 0 ? "dialog" : _s, _t = _a.type, type = _t === void 0 ? "centered" : _t, _u = _a.disableScrollLock, disableScrollLock = _u === void 0 ? false : _u, _v = _a.disableEscapeClose, propDisableEscapeClose = _v === void 0 ? false : _v, _w = _a.disableFocusContainer, disableFocusContainer = _w === void 0 ? false : _w, _x = _a.disableTabFocusWrap, disableTabFocusWrap = _x === void 0 ? false : _x, _y = _a.disableFocusOnMount, disableFocusOnMount = _y === void 0 ? false : _y, _z = _a.disableFocusOnUnmount, disableFocusOnUnmount = _z === void 0 ? false : _z, _0 = _a.disableNestedDialogFixes, disableNestedDialogFixes = _0 === void 0 ? false : _0, onKeyDown = _a.onKeyDown, props = __rest$17(_a, ["component", "tabIndex", "children", "className", "containerStyle", "containerClassName", "overlay", "overlayStyle", "overlayClassName", "overlayHidden", "visible", "onRequestClose", "forceContainer", "defaultFocus", "portal", "portalInto", "portalIntoId", "appear", "enter", "exit", "disableTransition", "classNames", "timeout", "mountOnEnter", "unmountOnExit", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "modal", "role", "type", "disableScrollLock", "disableEscapeClose", "disableFocusContainer", "disableTabFocusWrap", "disableFocusOnMount", "disableFocusOnUnmount", "disableNestedDialogFixes", "onKeyDown"]);
	    var id = props.id;
	    var isNoneRole = role === "none";
	    var isFullPage = type === "full-page";
	    var isCentered = type === "centered";
	    var _1 = useNestedDialogFixes({
	        id: id,
	        visible: visible,
	        disabled: disableNestedDialogFixes,
	        disableEscapeClose: propDisableEscapeClose,
	    }), disableOverlay = _1.disableOverlay, disableEscapeClose = _1.disableEscapeClose;
	    useScrollLock(visible && !isNoneRole && !disableScrollLock);
	    var overlayEl = null;
	    if (typeof propOverlay === "boolean" ? propOverlay : !isFullPage) {
	        // do not add the portal props to the overlay element since the portalling
	        // is handled in here. With how portals work, this would be rendered **after**
	        // the dialog instead of before which breaks some dialog styles
	        overlayEl = (React__default.createElement(Overlay, { id: id + "-overlay", style: overlayStyle, className: classnames("rmd-dialog-overlay", overlayClassName), hidden: overlayHidden || disableOverlay, visible: visible, clickable: !modal, onRequestClose: modal ? noop$3 : onRequestClose }));
	    }
	    var dialog = (React__default.createElement(FocusContainer, __assign$1k({}, props, { ref: ref, role: isNoneRole ? undefined : role, "aria-modal": (!isNoneRole && !!overlayEl) || undefined, tabIndex: tabIndex, component: component, defaultFocus: defaultFocus, disableTabFocusWrap: isNoneRole || disableTabFocusWrap || disableFocusContainer, disableFocusOnMount: isNoneRole || disableFocusContainer || disableFocusOnMount, disableFocusOnMountScroll: true, disableFocusOnUnmount: isNoneRole || disableFocusContainer || disableFocusOnUnmount, onKeyDown: useCloseOnEscape(onRequestClose, disableEscapeClose || isNoneRole, onKeyDown), className: classnames(block$Q({
	            centered: isCentered,
	            "full-page": isFullPage,
	        }), className) }), children));
	    if (isCentered || forceContainer) {
	        // the additional container is only required when we don't have a full page dialog. it's just
	        // used to apply flex center to the dialog and add some margin
	        dialog = (React__default.createElement("span", { id: id + "-container", style: containerStyle, className: classnames("rmd-dialog-container", containerClassName) }, dialog));
	    }
	    return (React__default.createElement(ConditionalPortal, { portal: !isNoneRole && portal, portalInto: portalInto, portalIntoId: portalIntoId },
	        React__default.createElement(React__default.Fragment, null,
	            overlayEl,
	            React__default.createElement(CSSTransition, { appear: !disableTransition && appear, enter: !disableTransition && enter, exit: !disableTransition && exit, in: visible, classNames: classNames, timeout: timeout, onEnter: onEnter, onEntering: onEntering, onEntered: onEntered, onExit: onExit, onExiting: onExiting, onExited: onExited, mountOnEnter: mountOnEnter, unmountOnExit: unmountOnExit }, dialog))));
	});
	{
	    try {
	        var PropTypes$1a = require("prop-types");
	        Dialog.propTypes = {
	            id: PropTypes$1a.string.isRequired,
	            role: PropTypes$1a.oneOf(["dialog", "alertdialog", "menu", "none"]),
	            "aria-label": PropTypes$1a.string,
	            "aria-labelledby": PropTypes$1a.string,
	            className: PropTypes$1a.string,
	            type: PropTypes$1a.oneOf(["custom", "centered", "full-page"]),
	            tabIndex: PropTypes$1a.number,
	            modal: PropTypes$1a.bool,
	            visible: PropTypes$1a.bool.isRequired,
	            onRequestClose: PropTypes$1a.func.isRequired,
	            mountOnEnter: PropTypes$1a.bool,
	            unmountOnExit: PropTypes$1a.bool,
	            overlay: PropTypes$1a.bool,
	            overlayStyle: PropTypes$1a.object,
	            overlayClassName: PropTypes$1a.string,
	            overlayHidden: PropTypes$1a.bool,
	            containerStyle: PropTypes$1a.object,
	            containerClassName: PropTypes$1a.string,
	            forceContainer: PropTypes$1a.bool,
	            onKeyDown: PropTypes$1a.func,
	            component: PropTypes$1a.oneOf(["div", "nav"]),
	            children: PropTypes$1a.node,
	            classNames: PropTypes$1a.oneOfType([
	                PropTypes$1a.string,
	                PropTypes$1a.shape({
	                    appear: PropTypes$1a.string,
	                    appearActive: PropTypes$1a.string,
	                    enter: PropTypes$1a.string,
	                    enterActive: PropTypes$1a.string,
	                    enterDone: PropTypes$1a.string,
	                    exit: PropTypes$1a.string,
	                    exitActive: PropTypes$1a.string,
	                    exitDone: PropTypes$1a.string,
	                }),
	            ]),
	            timeout: PropTypes$1a.oneOfType([
	                PropTypes$1a.number,
	                PropTypes$1a.shape({
	                    enter: PropTypes$1a.number,
	                    exit: PropTypes$1a.number,
	                }),
	            ]),
	            appear: PropTypes$1a.bool,
	            enter: PropTypes$1a.bool,
	            exit: PropTypes$1a.bool,
	            disableTransition: PropTypes$1a.bool,
	            onEnter: PropTypes$1a.func,
	            onEntering: PropTypes$1a.func,
	            onEntered: PropTypes$1a.func,
	            onExit: PropTypes$1a.func,
	            onExiting: PropTypes$1a.func,
	            onExited: PropTypes$1a.func,
	            portal: PropTypes$1a.bool,
	            portalInto: PropTypes$1a.oneOfType([
	                PropTypes$1a.func,
	                PropTypes$1a.string,
	                PropTypes$1a.object,
	            ]),
	            portalIntoId: PropTypes$1a.string,
	            defaultFocus: PropTypes$1a.oneOfType([
	                PropTypes$1a.oneOf(["first", "last"]),
	                PropTypes$1a.string,
	            ]),
	            disableScrollLock: PropTypes$1a.bool,
	            disableEscapeClose: PropTypes$1a.bool,
	            disableFocusContainer: PropTypes$1a.bool,
	            disableNestedDialogFixes: PropTypes$1a.bool,
	            disableTabFocusWrap: PropTypes$1a.bool,
	            disableFocusOnMount: PropTypes$1a.bool,
	            disableFocusOnUnmount: PropTypes$1a.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1l = (undefined && undefined.__assign) || function () {
	    __assign$1l = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1l.apply(this, arguments);
	};
	var __rest$18 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$R = bem("rmd-dialog");
	/**
	 * This component doesn't do anything to complex. It really just applies custom
	 * styles so that when the `DialogContent` component is used, the header will be
	 * "fixed" to the top of the dialog while the content scrolls. It also applies
	 * some minimal padding.
	 */
	var DialogHeader = React.forwardRef(function DialogHeader(_a, ref) {
	    var children = _a.children, className = _a.className, props = __rest$18(_a, ["children", "className"]);
	    return (React__default.createElement("header", __assign$1l({}, props, { ref: ref, className: classnames(block$R("header"), className) }), children));
	});
	{
	    try {
	        var PropTypes$1b = require("prop-types");
	        DialogHeader.propTypes = {
	            className: PropTypes$1b.string,
	            children: PropTypes$1b.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1m = (undefined && undefined.__assign) || function () {
	    __assign$1m = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1m.apply(this, arguments);
	};
	var __rest$19 = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$S = bem("rmd-dialog");
	/**
	 * This component adds some base styles to an `<h2>` element for a title within
	 * a `Dialog`.
	 */
	var DialogTitle = React.forwardRef(function DialogTitle(_a, ref) {
	    var children = _a.children, className = _a.className, props = __rest$19(_a, ["children", "className"]);
	    return (React__default.createElement("h2", __assign$1m({}, props, { ref: ref, className: classnames(block$S("title"), className) }), children));
	});
	{
	    try {
	        var PropTypes$1c = require("prop-types");
	        DialogTitle.propTypes = {
	            className: PropTypes$1c.string,
	            children: PropTypes$1c.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1n = (undefined && undefined.__assign) || function () {
	    __assign$1n = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1n.apply(this, arguments);
	};
	var __rest$1a = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$T = bem("rmd-dialog");
	/**
	 * This component is used to render the main content within a dialog. There are
	 * really only benefits when using the component alongside the `DialogHeader`
	 * and/or `DialogFooter` since it is set up so only the content will scroll
	 * while the header and footer will be "fixed".
	 */
	var DialogContent = React.forwardRef(function DialogContent(_a, ref) {
	    var children = _a.children, className = _a.className, _b = _a.disablePadding, disablePadding = _b === void 0 ? false : _b, props = __rest$1a(_a, ["children", "className", "disablePadding"]);
	    return (React__default.createElement("div", __assign$1n({}, props, { ref: ref, className: classnames(block$T("content", {
	            padded: !disablePadding,
	        }), className) }), children));
	});
	{
	    try {
	        var PropTypes$1d = require("prop-types");
	        DialogContent.propTypes = {
	            className: PropTypes$1d.string,
	            children: PropTypes$1d.node,
	            disablePadding: PropTypes$1d.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1o = (undefined && undefined.__assign) || function () {
	    __assign$1o = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1o.apply(this, arguments);
	};
	var __rest$1b = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$U = bem("rmd-dialog");
	var DialogFooter = React.forwardRef(function DialogFooter(_a, ref) {
	    var _b;
	    var children = _a.children, className = _a.className, _c = _a.align, align = _c === void 0 ? "end" : _c, props = __rest$1b(_a, ["children", "className", "align"]);
	    return (React__default.createElement("footer", __assign$1o({}, props, { ref: ref, className: classnames(block$U("footer", (_b = {
	                flex: align !== "none"
	            },
	            _b[align] = align !== "none",
	            _b)), className) }), children));
	});
	{
	    try {
	        var PropTypes$1e = require("prop-types");
	        DialogFooter.propTypes = {
	            className: PropTypes$1e.string,
	            children: PropTypes$1e.node,
	            align: PropTypes$1e.oneOf([
	                "none",
	                "start",
	                "end",
	                "between",
	                "stacked-start",
	                "stacked-end",
	            ]),
	        };
	    }
	    catch (e) { }
	}

	var __assign$1p = (undefined && undefined.__assign) || function () {
	    __assign$1p = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1p.apply(this, arguments);
	};
	var __rest$1c = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var DEFAULT_CLASSNAMES = {
	    appear: "rmd-dialog--fixed-enter",
	    appearActive: "rmd-dialog--fixed-enter-active",
	    enter: "rmd-dialog--fixed-enter",
	    enterActive: "rmd-dialog--fixed-enter-active",
	    exit: "rmd-dialog--fixed-exit",
	    exitActive: "rmd-dialog--fixed-exit-active",
	};
	/**
	 * The `FixedDialog` is a wrapper for the `Dialog` component that can be used to
	 * be fix itself to another element. Another term for this component might be a
	 * "Pop out Dialog".
	 */
	var FixedDialog = React.forwardRef(function FixedDialog(_a, ref) {
	    var fixedTo = _a.fixedTo, _b = _a.anchor, anchor = _b === void 0 ? TOP_INNER_RIGHT_ANCHOR : _b, options = _a.options, getOptions = _a.getOptions, children = _a.children, className = _a.className, _c = _a.classNames, classNames = _c === void 0 ? DEFAULT_CLASSNAMES : _c, _d = _a.overlayHidden, overlayHidden = _d === void 0 ? true : _d, _e = _a.disableScrollLock, disableScrollLock = _e === void 0 ? true : _e, props = __rest$1c(_a, ["fixedTo", "anchor", "options", "getOptions", "children", "className", "classNames", "overlayHidden", "disableScrollLock"]);
	    var onRequestClose = props.onRequestClose;
	    var _f = useFixedPositioning(__assign$1p(__assign$1p({ transformOrigin: true }, options), { onScroll: function (_event, _a) {
	            var visible = _a.visible;
	            if (!visible) {
	                onRequestClose();
	            }
	        }, fixedTo: fixedTo,
	        anchor: anchor,
	        getOptions: getOptions })), style = _f.style, onEnter = _f.onEnter, onEntering = _f.onEntering, onEntered = _f.onEntered, onExited = _f.onExited;
	    return (React__default.createElement(Dialog, __assign$1p({}, props, { ref: ref, type: "custom", style: style, className: classnames("rmd-dialog--fixed", className), classNames: classNames, overlayHidden: overlayHidden, disableScrollLock: disableScrollLock, onEnter: onEnter, onEntering: onEntering, onEntered: onEntered, onExited: onExited }), children));
	});
	{
	    try {
	        var PropTypes$1f = require("prop-types");
	        FixedDialog.propTypes = {
	            fixedTo: PropTypes$1f.oneOfType([
	                PropTypes$1f.string,
	                PropTypes$1f.func,
	                PropTypes$1f.object,
	            ]),
	            options: PropTypes$1f.shape({
	                vwMargin: PropTypes$1f.number,
	                vhMargin: PropTypes$1f.number,
	                xMargin: PropTypes$1f.number,
	                yMargin: PropTypes$1f.number,
	                disableSwapping: PropTypes$1f.bool,
	                transformOrigin: PropTypes$1f.bool,
	            }),
	            getOptions: PropTypes$1f.func,
	            onRequestClose: PropTypes$1f.func.isRequired,
	            overlayHidden: PropTypes$1f.bool,
	            classNames: PropTypes$1f.oneOfType([
	                PropTypes$1f.string,
	                PropTypes$1f.shape({
	                    appear: PropTypes$1f.string,
	                    appearActive: PropTypes$1f.string,
	                    enter: PropTypes$1f.string,
	                    enterActive: PropTypes$1f.string,
	                    enterDone: PropTypes$1f.string,
	                    exit: PropTypes$1f.string,
	                    exitActive: PropTypes$1f.string,
	                    exitDone: PropTypes$1f.string,
	                }),
	            ]),
	            timeout: PropTypes$1f.oneOfType([
	                PropTypes$1f.number,
	                PropTypes$1f.shape({
	                    enter: PropTypes$1f.number,
	                    exit: PropTypes$1f.number,
	                }),
	            ]),
	            disableScrollLock: PropTypes$1f.bool,
	            anchor: PropTypes$1f.shape({
	                x: PropTypes$1f.oneOf([
	                    "inner-left",
	                    "inner-right",
	                    "center",
	                    "left",
	                    "right",
	                ]),
	                y: PropTypes$1f.oneOf(["above", "below", "center", "top", "bottom"]),
	            }),
	            children: PropTypes$1f.node,
	            className: PropTypes$1f.string,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1q = (undefined && undefined.__assign) || function () {
	    __assign$1q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1q.apply(this, arguments);
	};
	var __rest$1d = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$V = bem("rmd-divider");
	var Divider = React.forwardRef(function Divider(_a, ref) {
	    var _b = _a.inset, inset = _b === void 0 ? false : _b, _c = _a.vertical, vertical = _c === void 0 ? false : _c, _d = _a.role, role = _d === void 0 ? "separator" : _d, className = _a.className, props = __rest$1d(_a, ["inset", "vertical", "role", "className"]);
	    var Component = (vertical ? "div" : "hr");
	    return (React__default.createElement(Component, __assign$1q({}, props, { ref: ref, role: role, className: classnames(block$V({ inset: !vertical && inset, vertical: vertical }), className) })));
	});
	{
	    try {
	        var PropTypes$1g = require("prop-types");
	        Divider.propTypes = {
	            role: PropTypes$1g.string,
	            inset: PropTypes$1g.bool,
	            className: PropTypes$1g.string,
	            vertical: PropTypes$1g.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1r = (undefined && undefined.__assign) || function () {
	    __assign$1r = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1r.apply(this, arguments);
	};
	var __rest$1e = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This is a small hook that is used to automatically create a vertical divider based
	 * on the computed height of its parent element.
	 *
	 * @param maxHeight The max height for the vertical divider. When the value is between
	 * 0 and 1, it will be used as a percentage. Otherwise the smaller value of parent element
	 * height and this will be used.
	 */
	function useVerticalDividerHeight(maxHeight, forwardedRef) {
	    if ( maxHeight < 0) {
	        throw new Error("The `maxHeight` for a vertical divider height must be greater than 0");
	    }
	    var _a = React.useState(undefined), height = _a[0], setHeight = _a[1];
	    var ref = React.useCallback(function (instance) {
	        applyRef(instance, forwardedRef);
	        if (!instance || !instance.parentElement) {
	            return;
	        }
	        var height = instance.parentElement.offsetHeight;
	        if (maxHeight <= 1) {
	            setHeight(height * maxHeight);
	        }
	        else {
	            setHeight(Math.min(height, maxHeight));
	        }
	    }, [maxHeight, forwardedRef]);
	    return { ref: ref, height: height };
	}
	/**
	 * This component is used to create a vertical divider based on a parent
	 * element's height. This is really only needed when the parent element **has no
	 * defined height**.  If there is a defined height, this component is not worth
	 * much as the height can be computed in css as normal. This really just fixes
	 * the issue that the height would be set to `auto` (which computes to 0 most of
	 * the time) when it is not set on a parent element.
	 */
	var VerticalDivider = React.forwardRef(function VerticalDivider(_a, forwardedRef) {
	    var style = _a.style, _b = _a.maxHeight, maxHeight = _b === void 0 ? 1 : _b, props = __rest$1e(_a, ["style", "maxHeight"]);
	    var _c = useVerticalDividerHeight(maxHeight, forwardedRef), ref = _c.ref, height = _c.height;
	    return (React__default.createElement(Divider, __assign$1r({}, props, { style: __assign$1r(__assign$1r({}, style), { height: height }), ref: ref, vertical: true })));
	});
	{
	    try {
	        var PropTypes$1h = require("prop-types");
	        VerticalDivider.propTypes = {
	            style: PropTypes$1h.object,
	            maxHeight: PropTypes$1h.number,
	            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
	            // @ts-expect-error
	            _validateMaxHeight: function (_a, _, componentName) {
	                var _b = _a.maxHeight, maxHeight = _b === void 0 ? 1 : _b;
	                if (maxHeight < 0) {
	                    return new Error("The maxHeight prop for `" + componentName + "` must be a number greater " +
	                        ("than 0, but received `" + maxHeight + "`."));
	                }
	                return null;
	            },
	        };
	    }
	    catch (e) { }
	}

	var __assign$1s = (undefined && undefined.__assign) || function () {
	    __assign$1s = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1s.apply(this, arguments);
	};
	var __rest$1f = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$W = bem("rmd-expansion-panel");
	/**
	 * The header for a panel that controls the expansion state. This is really just
	 * a simple button that displays the children before an expander icon.
	 *
	 * Reminder: Since this is a `<button>`, only `inline` elements should be
	 * rendered within (so use `<span>` instead of `<div>` for children).
	 */
	var ExpansionPanelHeader = React.forwardRef(function ExpansionPanelHeader(_a, ref) {
	    var propIcon = _a.icon, expanded = _a.expanded, children = _a.children, className = _a.className, _b = _a.disableTransition, disableTransition = _b === void 0 ? false : _b, props = __rest$1f(_a, ["icon", "expanded", "children", "className", "disableTransition"]);
	    var icon = useIcon("expander", propIcon);
	    return (React__default.createElement(UnstyledButton, __assign$1s({}, props, { ref: ref, "aria-expanded": expanded || undefined, className: classnames(block$W("header"), className) }),
	        children,
	        icon && (React__default.createElement("span", { className: block$W("icon") },
	            React__default.createElement(IconRotator, { animate: !disableTransition, rotated: expanded }, icon)))));
	});
	{
	    try {
	        var PropTypes$1i = require("prop-types");
	        ExpansionPanelHeader.propTypes = {
	            id: PropTypes$1i.string.isRequired,
	            icon: PropTypes$1i.node,
	            expanded: PropTypes$1i.bool.isRequired,
	            onClick: PropTypes$1i.func.isRequired,
	            children: PropTypes$1i.node.isRequired,
	            className: PropTypes$1i.string,
	            disableTransition: PropTypes$1i.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1t = (undefined && undefined.__assign) || function () {
	    __assign$1t = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1t.apply(this, arguments);
	};
	var __rest$1g = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$X = bem("rmd-expansion-panel");
	/**
	 * The expansion panel renders a header element (that is just a button) and
	 * dynamically shows content once expanded.
	 */
	var ExpansionPanel = React.forwardRef(function ExpansionPanel(_a, ref) {
	    var className = _a.className, children = _a.children, headerStyle = _a.headerStyle, headerClassName = _a.headerClassName, contentStyle = _a.contentStyle, contentClassName = _a.contentClassName, headerRef = _a.headerRef, _b = _a.disablePadding, disablePadding = _b === void 0 ? false : _b, _c = _a.disableSecondaryColor, disableSecondaryColor = _c === void 0 ? false : _c, customHeader = _a.customHeader, header = _a.header, expanded = _a.expanded, onExpandClick = _a.onExpandClick, expanderIcon = _a.expanderIcon, _d = _a.marginTop, marginTop = _d === void 0 ? false : _d, _e = _a.fullWidth, fullWidth = _e === void 0 ? true : _e, _f = _a.persistent, persistent = _f === void 0 ? false : _f, _g = _a.disabled, disabled = _g === void 0 ? false : _g, _h = _a.disableTransition, disableTransition = _h === void 0 ? false : _h, props = __rest$1g(_a, ["className", "children", "headerStyle", "headerClassName", "contentStyle", "contentClassName", "headerRef", "disablePadding", "disableSecondaryColor", "customHeader", "header", "expanded", "onExpandClick", "expanderIcon", "marginTop", "fullWidth", "persistent", "disabled", "disableTransition"]);
	    var id = props.id;
	    var contentId = id + "-content";
	    return (React__default.createElement(Card, __assign$1t({}, props, { id: id + "-container", ref: ref, fullWidth: fullWidth, className: classnames(block$X({ expanded: expanded, "margin-top": marginTop }), className) }),
	        customHeader || (React__default.createElement(ExpansionPanelHeader, { "aria-disabled": disabled || undefined, id: id, ref: headerRef, style: headerStyle, className: headerClassName, icon: expanderIcon, expanded: expanded, onClick: onExpandClick, disableTransition: disableTransition }, header)),
	        React__default.createElement(Collapse, { collapsed: !expanded, timeout: disableTransition ? 0 : undefined, temporary: !persistent },
	            React__default.createElement(CardContent, { id: contentId, "aria-labelledby": id, role: "region", style: contentStyle, className: contentClassName, disableSecondaryColor: disableSecondaryColor, disablePadding: disablePadding, disableExtraPadding: true }, children))));
	});
	{
	    try {
	        var PropTypes$1j = require("prop-types");
	        ExpansionPanel.propTypes = {
	            id: PropTypes$1j.string.isRequired,
	            className: PropTypes$1j.string,
	            disabled: PropTypes$1j.bool,
	            children: PropTypes$1j.node,
	            headerStyle: PropTypes$1j.object,
	            headerClassName: PropTypes$1j.string,
	            contentStyle: PropTypes$1j.object,
	            contentClassName: PropTypes$1j.string,
	            customHeader: PropTypes$1j.node,
	            fullWidth: PropTypes$1j.bool,
	            header: PropTypes$1j.node,
	            headerRef: PropTypes$1j.oneOfType([
	                PropTypes$1j.func,
	                PropTypes$1j.shape({
	                    current: PropTypes$1j.instanceOf(HTMLButtonElement),
	                }),
	            ]),
	            expanderIcon: PropTypes$1j.node,
	            expanded: PropTypes$1j.bool.isRequired,
	            onExpandClick: PropTypes$1j.func.isRequired,
	            persistent: PropTypes$1j.bool,
	            marginTop: PropTypes$1j.bool,
	            disableTransition: PropTypes$1j.bool,
	            disablePadding: PropTypes$1j.bool,
	            disableSecondaryColor: PropTypes$1j.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1u = (undefined && undefined.__assign) || function () {
	    __assign$1u = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1u.apply(this, arguments);
	};
	var __rest$1h = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This component is honestly not very helpful since it does not apply any
	 * styles. It is a simple wrapper for a `<div>` that updates the props to
	 * require the `children` and `onKeyDown` props.
	 */
	var ExpansionList = React.forwardRef(function ExpansionList(_a, ref) {
	    var children = _a.children, props = __rest$1h(_a, ["children"]);
	    return (React__default.createElement("div", __assign$1u({}, props, { ref: ref }), children));
	});
	{
	    try {
	        var PropTypes$1k = require("prop-types");
	        ExpansionList.propTypes = {
	            children: PropTypes$1k.node.isRequired,
	            className: PropTypes$1k.string,
	            onKeyDown: PropTypes$1k.func.isRequired,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * @private
	 */
	var attemptFocus = function (index, panels) {
	    var _a;
	    var panel = (_a = panels[index]) === null || _a === void 0 ? void 0 : _a.headerRef.current;
	    if (panel) {
	        panel.focus();
	    }
	};
	/**
	 * This hook is used to control the expansion of a list of panels along with
	 * providing some of the required props for each panel. This hook will provide
	 * an ordered list of:
	 *
	 * - the list of panel props that include the `id`, `key`, `expanded`, and
	 *   `onExpandChange`.
	 * - a keydown event handler to pass to a parent component (normally the
	 *   ExpansionList) to allow keyboard movement with the arrow keys, and home+end
	 *   keys. This should only be used when there are multiple panels.
	 * - the current list of panel ids that are expanded
	 * - the React setState dispatcher for controlling the expanded list of ids
	 *   manually if desired
	 * - a function to create a handler for toggling the expansion of a specific
	 *   panel
	 *
	 * This hook is usually used to control a list of expansion panels, but can also
	 * control a single panel if desired.
	 *
	 * Examples:
	 *
	 * Single panel:
	 *
	 * ```tsx
	 * const [panels] = usePanels({ count: 1, idPrefix: "my-panel" });
	 * // since the count is one, it'll just be a list of only one panel props
	 * const [panelProps] = panels;
	 *
	 * return (
	 *   <ExpansionPanel {...panelProps}>
	 *     Content within the panel...
	 *   </ExpansionPanel>
	 * );
	 * ```
	 *
	 * Multiple Panels:
	 *
	 * ```tsx
	 * const [panels, onKeyDown] = usePanels({ count: 3, idPrefix: "panel-list" });
	 *
	 * const [panel1Props, panel2Props, panel3Props] = panels;
	 *
	 * return (
	 *   <ExpansionList onKeyDown={onKeyDown}>
	 *     <ExpansionPanel {...panel1Props}>
	 *       Panel 1 Content...
	 *     </ExpansionPanel>
	 *     <ExpansionPanel {...panel2Props}>
	 *       Panel 2 Content...
	 *     </ExpansionPanel>
	 *     <ExpansionPanel {...panel3Props}>
	 *       Panel 3 Content...
	 *     </ExpansionPanel>
	 *   </ExpansionList>
	 * );
	 * ```
	 */
	function usePanels(_a) {
	    var idPrefix = _a.idPrefix, count = _a.count, _b = _a.multiple, multiple = _b === void 0 ? false : _b, _c = _a.preventAllClosed, preventAllClosed = _c === void 0 ? false : _c, defaultExpandedIndex = _a.defaultExpandedIndex;
	    {
	        if (count < 1) {
	            throw new RangeError("The `count` must be greater than `0`");
	        }
	        if (typeof defaultExpandedIndex === "number" &&
	            defaultExpandedIndex >= count) {
	            throw new RangeError("The `defaultExpandedIndex` must be less than or equal to the `count`");
	        }
	        if (typeof defaultExpandedIndex === "number" && defaultExpandedIndex < -1) {
	            throw new RangeError("The `defaultExpandedIndex` must be greater than or equal to `-1`");
	        }
	        if (Array.isArray(defaultExpandedIndex)) {
	            var greater = defaultExpandedIndex.filter(function (i) { return i > count; });
	            if (greater.length) {
	                throw new RangeError("The `defaultExpandedIndex` array must contain numbers less than the `count`");
	            }
	            var lessThan = defaultExpandedIndex.filter(function (i) { return i < 0; });
	            if (lessThan.length) {
	                throw new RangeError("The `defaultExpandedIndex` array must contain numbers greater than or equal to `0`");
	            }
	        }
	    }
	    var panels = React.useMemo(function () {
	        return Array.from({ length: count }, function (_, i) { return ({
	            id: idPrefix + "-" + (i + 1),
	            headerRef: React.createRef(),
	        }); });
	    }, [idPrefix, count]);
	    var _d = React.useState(function () {
	        if (typeof defaultExpandedIndex === "undefined") {
	            return preventAllClosed ? [panels[0].id] : [];
	        }
	        if (typeof defaultExpandedIndex === "number") {
	            return defaultExpandedIndex === -1
	                ? panels.map(function (_a) {
	                    var id = _a.id;
	                    return id;
	                })
	                : [panels[Math.min(defaultExpandedIndex, panels.length)].id];
	        }
	        return panels
	            .filter(function (_, i) { return defaultExpandedIndex.includes(i); })
	            .map(function (_a) {
	            var id = _a.id;
	            return id;
	        });
	    }), expandedIds = _d[0], setExpandedIds = _d[1];
	    var createExpandClick = function (panelId) { return function () {
	        setExpandedIds(function (prevIds) {
	            var i = prevIds.indexOf(panelId);
	            if (!multiple) {
	                if (prevIds[0] === panelId && prevIds.length === 1) {
	                    return preventAllClosed ? prevIds : [];
	                }
	                return [panelId];
	            }
	            var nextSelectedIds = prevIds.slice();
	            if (i === -1) {
	                nextSelectedIds.push(panelId);
	            }
	            else {
	                nextSelectedIds.splice(i, 1);
	            }
	            if (preventAllClosed && nextSelectedIds.length === 0) {
	                return [panelId];
	            }
	            return nextSelectedIds;
	        });
	    }; };
	    var previousExpanded = false;
	    var panelPropList = panels.map(function (_a, i) {
	        var id = _a.id, headerRef = _a.headerRef;
	        var expanded = expandedIds.includes(id);
	        var marginTop = i > 0 && (expanded || previousExpanded);
	        previousExpanded = expanded;
	        return {
	            id: id,
	            disabled: expanded && preventAllClosed && expandedIds.length === 1,
	            expanded: expanded,
	            headerRef: headerRef,
	            marginTop: marginTop,
	            onExpandClick: createExpandClick(id),
	        };
	    });
	    var onKeyDown = React.useCallback(function (event) {
	        if (event.shiftKey || event.ctrlKey || event.metaKey || event.altKey) {
	            return;
	        }
	        var key = event.key;
	        var increment = key === "ArrowDown";
	        var decrement = key === "ArrowUp";
	        var jumpToFirst = key === "Home";
	        var jumpToLast = key === "End";
	        if (!increment && !decrement && !jumpToFirst && !jumpToLast) {
	            return;
	        }
	        var currentIndex = panels.findIndex(function (_a) {
	            var headerRef = _a.headerRef;
	            return event.target === headerRef.current;
	        });
	        if (currentIndex === -1) {
	            return;
	        }
	        // don't want page scroll behavior
	        event.preventDefault();
	        if (jumpToFirst) {
	            attemptFocus(0, panels);
	            return;
	        }
	        if (jumpToLast) {
	            attemptFocus(panels.length - 1, panels);
	            return;
	        }
	        attemptFocus(loop(currentIndex, panels.length - 1, increment), panels);
	    }, [panels]);
	    return [
	        panelPropList,
	        onKeyDown,
	        expandedIds,
	        setExpandedIds,
	        createExpandClick,
	    ];
	}

	var DEFAULT_TOOLTIP_CLASSNAMES = {
	    appear: "rmd-tooltip--enter",
	    appearActive: "rmd-tooltip--visible",
	    enter: "rmd-tooltip--enter",
	    enterActive: "rmd-tooltip--visible",
	    enterDone: "rmd-tooltip--visible",
	    exit: "rmd-tooltip--visible rmd-tooltip--exit",
	    exitActive: "rmd-tooltip--exit-active",
	};
	var DEFAULT_TOOLTIP_TIMEOUT = {
	    enter: 200,
	    exit: 150,
	};
	var DEFAULT_TOOLTIP_DELAY = 1000;
	var DEFAULT_TOOLTIP_THRESHOLD = 0.75;

	var __assign$1v = (undefined && undefined.__assign) || function () {
	    __assign$1v = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1v.apply(this, arguments);
	};
	var __rest$1i = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$Y = bem("rmd-tooltip");
	/**
	 * This is the base tooltip component that can only be used to render a tooltip
	 * with an animation when the visibility changes. If this component is used, you
	 * will need to manually add all the event listeners and triggers to change the
	 * `visible` prop.
	 */
	var Tooltip = React.forwardRef(function Tooltip(_a, ref) {
	    var _b;
	    var className = _a.className, _c = _a.classNames, classNames = _c === void 0 ? DEFAULT_TOOLTIP_CLASSNAMES : _c, visible = _a.visible, _d = _a.timeout, timeout = _d === void 0 ? DEFAULT_TOOLTIP_TIMEOUT : _d, _e = _a.dense, dense = _e === void 0 ? false : _e, _f = _a.lineWrap, lineWrap = _f === void 0 ? true : _f, _g = _a.position, position = _g === void 0 ? "below" : _g, children = _a.children, onEnter = _a.onEnter, onEntering = _a.onEntering, onEntered = _a.onEntered, onExit = _a.onExit, onExiting = _a.onExiting, onExited = _a.onExited, _h = _a.mountOnEnter, mountOnEnter = _h === void 0 ? true : _h, _j = _a.unmountOnExit, unmountOnExit = _j === void 0 ? true : _j, props = __rest$1i(_a, ["className", "classNames", "visible", "timeout", "dense", "lineWrap", "position", "children", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "mountOnEnter", "unmountOnExit"]);
	    return (React__default.createElement(CSSTransition, { classNames: classNames, in: visible, timeout: timeout, onEnter: onEnter, onEntering: onEntering, onEntered: onEntered, onExit: onExit, onExiting: onExiting, onExited: onExited, mountOnEnter: mountOnEnter, unmountOnExit: unmountOnExit },
	        React__default.createElement("span", __assign$1v({}, props, { ref: ref, role: "tooltip", className: classnames(block$Y((_b = {
	                    dense: dense,
	                    "line-wrap": lineWrap,
	                    "dense-line-wrap": dense && lineWrap
	                },
	                _b[position] = true,
	                _b)), className) }), children)));
	});
	{
	    try {
	        var PropTypes$1l = require("prop-types");
	        Tooltip.propTypes = {
	            id: PropTypes$1l.string.isRequired,
	            style: PropTypes$1l.object,
	            className: PropTypes$1l.string,
	            children: PropTypes$1l.node.isRequired,
	            dense: PropTypes$1l.bool,
	            lineWrap: PropTypes$1l.bool,
	            classNames: PropTypes$1l.oneOfType([
	                PropTypes$1l.string,
	                PropTypes$1l.shape({
	                    appear: PropTypes$1l.string,
	                    appearActive: PropTypes$1l.string,
	                    enter: PropTypes$1l.string,
	                    enterActive: PropTypes$1l.string,
	                    enterDone: PropTypes$1l.string,
	                    exit: PropTypes$1l.string,
	                    exitActive: PropTypes$1l.string,
	                    exitDone: PropTypes$1l.string,
	                }),
	            ]),
	            timeout: PropTypes$1l.oneOfType([
	                PropTypes$1l.number,
	                PropTypes$1l.shape({
	                    enter: PropTypes$1l.number,
	                    exit: PropTypes$1l.number,
	                }),
	            ]),
	            onEnter: PropTypes$1l.func,
	            onEntering: PropTypes$1l.func,
	            onEntered: PropTypes$1l.func,
	            onExit: PropTypes$1l.func,
	            onExiting: PropTypes$1l.func,
	            onExited: PropTypes$1l.func,
	            mountOnEnter: PropTypes$1l.bool,
	            unmountOnExit: PropTypes$1l.bool,
	            position: PropTypes$1l.oneOf(["above", "below", "left", "right"]),
	            visible: PropTypes$1l.bool.isRequired,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * This is a private hook that is used to cache and update the tooltip delay
	 * context state when needed.
	 *
	 * @param defaultDelay The default delay to use for all tooltips
	 * @return the tooltip delay state
	 */
	function useTooltipHoverModeState(defaultDelay, delayTimeout) {
	    var _a = React.useState(defaultDelay), delay = _a[0], setDelay = _a[1];
	    var delayRef = useRefCache(delay);
	    var disable = React.useCallback(function () {
	        if (delayRef.current === 0) {
	            setDelay(defaultDelay);
	        }
	        // disabled since useRefCache
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [defaultDelay]);
	    var _b = useTimeout(disable, delayTimeout), start = _b[0], stop = _b[1];
	    var enable = React.useCallback(function () {
	        stop();
	        if (delayRef.current !== 0) {
	            setDelay(0);
	        }
	        // disabled since useRefCache
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [stop]);
	    return {
	        delay: delay,
	        enable: enable,
	        startDisableTimer: start,
	    };
	}
	/**
	 * This keeps track of the current "immediate" delay to use for all child
	 * tooltip components.  When the `enable` function is called, this is updated to
	 * be `0` so tooltips can appear immediately on hover.
	 */
	var HoverModeDelay = React.createContext(DEFAULT_TOOLTIP_DELAY);
	/**
	 * Contains the actions to enable or start disabling the immediate mode for
	 * tooltips.
	 */
	var HoverModeActions = React.createContext({
	    enable: function () { },
	    startDisableTimer: function () { },
	});
	/**
	 * Keeps track of if the immediate mode is enabled. This allows for easy
	 * configuration of the app by automatically enabling hover mode functionality
	 * if the `ImmediateTooltipConfig` is in your app.
	 */
	var HoverModeEnabled = React.createContext(false);
	/**
	 * This hook returns the current delay timeout. This probably shouldn't be used
	 * much outside of this package.
	 * @private
	 */
	function useTooltipHoverModeDelay() {
	    return React.useContext(HoverModeDelay);
	}
	/**
	 * This hook returns the actions to enable the hover mode as well as start a
	 * timer to disable it.
	 * @private
	 */
	function useTooltipHoverModeActions() {
	    return React.useContext(HoverModeActions);
	}
	/**
	 * @private
	 */
	function useTooltipHoverModeEnabled() {
	    return React.useContext(HoverModeEnabled);
	}

	/**
	 * This handles creating and returning the required mouse event listeners to
	 * show and hide tooltips as needed. If there were any mouse event listeners
	 * passed in, they will be merged with the tooltip logic automatically and
	 * memoized.
	 */
	function useMouseState(_a) {
	    var mode = _a.mode, showTooltip = _a.showTooltip, hideTooltip = _a.hideTooltip, initiated = _a.initiated, setInitiated = _a.setInitiated, propDelay = _a.delay, onMouseEnter = _a.onMouseEnter, onMouseLeave = _a.onMouseLeave, setEstimatedPosition = _a.setEstimatedPosition, disableHoverMode = _a.disableHoverMode;
	    var handlers = useRefCache({ onMouseEnter: onMouseEnter, onMouseLeave: onMouseLeave });
	    var isHoverModeable = useTooltipHoverModeEnabled();
	    if (typeof disableHoverMode === "boolean") {
	        isHoverModeable = !disableHoverMode;
	    }
	    var delay = useTooltipHoverModeDelay();
	    if (!isHoverModeable) {
	        delay = propDelay;
	    }
	    var hoverModeActions = useTooltipHoverModeActions();
	    var _b = useTimeout(function () {
	        if (initiated.current === "mouse") {
	            showTooltip();
	            if (isHoverModeable) {
	                hoverModeActions.enable();
	            }
	        }
	    }, delay), start = _b[0], stop = _b[1];
	    var handleMouseEnter = React.useCallback(function (event) {
	        var onMouseEnter = handlers.current.onMouseEnter;
	        if (onMouseEnter) {
	            onMouseEnter(event);
	        }
	        if (initiated.current !== null) {
	            return;
	        }
	        setInitiated("mouse");
	        setEstimatedPosition(event.currentTarget);
	        start();
	    }, [setEstimatedPosition, setInitiated, start, handlers, initiated]);
	    var handleMouseLeave = React.useCallback(function (event) {
	        var onMouseLeave = handlers.current.onMouseLeave;
	        if (onMouseLeave) {
	            onMouseLeave(event);
	        }
	        if (initiated.current !== "mouse") {
	            return;
	        }
	        stop();
	        hideTooltip();
	        if (isHoverModeable) {
	            hoverModeActions.startDisableTimer();
	        }
	    }, [isHoverModeable, handlers, hideTooltip, hoverModeActions, initiated, stop]);
	    return [
	        stop,
	        mode !== "touch" ? handleMouseEnter : onMouseEnter,
	        mode !== "touch" ? handleMouseLeave : onMouseLeave,
	    ];
	}
	/**
	 * This handles creating and returning the required keyboard event listeners to
	 * show and hide tooltips as needed. If there were any keyboard event listeners
	 * passed in, they will be merged with the tooltip logic automatically and
	 * memoized.
	 */
	function useKeyboardState(_a) {
	    var mode = _a.mode, showTooltip = _a.showTooltip, hideTooltip = _a.hideTooltip, delay = _a.delay, initiated = _a.initiated, setInitiated = _a.setInitiated, onFocus = _a.onFocus, onBlur = _a.onBlur, onKeyDown = _a.onKeyDown, setEstimatedPosition = _a.setEstimatedPosition;
	    var handlers = useRefCache({ onFocus: onFocus, onBlur: onBlur, onKeyDown: onKeyDown });
	    var isWindowBlurred = React.useRef(false);
	    var _b = useTimeout(function () {
	        if (initiated.current === "keyboard") {
	            showTooltip();
	        }
	    }, delay), start = _b[0], stop = _b[1];
	    var handleFocus = React.useCallback(function (event) {
	        var onFocus = handlers.current.onFocus;
	        if (onFocus) {
	            onFocus(event);
	        }
	        // if the entire browser window was blurred, we don't want to show the
	        // tooltip on the next focus event since it is confusing to see a tooltip
	        // appear again after re-focusing a window.
	        if (isWindowBlurred.current) {
	            isWindowBlurred.current = false;
	            return;
	        }
	        setInitiated("keyboard");
	        setEstimatedPosition(event.currentTarget);
	        start();
	    }, 
	    // disabled since useRefCache for handlers
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [setEstimatedPosition, setInitiated, start]);
	    var handleBlur = React.useCallback(function (event) {
	        var onBlur = handlers.current.onBlur;
	        if (onBlur) {
	            onBlur(event);
	        }
	        stop();
	        hideTooltip();
	    }, 
	    // disabled since useRefCache for handlers
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [hideTooltip, stop]);
	    var handleKeyDown = React.useCallback(function (event) {
	        var onKeyDown = handlers.current.onKeyDown;
	        if (onKeyDown) {
	            onKeyDown(event);
	        }
	        if (initiated.current === "keyboard" && event.key === "Escape") {
	            stop();
	            hideTooltip();
	        }
	    }, 
	    // disabled since both initiated and handlers are refs
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [hideTooltip, stop]);
	    React.useEffect(function () {
	        if (mode !== "keyboard") {
	            return;
	        }
	        // whenever the browser loses focus, need to ensure that when the browser is
	        // re-focused the last focused element (that had a tooltip) does not make
	        // the tooltip appear
	        var handleWindowBlur = function () {
	            if (document.hidden) {
	                isWindowBlurred.current = true;
	                hideTooltip();
	            }
	            else {
	                window.requestAnimationFrame(function () {
	                    isWindowBlurred.current = false;
	                });
	            }
	        };
	        window.addEventListener("visibilitychange", handleWindowBlur);
	        return function () {
	            window.removeEventListener("visibilitychange", handleWindowBlur);
	        };
	    }, [mode, hideTooltip]);
	    return [
	        stop,
	        mode === "keyboard" ? handleFocus : onFocus,
	        mode === "keyboard" ? handleBlur : onBlur,
	        mode === "keyboard" ? handleKeyDown : onKeyDown,
	    ];
	}
	/**
	 * This handles creating and returning the required touch event listeners to
	 * show and hide tooltips as needed. If there were any touch event listeners
	 * passed in, they will be merged with the tooltip logic automatically and
	 * memoized.
	 *
	 * Tooltips on touch devices are a bit different than mouse and keyboard. Since
	 * tooltips appear after a long press on mobile and long presses on mobile cause
	 * a context menu to appear, no timeouts for showing the tooltip are started
	 * after a touchstart event.  The tooltip will only appear after a contextmenu
	 * event which has the default behavior prevented so the tooltip appears
	 * instead. After the tooltip appears, it will stay visible as long as the user
	 * keeps their finger on their phone. Once they remove their finger, the tooltip
	 * will be visible for another `x`ms to make it easier to read without their
	 * finger in the way and finally hide.
	 */
	function useTouchState(_a) {
	    var mode = _a.mode, visible = _a.visible, showTooltip = _a.showTooltip, hideTooltip = _a.hideTooltip, delay = _a.delay, setInitiated = _a.setInitiated, onTouchStart = _a.onTouchStart, onTouchMove = _a.onTouchMove, onContextMenu = _a.onContextMenu, setEstimatedPosition = _a.setEstimatedPosition;
	    var touched = React.useRef(false);
	    var handlers = useRefCache({ onTouchStart: onTouchStart, onTouchMove: onTouchMove, onContextMenu: onContextMenu });
	    var _b = useTimeout(function () {
	        touched.current = false;
	        hideTooltip();
	    }, delay), start = _b[0], stop = _b[1];
	    React.useEffect(function () {
	        if (!visible) {
	            return;
	        }
	        if (mode !== "touch") {
	            touched.current = false;
	            return;
	        }
	        var cb = function () {
	            start();
	            window.removeEventListener("touchend", cb, true);
	        };
	        window.addEventListener("touchend", cb, true);
	        return function () {
	            window.removeEventListener("touchend", cb, true);
	        };
	        // disabled since it should only be updated on visible or touch changes
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [visible, mode]);
	    var handleTouchStart = React.useCallback(function (event) {
	        var onTouchStart = handlers.current.onTouchStart;
	        if (onTouchStart) {
	            onTouchStart(event);
	        }
	        touched.current = true;
	        stop();
	        setEstimatedPosition(event.currentTarget);
	    }, 
	    // disabled since useRefCache for handlers
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [setEstimatedPosition, stop]);
	    var handleTouchMove = React.useCallback(function (event) {
	        var onTouchMove = handlers.current.onTouchMove;
	        if (onTouchMove) {
	            onTouchMove(event);
	        }
	        touched.current = false;
	    }, 
	    // disabled since useRefCache for handlers
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    []);
	    var handleContextMenu = React.useCallback(function (event) {
	        var onContextMenu = handlers.current.onContextMenu;
	        if (onContextMenu) {
	            onContextMenu(event);
	        }
	        if (!touched.current) {
	            return;
	        }
	        // need to prevent the context menu from appearing and instead show the tooltip
	        event.preventDefault();
	        // since the context menu might also select text by default, we want to deselect any
	        // selected text if it is within the container element
	        var selection = window.getSelection();
	        var selectionNode = selection && selection.anchorNode && selection.anchorNode.parentElement;
	        if (selection &&
	            selectionNode &&
	            event.currentTarget.contains(selectionNode)) {
	            selection.empty();
	        }
	        setInitiated("touch");
	        showTooltip();
	    }, 
	    // disabled since useRefCache for handlers
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [setInitiated, showTooltip]);
	    return [
	        stop,
	        handleTouchStart,
	        handleTouchMove,
	        mode === "touch" ? handleContextMenu : onContextMenu,
	    ];
	}

	var NOOP = function () { };
	/**
	 * A small hook that will set the tooltip position automatically based on the
	 * container element's location within the viewport. However, if the `position`
	 * option/prop was provided, that value will always be used instead.
	 */
	function usePosition(_a) {
	    var determinedPosition = _a.position, defaultPosition = _a.defaultPosition, threshold = _a.threshold;
	    var _b = React.useState(defaultPosition), position = _b[0], setPosition = _b[1];
	    var prevPosition = useRefCache(position);
	    /**
	     * This will only be used when the `determinedPosition` is undefined. When the
	     * container element starts the tooltip "visibility" mode, this will be called
	     * so that we can best guess what the position of the tooltip should be based
	     * on the current position of the container element within the viewport. If
	     * this isn't done and the tooltip swaps position due to the positioning
	     * logic, the animation will be reversed.
	     */
	    var setEstimatedPosition = React.useCallback(function (container) {
	        var _a = container.getBoundingClientRect(), top = _a.top, left = _a.left;
	        var nextPosition = defaultPosition;
	        var vh = getViewportSize("height");
	        var vw = getViewportSize("width");
	        switch (defaultPosition) {
	            case "above":
	                if (top < vh - vh * threshold) {
	                    nextPosition = "below";
	                }
	                break;
	            case "below":
	                if (top > vh * threshold) {
	                    nextPosition = "above";
	                }
	                break;
	            case "left":
	                if (left < vw - vw * threshold) {
	                    nextPosition = "right";
	                }
	                break;
	            case "right":
	                if (left > vw * threshold) {
	                    nextPosition = "left";
	                }
	                break;
	            // no default
	        }
	        if (prevPosition.current !== nextPosition) {
	            setPosition(nextPosition);
	        }
	    }, 
	    // disabled since useRefCache for prevPosition
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [defaultPosition, threshold]);
	    if (typeof determinedPosition !== "undefined") {
	        return {
	            position: determinedPosition,
	            setEstimatedPosition: NOOP,
	        };
	    }
	    return {
	        position: position,
	        setEstimatedPosition: setEstimatedPosition,
	    };
	}

	/**
	 * This hook will call the `onShow` and `onHide` functions as needed based on
	 * the current interaction mode and the visibility of the tooltip.
	 *
	 * @private
	 */
	function useVisiblityChange(_a) {
	    var onShow = _a.onShow, onHide = _a.onHide, visible = _a.visible, mode = _a.mode;
	    var handlers = useRefCache({ onShow: onShow, onHide: onHide });
	    React.useEffect(function () {
	        if (!visible || mode === null) {
	            return;
	        }
	        var _a = handlers.current, onShow = _a.onShow, onHide = _a.onHide;
	        if (onShow) {
	            onShow(mode);
	        }
	        return function () {
	            if (onHide) {
	                onHide();
	            }
	        };
	        // only want to trigger on visibility changes
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [visible]);
	}

	/**
	 * When the tooltip becomes visible, the tooltip should be hidden if any element
	 * within the page is clicked, or the browser is blurred. This hook will just
	 * add the required event listeners to hide the tooltip.
	 *
	 * Whent he entire window is blurred, we start a different flow to ensure that a
	 * tooltip won't appear when the window is re-focused. Without this flow, a
	 * keyboard user that had focused a tooltippable element will have the tooltip
	 * appear again after `x`ms which is not wanted. The user will need to manually
	 * re-focus the tooltippable element to show a tooltip again.
	 */
	function useOtherInteractionDisable(initiated, hideTooltip) {
	    React.useEffect(function () {
	        if (!initiated) {
	            return;
	        }
	        window.addEventListener("mousedown", hideTooltip, true);
	        window.addEventListener("click", hideTooltip, true);
	        return function () {
	            window.removeEventListener("mousedown", hideTooltip, true);
	            window.removeEventListener("click", hideTooltip, true);
	        };
	    }, [initiated, hideTooltip]);
	}
	/**
	 * This is a reusable hook that allows you to have all the event listeners and
	 * visibility logic of toolips so it can be used for any component. This is
	 * extremely helpful for when you want to create more complex tooltips (like
	 * dialogs).
	 *
	 * The tooltip state flow is pretty complex, so here's a quick run down of some
	 * of the logic:
	 * - the tooltip can only be shown by mouse, keyboard, or touch and can only be
	 *   closed by the same "initiation" type. So basically if the tooltip was shown
	 *   via mouse, it can only be closed by mouse as well.
	 * - if the user resizes the window, scrolls the page, clicks anywhere on the
	 *   page, switches tabs/ blurs the browser window while the tooltip is visible,
	 *   the tooltip will be hidden.
	 * - a keyboard user can hide the tooltip by pressing the escape key after it
	 *   was shown by focusing the element
	 *
	 * Since the tooltip can appear above or below the element, the position of the
	 * tooltip must be determined before the tooltip becomes visible or else the
	 * animation will be in the wrong direction.  So when one of the starting
	 * interaction types happen to the container element, the initial position is
	 * "guessed" based on the current viewport height and the position of the
	 * container element within the viewport.
	 */
	function useTooltipState(_a) {
	    var propPosition = _a.position, defaultPosition = _a.defaultPosition, _b = _a.positionThreshold, positionThreshold = _b === void 0 ? DEFAULT_TOOLTIP_THRESHOLD : _b, _c = _a.hoverDelay, hoverDelay = _c === void 0 ? DEFAULT_TOOLTIP_DELAY : _c, _d = _a.touchTimeout, touchTimeout = _d === void 0 ? DEFAULT_TOOLTIP_DELAY : _d, _e = _a.focusDelay, focusDelay = _e === void 0 ? DEFAULT_TOOLTIP_DELAY : _e, disableHoverMode = _a.disableHoverMode, onMouseEnter = _a.onMouseEnter, onMouseLeave = _a.onMouseLeave, onTouchStart = _a.onTouchStart, onTouchMove = _a.onTouchMove, onFocus = _a.onFocus, onBlur = _a.onBlur, onKeyDown = _a.onKeyDown, onShow = _a.onShow, onHide = _a.onHide;
	    var mode = useUserInteractionMode();
	    var initiated = React.useRef(null);
	    var setInitiated = React.useCallback(function (initiatedBy) {
	        initiated.current = initiatedBy;
	    }, []);
	    var _f = useToggle(false), visible = _f[0], showTooltip = _f[1], hide = _f[2];
	    var hideTooltip = React.useCallback(function () {
	        initiated.current = null;
	        hide();
	    }, [hide]);
	    useVisiblityChange({
	        visible: visible,
	        onShow: onShow,
	        onHide: onHide,
	        mode: initiated.current,
	    });
	    var _g = usePosition({
	        position: propPosition,
	        defaultPosition: defaultPosition,
	        threshold: positionThreshold,
	    }), position = _g.position, setEstimatedPosition = _g.setEstimatedPosition;
	    var _h = useMouseState({
	        mode: mode,
	        showTooltip: showTooltip,
	        hideTooltip: hideTooltip,
	        delay: hoverDelay,
	        disableHoverMode: disableHoverMode,
	        initiated: initiated,
	        setInitiated: setInitiated,
	        onMouseEnter: onMouseEnter,
	        onMouseLeave: onMouseLeave,
	        setEstimatedPosition: setEstimatedPosition,
	    }), stopMouseTimer = _h[0], handleMouseEnter = _h[1], handleMouseLeave = _h[2];
	    var _j = useKeyboardState({
	        mode: mode,
	        showTooltip: showTooltip,
	        hideTooltip: hideTooltip,
	        delay: focusDelay,
	        initiated: initiated,
	        setInitiated: setInitiated,
	        onFocus: onFocus,
	        onBlur: onBlur,
	        onKeyDown: onKeyDown,
	        setEstimatedPosition: setEstimatedPosition,
	    }), stopKeyboardTimer = _j[0], handleFocus = _j[1], handleBlur = _j[2], handleKeyDown = _j[3];
	    var _k = useTouchState({
	        mode: mode,
	        visible: visible,
	        showTooltip: showTooltip,
	        hideTooltip: hideTooltip,
	        delay: touchTimeout,
	        initiated: initiated,
	        setInitiated: setInitiated,
	        onTouchStart: onTouchStart,
	        onTouchMove: onTouchMove,
	        setEstimatedPosition: setEstimatedPosition,
	    }), stopTouchTimer = _k[0], handleTouchStart = _k[1], handleTouchMove = _k[2], handleContextMenu = _k[3];
	    var hideAndReset = React.useCallback(function () {
	        stopMouseTimer();
	        stopKeyboardTimer();
	        stopTouchTimer();
	        hide();
	    }, [stopMouseTimer, stopKeyboardTimer, stopTouchTimer, hide]);
	    useOtherInteractionDisable(initiated.current, hideAndReset);
	    return {
	        hide: hide,
	        visible: visible,
	        position: position,
	        handlers: {
	            onMouseEnter: handleMouseEnter,
	            onMouseLeave: handleMouseLeave,
	            onFocus: handleFocus,
	            onBlur: handleBlur,
	            onKeyDown: handleKeyDown,
	            onTouchStart: handleTouchStart,
	            onTouchMove: handleTouchMove,
	            onContextMenu: handleContextMenu,
	        },
	    };
	}

	var __assign$1w = (undefined && undefined.__assign) || function () {
	    __assign$1w = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1w.apply(this, arguments);
	};
	var __rest$1j = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var MERGABLE_PROPS = [
	    "onMouseEnter",
	    "onMouseLeave",
	    "onTouchStart",
	    "onTouchMove",
	    "onFocus",
	    "onKeyDown",
	    "onContextMenu",
	];
	/**
	 * The `Tooltipped` component can be used to dynamically add a tooltip to child
	 * element by cloning the required event handlers and accessibility props into
	 * the child with `React.cloneChild`.
	 */
	function Tooltipped(_a) {
	    var id = _a.id, children = _a.children, tooltipChildren = _a.tooltip, _b = _a.dense, dense = _b === void 0 ? false : _b, _c = _a.vhMargin, vhMargin = _c === void 0 ? 16 : _c, _d = _a.vwMargin, vwMargin = _d === void 0 ? 16 : _d, _e = _a.hoverDelay, hoverDelay = _e === void 0 ? DEFAULT_TOOLTIP_DELAY : _e, _f = _a.focusDelay, focusDelay = _f === void 0 ? DEFAULT_TOOLTIP_DELAY : _f, _g = _a.touchTimeout, touchTimeout = _g === void 0 ? DEFAULT_TOOLTIP_DELAY : _g, _h = _a.spacing, spacing = _h === void 0 ? "1.5rem" : _h, _j = _a.denseSpacing, denseSpacing = _j === void 0 ? "0.875rem" : _j, propPosition = _a.position, _k = _a.positionThreshold, positionThreshold = _k === void 0 ? DEFAULT_TOOLTIP_THRESHOLD : _k, _l = _a.portal, portal = _l === void 0 ? true : _l, portalInto = _a.portalInto, portalIntoId = _a.portalIntoId, onMouseEnter = _a.onMouseEnter, onMouseLeave = _a.onMouseLeave, onTouchStart = _a.onTouchStart, onTouchMove = _a.onTouchMove, onContextMenu = _a.onContextMenu, onFocus = _a.onFocus, onKeyDown = _a.onKeyDown, onShow = _a.onShow, onHide = _a.onHide, disableHoverMode = _a.disableHoverMode, describedBy = _a["aria-describedby"], _m = _a.defaultPosition, defaultPosition = _m === void 0 ? "below" : _m, disableSwapping = _a.disableSwapping, _o = _a.mountOnEnter, mountOnEnter = _o === void 0 ? true : _o, _p = _a.unmountOnExit, unmountOnExit = _p === void 0 ? true : _p, _q = _a.disableAutoSpacing, disableAutoSpacing = _q === void 0 ? undefined === "test" : _q, props = __rest$1j(_a, ["id", "children", "tooltip", "dense", "vhMargin", "vwMargin", "hoverDelay", "focusDelay", "touchTimeout", "spacing", "denseSpacing", "position", "positionThreshold", "portal", "portalInto", "portalIntoId", "onMouseEnter", "onMouseLeave", "onTouchStart", "onTouchMove", "onContextMenu", "onFocus", "onKeyDown", "onShow", "onHide", "disableHoverMode", "aria-describedby", "defaultPosition", "disableSwapping", "mountOnEnter", "unmountOnExit", "disableAutoSpacing"]);
	    var _r = useTooltipState({
	        position: propPosition,
	        disableHoverMode: disableHoverMode,
	        defaultPosition: defaultPosition,
	        positionThreshold: positionThreshold,
	        hoverDelay: hoverDelay,
	        focusDelay: focusDelay,
	        touchTimeout: touchTimeout,
	        onMouseEnter: onMouseEnter,
	        onMouseLeave: onMouseLeave,
	        onTouchStart: onTouchStart,
	        onTouchMove: onTouchMove,
	        onContextMenu: onContextMenu,
	        onFocus: onFocus,
	        onKeyDown: onKeyDown,
	        onShow: onShow,
	        onHide: onHide,
	    }), hide = _r.hide, visible = _r.visible, position = _r.position, handlers = _r.handlers;
	    var labelledBy = React.useRef(visible);
	    var currentSpacing = React.useMemo(function () { return unitToNumber(dense ? denseSpacing : spacing); }, [spacing, denseSpacing, dense]);
	    var getOptions;
	    if (!disableAutoSpacing) {
	        getOptions = function (node) {
	            var spacing = unitToNumber(window.getComputedStyle(node).getPropertyValue("--rmd-tooltip-spacing"));
	            return { xMargin: spacing, yMargin: spacing };
	        };
	    }
	    var isHorizontal = position === "left" || position === "right";
	    var _s = useFixedPositioning({
	        anchor: {
	            x: isHorizontal ? position : "center",
	            y: isHorizontal ? "center" : position,
	        },
	        disableSwapping: typeof disableSwapping === "boolean" ? disableSwapping : !!propPosition,
	        fixedTo: function () { return document.getElementById(id); },
	        vhMargin: vhMargin,
	        vwMargin: vwMargin,
	        yMargin: currentSpacing,
	        xMargin: currentSpacing,
	        onResize: hide,
	        onScroll: hide,
	        getOptions: getOptions,
	    }), style = _s.style, onEnter = _s.onEnter, onEntering = _s.onEntering, onEntered = _s.onEntered, onExited = _s.onExited;
	    if (!tooltipChildren) {
	        if (typeof children === "function") {
	            return children({ id: id, tooltip: null, "aria-describedby": describedBy });
	        }
	        var child_1 = React.Children.only(children);
	        return React.cloneElement(child_1, { id: id, "aria-describedby": describedBy });
	    }
	    var tooltipId = props.tooltipId;
	    if (!tooltipId) {
	        tooltipId = id + "-tooltip";
	    }
	    var tooltip = (React__default.createElement(ConditionalPortal, { portal: portal, portalInto: portalInto, portalIntoId: portalIntoId },
	        React__default.createElement(Tooltip, __assign$1w({ id: tooltipId }, props, { dense: dense, position: position, mountOnEnter: mountOnEnter, unmountOnExit: unmountOnExit, style: style, onEnter: function (node, appear) {
	                if (onEnter) {
	                    onEnter(node, appear);
	                }
	                labelledBy.current = true;
	            }, onEntering: onEntering, onEntered: onEntered, onExited: function (node) {
	                if (onExited) {
	                    onExited(node);
	                }
	                labelledBy.current = false;
	            }, visible: visible }), tooltipChildren)));
	    var config = __assign$1w({ id: id, "aria-describedby": classnames(labelledBy.current && tooltipId, describedBy) || undefined }, handlers);
	    if (typeof children === "function") {
	        return children(__assign$1w(__assign$1w({}, config), { tooltip: tooltip }));
	    }
	    var child = React.Children.only(children);
	    var merged = MERGABLE_PROPS.reduce(function (result, propName) {
	        var propHandler = child.props[propName];
	        var configHandler = config[propName];
	        if (!propHandler) {
	            result[propName] = configHandler;
	        }
	        else if (!configHandler) {
	            result[propName] = propHandler;
	        }
	        else {
	            // not sure of a way to actually strongly type this nicely.
	            // eslint-disable-next-line @typescript-eslint/no-explicit-any
	            result[propName] = function (event) {
	                propHandler(event);
	                configHandler(event);
	            };
	        }
	        return result;
	    }, __assign$1w({}, config));
	    return (React__default.createElement(React__default.Fragment, null,
	        React.cloneElement(child, merged),
	        tooltip));
	}
	{
	    try {
	        var PropTypes$1m = require("prop-types");
	        Tooltipped.propTypes = {
	            tooltipId: PropTypes$1m.string,
	            dense: PropTypes$1m.bool,
	            spacing: PropTypes$1m.oneOfType([PropTypes$1m.number, PropTypes$1m.string]),
	            denseSpacing: PropTypes$1m.oneOfType([PropTypes$1m.number, PropTypes$1m.string]),
	            positionThreshold: PropTypes$1m.number,
	            disableAutoSpacing: PropTypes$1m.bool,
	            vwMargin: PropTypes$1m.number,
	            vhMargin: PropTypes$1m.number,
	            portal: PropTypes$1m.bool,
	            lineWrap: PropTypes$1m.bool,
	            focusDelay: PropTypes$1m.number,
	            hoverDelay: PropTypes$1m.number,
	            touchTimeout: PropTypes$1m.number,
	            mountOnEnter: PropTypes$1m.bool,
	            unmountOnExit: PropTypes$1m.bool,
	            defaultPosition: PropTypes$1m.oneOf(["above", "below", "left", "right"]),
	        };
	    }
	    catch (e) { }
	}

	/**
	 * This component is used so that tooltips can gain the "hover mode"
	 * functionality in that once a tooltip has become visible by hover, all other
	 * tooltips will become visible immediately until 3 seconds have passed.
	 */
	function TooltipHoverModeConfig(_a) {
	    var _b = _a.defaultDelay, defaultDelay = _b === void 0 ? DEFAULT_TOOLTIP_DELAY : _b, _c = _a.delayTimeout, delayTimeout = _c === void 0 ? DEFAULT_TOOLTIP_DELAY : _c, _d = _a.enabled, enabled = _d === void 0 ? true : _d, children = _a.children;
	    var _e = useTooltipHoverModeState(defaultDelay, delayTimeout), delay = _e.delay, enable = _e.enable, startDisableTimer = _e.startDisableTimer;
	    var actions = React.useMemo(function () { return ({
	        enable: enable,
	        startDisableTimer: startDisableTimer,
	    }); }, [enable, startDisableTimer]);
	    return (React__default.createElement(HoverModeDelay.Provider, { value: delay },
	        React__default.createElement(HoverModeActions.Provider, { value: actions },
	            React__default.createElement(HoverModeEnabled.Provider, { value: enabled }, children))));
	}
	{
	    try {
	        var PropTypes$1n = require("prop-types");
	        TooltipHoverModeConfig.propTypes = {
	            enabled: PropTypes$1n.bool,
	            delayTimeout: PropTypes$1n.number,
	            defaultDelay: PropTypes$1n.number,
	            children: PropTypes$1n.node.isRequired,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1x = (undefined && undefined.__assign) || function () {
	    __assign$1x = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1x.apply(this, arguments);
	};
	/**
	 * This component allows you to quickly configure different functionality within
	 * `react-md` in one place with reasonable defaults.
	 */
	var Configuration = function (_a) {
	    var onAppResize = _a.onAppResize, children = _a.children, icons = _a.icons, formTheme = _a.formTheme, _b = _a.phoneMaxWidth, phoneMaxWidth = _b === void 0 ? DEFAULT_PHONE_MAX_WIDTH : _b, _c = _a.tabletMinWidth, tabletMinWidth = _c === void 0 ? DEFAULT_TABLET_MIN_WIDTH : _c, _d = _a.tabletMaxWidth, tabletMaxWidth = _d === void 0 ? DEFAULT_TABLET_MAX_WIDTH : _d, _e = _a.desktopMinWidth, desktopMinWidth = _e === void 0 ? DEFAULT_DESKTOP_MIN_WIDTH : _e, _f = _a.desktopLargeMinWidth, desktopLargeMinWidth = _f === void 0 ? DEFAULT_DESKTOP_LARGE_MIN_WIDTH : _f, _g = _a.defaultSize, defaultSize = _g === void 0 ? DEFAULT_APP_SIZE : _g, _h = _a.rippleTimeout, rippleTimeout = _h === void 0 ? DEFAULT_RIPPLE_TIMEOUT : _h, _j = _a.rippleClassNames, rippleClassNames = _j === void 0 ? DEFAULT_RIPPLE_CLASSNAMES : _j, _k = _a.disableRipple, disableRipple = _k === void 0 ? false : _k, _l = _a.disableProgrammaticRipple, disableProgrammaticRipple = _l === void 0 ? false : _l, _m = _a.disableTooltipHoverMode, disableTooltipHoverMode = _m === void 0 ? false : _m, _o = _a.tooltipDefaultDelay, tooltipDefaultDelay = _o === void 0 ? DEFAULT_TOOLTIP_DELAY : _o, _p = _a.tooltipDelayTimeout, tooltipDelayTimeout = _p === void 0 ? DEFAULT_TOOLTIP_DELAY : _p;
	    return (React__default.createElement(AppSizeListener, { defaultSize: defaultSize, onChange: onAppResize, phoneMaxWidth: phoneMaxWidth, tabletMinWidth: tabletMinWidth, tabletMaxWidth: tabletMaxWidth, desktopMinWidth: desktopMinWidth, desktopLargeMinWidth: desktopLargeMinWidth },
	        React__default.createElement(NestedDialogContextProvider, null,
	            React__default.createElement(InteractionModeListener, null,
	                React__default.createElement(StatesConfig, { disableRipple: disableRipple, disableProgrammaticRipple: disableProgrammaticRipple, rippleTimeout: rippleTimeout, rippleClassNames: rippleClassNames },
	                    React__default.createElement(TooltipHoverModeConfig, { enabled: !disableTooltipHoverMode, defaultDelay: tooltipDefaultDelay, delayTimeout: tooltipDelayTimeout },
	                        React__default.createElement(IconProvider, __assign$1x({}, icons),
	                            React__default.createElement(FormThemeProvider, __assign$1x({}, formTheme), children))))))));
	};
	{
	    try {
	        var PropTypes$1o = require("prop-types");
	        var querySize$1 = PropTypes$1o.oneOfType([PropTypes$1o.string, PropTypes$1o.number]);
	        Configuration.propTypes = {
	            children: PropTypes$1o.node.isRequired,
	            onAppResize: PropTypes$1o.func,
	            phoneMaxWidth: querySize$1,
	            tabletMinWidth: querySize$1,
	            tabletMaxWidth: querySize$1,
	            desktopMinWidth: querySize$1,
	            desktopLargeMinWidth: querySize$1,
	            defaultSize: PropTypes$1o.shape({
	                isPhone: PropTypes$1o.bool.isRequired,
	                isTablet: PropTypes$1o.bool.isRequired,
	                isDesktop: PropTypes$1o.bool.isRequired,
	                isLargeDesktop: PropTypes$1o.bool.isRequired,
	                isLandscape: PropTypes$1o.bool.isRequired,
	            }),
	            rippleTimeout: PropTypes$1o.oneOfType([
	                PropTypes$1o.number,
	                PropTypes$1o.shape({
	                    enter: PropTypes$1o.number,
	                    exit: PropTypes$1o.number,
	                }),
	            ]),
	            rippleClassNames: PropTypes$1o.oneOfType([
	                PropTypes$1o.string,
	                PropTypes$1o.shape({
	                    enter: PropTypes$1o.string,
	                    enterActive: PropTypes$1o.string,
	                    enterDone: PropTypes$1o.string,
	                    exit: PropTypes$1o.string,
	                    exitActive: PropTypes$1o.string,
	                }),
	            ]),
	            disableRipple: PropTypes$1o.bool,
	            disableProgrammaticRipple: PropTypes$1o.bool,
	            tooltipDelayTimeout: PropTypes$1o.number,
	            tooltipDefaultDelay: PropTypes$1o.number,
	            disableTooltipHoverMode: PropTypes$1o.bool,
	            icons: PropTypes$1o.shape({
	                back: PropTypes$1o.node,
	                checkbox: PropTypes$1o.node,
	                expander: PropTypes$1o.node,
	                dropdown: PropTypes$1o.node,
	                download: PropTypes$1o.node,
	                forward: PropTypes$1o.node,
	                menu: PropTypes$1o.node,
	                radio: PropTypes$1o.node,
	                password: PropTypes$1o.node,
	                notification: PropTypes$1o.node,
	                sort: PropTypes$1o.node,
	            }),
	            formTheme: PropTypes$1o.shape({
	                theme: PropTypes$1o.oneOf(["none", "underline", "outline", "filled"]),
	                underlineDirection: PropTypes$1o.oneOf(["left", "center", "right"]),
	            }),
	        };
	    }
	    catch (e) { }
	}

	var __assign$1y = (undefined && undefined.__assign) || function () {
	    __assign$1y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1y.apply(this, arguments);
	};
	var __rest$1k = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$Z = bem("rmd-link");
	/**
	 * The `Link` component is used to render links within your app with a basic
	 * styles applied and some additional "security" built-in if using the
	 * `rel="_blank"`. This can be used with a browser routing library like
	 * `react-router` or `reach-router` by providing the `Link` as the
	 * `linkComponent` prop.
	 */
	var Link = React.forwardRef(function Link(_a, ref) {
	    var propClassName = _a.className, _b = _a.component, Component = _b === void 0 ? "a" : _b, propHref = _a.href, children = _a.children, propRel = _a.rel, _c = _a.flexCentered, flexCentered = _c === void 0 ? false : _c, _d = _a.preventMaliciousTarget, preventMaliciousTarget = _d === void 0 ? true : _d, props = __rest$1k(_a, ["className", "component", "href", "children", "rel", "flexCentered", "preventMaliciousTarget"]);
	    var target = props.target;
	    var href = propHref === "" ? undefined : propHref;
	    var className = classnames(block$Z({ "flex-centered": flexCentered }), propClassName);
	    var rel = propRel;
	    if (preventMaliciousTarget &&
	        typeof rel !== "string" &&
	        target === "_blank") {
	        rel = "noopener noreferrer";
	    }
	    return (React__default.createElement(Component, __assign$1y({}, props, { className: className, ref: ref, rel: rel, href: href }), children));
	});
	{
	    try {
	        var PropTypes$1p = require("prop-types");
	        Link.propTypes = {
	            className: PropTypes$1p.string,
	            href: PropTypes$1p.string,
	            children: PropTypes$1p.node,
	            component: PropTypes$1p.oneOfType([
	                PropTypes$1p.string,
	                PropTypes$1p.func,
	                PropTypes$1p.object,
	            ]),
	            target: PropTypes$1p.string,
	            rel: PropTypes$1p.string,
	            preventMaliciousTarget: PropTypes$1p.bool,
	            flexCentered: PropTypes$1p.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1z = (undefined && undefined.__assign) || function () {
	    __assign$1z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1z.apply(this, arguments);
	};
	var __rest$1l = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$_ = bem("rmd-link-skip");
	/**
	 * This component allows you to create a screen-reader only/keyboard focusable
	 * only link that allows a user to skip to the main content of the page. This is
	 * extremely useful when you have a lot of navigation items that must be tabbed
	 * through before the main content can be focused and this component should
	 * normally be the first focusable element on your page.
	 */
	var SkipToMainContent = React.forwardRef(function SkipToMainContent(_a, ref) {
	    var _b = _a.id, id = _b === void 0 ? "skip-to-main-content" : _b, _c = _a.children, children = _c === void 0 ? "Skip to main content" : _c, _d = _a.unstyled, unstyled = _d === void 0 ? false : _d, mainId = _a.mainId, className = _a.className, onClick = _a.onClick, props = __rest$1l(_a, ["id", "children", "unstyled", "mainId", "className", "onClick"]);
	    var handleClick = React.useCallback(function (event) {
	        if (onClick) {
	            onClick(event);
	        }
	        event.preventDefault();
	        var main = document.getElementById(mainId);
	        if (!main) {
	            {
	                /* eslint-disable no-console */
	                var foundMain = document.querySelector("main");
	                var foundMainId = foundMain && foundMain.id;
	                console.error("Unable to find a main element to focus with an id of: \"" + mainId + "\".");
	                if (foundMainId) {
	                    console.error("However, a \"<main>\" element was found with an id: \"" + foundMainId + "\". Should this be the \"mainId\" prop for the \"SkipToMainContent\" component?");
	                }
	            }
	            return;
	        }
	        main.focus();
	    }, [mainId, onClick]);
	    return (React__default.createElement(Link, __assign$1z({}, props, { id: id, ref: ref, href: "#" + mainId, onClick: handleClick, className: classnames(block$_({ styled: !unstyled }), className) }), children));
	});
	{
	    try {
	        var PropTypes$1q = require("prop-types");
	        SkipToMainContent.propTypes = {
	            id: PropTypes$1q.string,
	            mainId: PropTypes$1q.string.isRequired,
	            onClick: PropTypes$1q.func,
	            className: PropTypes$1q.string,
	            children: PropTypes$1q.node,
	            unstyled: PropTypes$1q.bool,
	        };
	    }
	    catch (e) { }
	}

	var DEFAULT_PHONE_LAYOUT = "temporary";
	var DEFAULT_TABLET_LAYOUT = "toggleable";
	var DEFAULT_LANDSCAPE_TABLET_LAYOUT = "toggleable";
	var DEFAULT_DESKTOP_LAYOUT = "full-height";
	var DEFAULT_LAYOUT_MAIN_CLASSNAMES = {
	    enter: "rmd-layout-transition--enter",
	    enterActive: "rmd-layout-main--nav-offset",
	    enterDone: "rmd-layout-main--nav-offset",
	    exit: "rmd-layout-transition--exit",
	};
	var DEFFAULT_LAYOUT_NAV_TOGGLE_CLASSNAMES = {
	    enter: "rmd-layout-transition--enter",
	    enterActive: "rmd-layout-nav-toggle--offset",
	    enterDone: "rmd-layout-nav-toggle--offset",
	    exit: "rmd-layout-transition--exit",
	};

	/**
	 * Gets the current layout based on the app size and layout configuration.
	 *
	 * @return The current layout type
	 */
	function getLayoutType(_a) {
	    var appSize = _a.appSize, _b = _a.phoneLayout, phoneLayout = _b === void 0 ? DEFAULT_PHONE_LAYOUT : _b, _c = _a.tabletLayout, tabletLayout = _c === void 0 ? DEFAULT_TABLET_LAYOUT : _c, _d = _a.landscapeTabletLayout, landscapeTabletLayout = _d === void 0 ? DEFAULT_LANDSCAPE_TABLET_LAYOUT : _d, _e = _a.desktopLayout, desktopLayout = _e === void 0 ? DEFAULT_DESKTOP_LAYOUT : _e, _f = _a.largeDesktopLayout, largeDesktopLayout = _f === void 0 ? desktopLayout : _f;
	    var isPhone = appSize.isPhone, isTablet = appSize.isTablet, isLargeDesktop = appSize.isLargeDesktop, isLandscape = appSize.isLandscape;
	    if (isPhone) {
	        return phoneLayout;
	    }
	    if (isTablet) {
	        return isLandscape ? landscapeTabletLayout : tabletLayout;
	    }
	    if (isLargeDesktop) {
	        return largeDesktopLayout;
	    }
	    return desktopLayout;
	}
	/**
	 * Checks if the current `layout` is one of the temporary types
	 *
	 * @param layout The layout to check against
	 * @return true if the current layout has a temporary navigation.
	 */
	function isTemporaryLayout(layout) {
	    return layout === "temporary" || layout === "temporary-mini";
	}
	/**
	 * Checks if the current `layout` is one of the toggleable types
	 *
	 * @param layout The layout to check against
	 * @return true if the current layout is toggleable.
	 */
	function isToggleableLayout(layout) {
	    return layout === "toggleable" || layout === "toggleable-mini";
	}
	/**
	 * Checks if the current `layout` is `"clipped"`, `"floating"`, or `"full-height"`.
	 *
	 * @param layout The layout to check against
	 * @return true if the current layout is persistent.
	 */
	function isPersistentLayout(layout) {
	    return (layout === "clipped" || layout === "floating" || layout === "full-height");
	}
	/**
	 * Checks if the current `layout` is the `"full-height"` variant.
	 *
	 * @param layout The layout to check against
	 * @return true if the current layout is the full height variant.
	 */
	function isFullHeightLayout(layout) {
	    return layout === "full-height";
	}

	var __spreadArrays$4 = (undefined && undefined.__spreadArrays) || function () {
	    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	    for (var r = Array(s), k = 0, i = 0; i < il; i++)
	        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
	            r[k] = a[j];
	    return r;
	};
	/**
	 * @private
	 */
	var notInitialized = function (name) { return function () {
	    {
	        /* eslint-disable no-console */
	        console.warn("Uh oh, something went wrong. Somehow the `LayoutNavigationConfiguration` context has not been initialized. " +
	            ("This caused the \"" + name + "\" callback to do nothing."));
	    }
	}; };
	var context$3 = React.createContext({
	    baseId: "layout",
	    layout: "temporary",
	    visible: false,
	    showNav: notInitialized("showNav"),
	    hideNav: notInitialized("hideNav"),
	});
	/**
	 * Gets the current layout state and configuration.
	 */
	function useLayoutConfig() {
	    return React.useContext(context$3);
	}
	var Provider$3 = context$3.Provider;
	/**
	 * Determines the current layout based on the `LayoutConfiguration` and hooks
	 * into the `AppSizeListener` to update on resize. This also initializes the
	 * `LayLayoutContext` so that a custom layout implementation can be used along
	 * with the `useLayoutConfig()` hook and the multiple `Layout` components.
	 */
	var LayoutProvider = function (_a) {
	    var baseId = _a.baseId, _b = _a.phoneLayout, phoneLayout = _b === void 0 ? DEFAULT_PHONE_LAYOUT : _b, _c = _a.tabletLayout, tabletLayout = _c === void 0 ? DEFAULT_TABLET_LAYOUT : _c, _d = _a.landscapeTabletLayout, landscapeTabletLayout = _d === void 0 ? DEFAULT_LANDSCAPE_TABLET_LAYOUT : _d, _e = _a.desktopLayout, desktopLayout = _e === void 0 ? DEFAULT_DESKTOP_LAYOUT : _e, largeDesktopLayout = _a.largeDesktopLayout, children = _a.children;
	    var appSize = useAppSize();
	    var layout = getLayoutType({
	        appSize: appSize,
	        phoneLayout: phoneLayout,
	        tabletLayout: tabletLayout,
	        landscapeTabletLayout: landscapeTabletLayout,
	        desktopLayout: desktopLayout,
	        largeDesktopLayout: largeDesktopLayout,
	    });
	    var isPersistent = isPersistentLayout(layout);
	    var isDesktop = appSize.isDesktop;
	    var _f = React.useState(isPersistent && isDesktop), visible = _f[0], setVisible = _f[1];
	    var prevLayout = React.useRef(layout);
	    if (prevLayout.current !== layout) {
	        prevLayout.current = layout;
	        if (visible !== isPersistent) {
	            setVisible(isPersistent);
	        }
	    }
	    var showNav = React.useCallback(function () {
	        setVisible(true);
	    }, []);
	    var hideNav = React.useCallback(function () {
	        if (!isPersistentLayout(layout)) {
	            setVisible(false);
	        }
	    }, [layout]);
	    var value = React.useMemo(function () { return ({
	        baseId: baseId,
	        layout: layout,
	        visible: visible,
	        showNav: showNav,
	        hideNav: hideNav,
	    }); }, [baseId, layout, visible, showNav, hideNav]);
	    return React__default.createElement(Provider$3, { value: value }, children);
	};
	{
	    try {
	        context$3.displayName = "Layout";
	        var PropTypes$1r = require("prop-types");
	        var phoneLayouts = ["temporary", "temporary-mini"];
	        var tabletLayouts = __spreadArrays$4(phoneLayouts, ["toggleable", "toggleable-mini"]);
	        var wideLayouts = __spreadArrays$4(tabletLayouts, [
	            "clipped",
	            "floating",
	            "full-height",
	        ]);
	        LayoutProvider.propTypes = {
	            baseId: PropTypes$1r.string.isRequired,
	            children: PropTypes$1r.node.isRequired,
	            phoneLayout: PropTypes$1r.oneOf(phoneLayouts),
	            tabletLayout: PropTypes$1r.oneOf(tabletLayouts),
	            landscapeTabletLayout: PropTypes$1r.oneOf(wideLayouts),
	            desktopLayout: PropTypes$1r.oneOf(wideLayouts),
	            largeDesktopLayout: PropTypes$1r.oneOf(wideLayouts),
	        };
	    }
	    catch (error) { }
	}

	var __assign$1A = (undefined && undefined.__assign) || function () {
	    __assign$1A = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1A.apply(this, arguments);
	};
	var __rest$1m = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var styles$1 = bem("rmd-layout-title");
	/**
	 * An extremely simple wrapper for the `AppBarTitle` that will automatically
	 * apply an `id` and apply the correct margin for full-height layouts.
	 */
	var LayoutAppBarTitle = React.forwardRef(function LayoutAppBarTitle(_a, ref) {
	    var propId = _a.id, className = _a.className, children = _a.children, props = __rest$1m(_a, ["id", "className", "children"]);
	    var _b = useLayoutConfig(), baseId = _b.baseId, layout = _b.layout;
	    var id = propId !== null && propId !== void 0 ? propId : baseId + "-title";
	    return (React__default.createElement(AppBarTitle, __assign$1A({}, props, { id: id, ref: ref, className: classnames(styles$1({ offset: isFullHeightLayout(layout) }), className) }), children));
	});
	{
	    try {
	        var PropTypes$1s = require("prop-types");
	        LayoutAppBarTitle.propTypes = {
	            id: PropTypes$1s.string,
	            className: PropTypes$1s.string,
	            children: PropTypes$1s.node,
	        };
	    }
	    catch (error) { }
	}

	var DEFAULT_SHEET_TIMEOUT = {
	    enter: 200,
	    exit: 150,
	};
	var DEFAULT_SHEET_CLASSNAMES = {
	    appear: "rmd-sheet--offscreen",
	    appearActive: "rmd-sheet--enter rmd-sheet--visible",
	    enter: "rmd-sheet--offscreen",
	    enterActive: "rmd-sheet--enter rmd-sheet--visible",
	    exit: "rmd-sheet--exit",
	    exitActive: "rmd-sheet--offscreen",
	    exitDone: "rmd-sheet--offscreen rmd-sheet--hidden",
	};

	var __assign$1B = (undefined && undefined.__assign) || function () {
	    __assign$1B = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1B.apply(this, arguments);
	};
	var __rest$1n = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$$ = bem("rmd-sheet");
	/**
	 * The Sheet component is an extension of the `Dialog` except that it is fixed
	 * to the edges of the viewport instead of centered or full page. This component
	 * is great for rendering a navigation tree or menus on mobile devices.
	 */
	var Sheet = React.forwardRef(function Sheet(_a, ref) {
	    var _b;
	    var className = _a.className, children = _a.children, visible = _a.visible, _c = _a.position, position = _c === void 0 ? "left" : _c, _d = _a.horizontalSize, horizontalSize = _d === void 0 ? "media" : _d, _e = _a.verticalSize, verticalSize = _e === void 0 ? "recommended" : _e, _f = _a.overlay, propOverlay = _f === void 0 ? true : _f, overlayClassName = _a.overlayClassName, _g = _a.role, role = _g === void 0 ? "dialog" : _g, _h = _a.component, component = _h === void 0 ? "div" : _h, _j = _a.tabIndex, tabIndex = _j === void 0 ? -1 : _j, _k = _a.appear, appear = _k === void 0 ? false : _k, _l = _a.enter, enter = _l === void 0 ? true : _l, _m = _a.exit, exit = _m === void 0 ? true : _m, onExited = _a.onExited, propHidden = _a.hidden, _o = _a.timeout, timeout = _o === void 0 ? DEFAULT_SHEET_TIMEOUT : _o, _p = _a.classNames, classNames = _p === void 0 ? DEFAULT_SHEET_CLASSNAMES : _p, _q = _a.disableTransition, disableTransition = _q === void 0 ? false : _q, _r = _a.mountOnEnter, mountOnEnter = _r === void 0 ? true : _r, _s = _a.unmountOnExit, unmountOnExit = _s === void 0 ? true : _s, _t = _a.portal, portal = _t === void 0 ? true : _t, _u = _a.overlayHidden, overlayHidden = _u === void 0 ? false : _u, _v = _a.defaultFocus, defaultFocus = _v === void 0 ? "first" : _v, _w = _a.disableScrollLock, disableScrollLock = _w === void 0 ? false : _w, _x = _a.disableEscapeClose, disableEscapeClose = _x === void 0 ? false : _x, _y = _a.disableFocusContainer, disableFocusContainer = _y === void 0 ? false : _y, _z = _a.disableNestedDialogFixes, disableNestedDialogFixes = _z === void 0 ? false : _z, props = __rest$1n(_a, ["className", "children", "visible", "position", "horizontalSize", "verticalSize", "overlay", "overlayClassName", "role", "component", "tabIndex", "appear", "enter", "exit", "onExited", "hidden", "timeout", "classNames", "disableTransition", "mountOnEnter", "unmountOnExit", "portal", "overlayHidden", "defaultFocus", "disableScrollLock", "disableEscapeClose", "disableFocusContainer", "disableNestedDialogFixes"]);
	    var horizontal = position === "left" || position === "right";
	    var overlay = role !== "none" && propOverlay;
	    // if the sheet mounts while not visible and the conditional mounting isn't
	    // enabled, need to default to the offscreen state which is normally handled
	    // by the CSSTransition's exit state.
	    var offscreen = React.useRef(!visible && !unmountOnExit && !mountOnEnter);
	    if (offscreen.current && visible) {
	        offscreen.current = false;
	    }
	    // when sheets are not unmounted on exit, need to set it to hidden so that
	    // tabbing no longer focuses any of the elements inside
	    var _0 = React.useState(!visible && !mountOnEnter), hidden = _0[0], setHidden = _0[1];
	    if (hidden && visible) {
	        setHidden(false);
	    }
	    var handleExited = React.useCallback(function (node) {
	        if (onExited) {
	            onExited(node);
	        }
	        setHidden(true);
	    }, [onExited]);
	    return (React__default.createElement(Dialog, __assign$1B({}, props, { ref: ref, type: "custom", role: role, visible: visible, className: classnames(block$$((_b = {
	                horizontal: horizontal,
	                vertical: !horizontal,
	                raised: overlay,
	                offscreen: offscreen.current
	            },
	            _b[position] = true,
	            _b[horizontalSize + "-width"] = horizontal,
	            _b["viewport-height"] = !horizontal && verticalSize === "none",
	            _b["touchable-height"] = !horizontal && verticalSize === "touch",
	            _b["recommended-height"] = !horizontal && verticalSize === "recommended",
	            _b)), className), hidden: propHidden !== null && propHidden !== void 0 ? propHidden : hidden, overlay: overlay, overlayClassName: classnames("rmd-sheet-overlay", overlayClassName), component: component, tabIndex: tabIndex, appear: appear, enter: enter, exit: exit, timeout: timeout, classNames: classNames, disableTransition: disableTransition, mountOnEnter: mountOnEnter, unmountOnExit: unmountOnExit, onExited: handleExited, portal: portal, overlayHidden: overlayHidden, defaultFocus: defaultFocus, disableScrollLock: disableScrollLock, disableEscapeClose: disableEscapeClose, disableFocusContainer: disableFocusContainer, disableNestedDialogFixes: disableNestedDialogFixes }), children));
	});
	{
	    try {
	        var PropTypes$1t = require("prop-types");
	        Sheet.propTypes = {
	            id: PropTypes$1t.string.isRequired,
	            "aria-label": PropTypes$1t.string,
	            "aria-labelledby": PropTypes$1t.string,
	            className: PropTypes$1t.string,
	            tabIndex: PropTypes$1t.number,
	            visible: PropTypes$1t.bool.isRequired,
	            onRequestClose: PropTypes$1t.func.isRequired,
	            mountOnEnter: PropTypes$1t.bool,
	            unmountOnExit: PropTypes$1t.bool,
	            overlay: PropTypes$1t.bool,
	            overlayStyle: PropTypes$1t.object,
	            overlayClassName: PropTypes$1t.string,
	            overlayHidden: PropTypes$1t.bool,
	            containerStyle: PropTypes$1t.object,
	            containerClassName: PropTypes$1t.string,
	            children: PropTypes$1t.node,
	            classNames: PropTypes$1t.oneOfType([
	                PropTypes$1t.string,
	                PropTypes$1t.shape({
	                    appear: PropTypes$1t.string,
	                    appearActive: PropTypes$1t.string,
	                    enter: PropTypes$1t.string,
	                    enterActive: PropTypes$1t.string,
	                    enterDone: PropTypes$1t.string,
	                    exit: PropTypes$1t.string,
	                    exitActive: PropTypes$1t.string,
	                    exitDone: PropTypes$1t.string,
	                }),
	            ]),
	            timeout: PropTypes$1t.oneOfType([
	                PropTypes$1t.number,
	                PropTypes$1t.shape({
	                    enter: PropTypes$1t.number,
	                    exit: PropTypes$1t.number,
	                }),
	            ]),
	            appear: PropTypes$1t.bool,
	            enter: PropTypes$1t.bool,
	            exit: PropTypes$1t.bool,
	            disableTransition: PropTypes$1t.bool,
	            onEnter: PropTypes$1t.func,
	            onEntering: PropTypes$1t.func,
	            onEntered: PropTypes$1t.func,
	            onExit: PropTypes$1t.func,
	            onExiting: PropTypes$1t.func,
	            onExited: PropTypes$1t.func,
	            portal: PropTypes$1t.bool,
	            portalInto: PropTypes$1t.oneOfType([
	                PropTypes$1t.func,
	                PropTypes$1t.string,
	                PropTypes$1t.object,
	            ]),
	            portalIntoId: PropTypes$1t.string,
	            defaultFocus: PropTypes$1t.oneOfType([
	                PropTypes$1t.oneOf(["first", "last"]),
	                PropTypes$1t.string,
	            ]),
	            disableScrollLock: PropTypes$1t.bool,
	            disableEscapeClose: PropTypes$1t.bool,
	            disableFocusContainer: PropTypes$1t.bool,
	            disableNestedDialogFixes: PropTypes$1t.bool,
	            position: PropTypes$1t.oneOf(["top", "right", "bottom", "left"]),
	            horizontalSize: PropTypes$1t.oneOf(["none", "media", "touch", "static"]),
	            verticalSize: PropTypes$1t.oneOf(["none", "touch", "recommended"]),
	            role: PropTypes$1t.oneOf(["dialog", "menu", "none"]),
	            hidden: PropTypes$1t.bool,
	            component: PropTypes$1t.oneOf(["div", "nav"]),
	        };
	    }
	    catch (e) { }
	}

	var __assign$1C = (undefined && undefined.__assign) || function () {
	    __assign$1C = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1C.apply(this, arguments);
	};
	var __rest$1o = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This is the default implementation for the navigation toggle button within
	 * the `Layout` component and should normally be the first child for the
	 * `LayoutAppBar`. In addition, this component will automatically update itself
	 * to provide an accessible `aria-label` for screen readers and change to a
	 * toggle button for toggleable layouts.
	 */
	var LayoutNavToggle = React.forwardRef(function LayoutNavToggle(_a, forwardedRef) {
	    var propAriaLabel = _a["aria-label"], propAriaPressed = _a["aria-pressed"], propChildren = _a.children, propClassName = _a.className, _b = _a.buttonType, buttonType = _b === void 0 ? "icon" : _b, onClick = _a.onClick, propOffset = _a.offset, rendered = _a.rendered, propTabIndex = _a.tabIndex, _c = _a.timeout, timeout = _c === void 0 ? DEFAULT_SHEET_TIMEOUT : _c, _d = _a.classNames, classNames = _d === void 0 ? DEFFAULT_LAYOUT_NAV_TOGGLE_CLASSNAMES : _d, props = __rest$1o(_a, ["aria-label", "aria-pressed", "children", "className", "buttonType", "onClick", "offset", "rendered", "tabIndex", "timeout", "classNames"]);
	    var icon = useIcon("menu");
	    var _e = useLayoutConfig(), baseId = _e.baseId, layout = _e.layout, showNav = _e.showNav, hideNav = _e.hideNav, visible = _e.visible;
	    var isToggleable = isToggleableLayout(layout);
	    var isTemporary = isTemporaryLayout(layout);
	    var isRendered = rendered;
	    if (typeof isRendered === "undefined") {
	        isRendered = isTemporary || isToggleable;
	    }
	    var offset = propOffset;
	    if (typeof offset === "undefined") {
	        offset = isToggleable && visible;
	    }
	    var _f = useCSSTransition({
	        ref: forwardedRef,
	        transitionIn: offset,
	        temporary: false,
	        className: propClassName,
	        timeout: timeout,
	        classNames: classNames,
	    }), _g = _f[1], ref = _g.ref, className = _g.className;
	    if (!isRendered) {
	        return null;
	    }
	    var children = propChildren;
	    if (buttonType === "icon" && typeof children === "undefined") {
	        children = icon;
	    }
	    var tabIndex = propTabIndex;
	    if (typeof tabIndex === "undefined" && visible && isToggleable) {
	        // set to -1 so it isn't tab focusable but is still programmatically
	        // focusable for temporary navigation drawers to re-focus once closed
	        tabIndex = -1;
	    }
	    var ariaPressed = propAriaPressed;
	    if (typeof ariaPressed === "undefined" && isToggleable) {
	        ariaPressed = visible;
	    }
	    var ariaLabel = propAriaLabel;
	    if (typeof ariaLabel === "undefined" &&
	        typeof props["aria-labelledby"] === "undefined") {
	        ariaLabel = isToggleable ? "Navigation" : "Show Navigation";
	    }
	    return (React__default.createElement(AppBarNav, __assign$1C({ id: baseId + "-nav-toggle" }, props, { "aria-label": ariaLabel, "aria-pressed": ariaPressed, ref: ref, onClick: function (event) {
	            if (onClick) {
	                onClick(event);
	            }
	            if (!visible) {
	                showNav();
	            }
	            else {
	                hideNav();
	            }
	        }, buttonType: buttonType, tabIndex: tabIndex, className: classnames("rmd-layout-nav-toggle", className) }), children));
	});
	{
	    try {
	        var PropTypes$1u = require("prop-types");
	        LayoutNavToggle.propTypes = {
	            "aria-label": PropTypes$1u.string,
	            "aria-labelledby": PropTypes$1u.string,
	            "aria-pressed": PropTypes$1u.bool,
	            className: PropTypes$1u.string,
	            children: PropTypes$1u.node,
	            onClick: PropTypes$1u.func,
	            rendered: PropTypes$1u.bool,
	            tabIndex: PropTypes$1u.number,
	            buttonType: PropTypes$1u.oneOf(["text", "icon"]),
	            offset: PropTypes$1u.bool,
	            timeout: PropTypes$1u.oneOfType([
	                PropTypes$1u.number,
	                PropTypes$1u.shape({
	                    appear: PropTypes$1u.number,
	                    enter: PropTypes$1u.number,
	                    exit: PropTypes$1u.number,
	                }),
	            ]),
	            classNames: PropTypes$1u.oneOfType([
	                PropTypes$1u.string,
	                PropTypes$1u.shape({
	                    appear: PropTypes$1u.string,
	                    appearActive: PropTypes$1u.string,
	                    enter: PropTypes$1u.string,
	                    enterActive: PropTypes$1u.string,
	                    enterDone: PropTypes$1u.string,
	                    exit: PropTypes$1u.string,
	                    exitActive: PropTypes$1u.string,
	                    exitDone: PropTypes$1u.string,
	                }),
	            ]),
	        };
	    }
	    catch (error) { }
	}

	var __assign$1D = (undefined && undefined.__assign) || function () {
	    __assign$1D = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1D.apply(this, arguments);
	};
	var __rest$1p = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This is the default implementation for an `AppBar` within the `Layout` that
	 * will conditionally render the default `LayoutNavToggle` button and
	 * `AppBarTitle` depending on specific props that were provided.
	 */
	var LayoutAppBar = React.forwardRef(function LayoutAppBar(_a, ref) {
	    var children = _a.children, _b = _a.fixed, fixed = _b === void 0 ? true : _b, propNavToggle = _a.navToggle, navToggleProps = _a.navToggleProps, customTitle = _a.customTitle, titleChildren = _a.title, titleProps = _a.titleProps, props = __rest$1p(_a, ["children", "fixed", "navToggle", "navToggleProps", "customTitle", "title", "titleProps"]);
	    var _c = useLayoutConfig(), baseId = _c.baseId, layout = _c.layout;
	    var nav = propNavToggle;
	    if (typeof nav === "undefined") {
	        // set the key to the current layout since we want the button to re-mount
	        // on layout changes so the transition does not occur
	        nav = React__default.createElement(LayoutNavToggle, __assign$1D({ key: layout }, navToggleProps));
	    }
	    var title = customTitle;
	    if (typeof title === "undefined") {
	        title = (React__default.createElement(LayoutAppBarTitle, __assign$1D({}, titleProps), titleChildren));
	    }
	    return (React__default.createElement(AppBar, __assign$1D({ id: baseId + "-header" }, props, { ref: ref, fixed: fixed }),
	        nav,
	        title,
	        children));
	});
	{
	    try {
	        var PropTypes$1v = require("prop-types");
	        LayoutAppBar.propTypes = {
	            fixed: PropTypes$1v.bool,
	            navToggle: PropTypes$1v.node,
	            navToggleProps: PropTypes$1v.object,
	            className: PropTypes$1v.string,
	            customTitle: PropTypes$1v.node,
	            title: PropTypes$1v.node,
	            titleProps: PropTypes$1v.object,
	            children: PropTypes$1v.node,
	        };
	    }
	    catch (error) { }
	}

	var __assign$1E = (undefined && undefined.__assign) || function () {
	    __assign$1E = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1E.apply(this, arguments);
	};
	var __rest$1q = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var styles$2 = bem("rmd-layout-main");
	/**
	 * This is the `<main>` element for your app that has some built in styles to be
	 * able to update based on the current layout types.
	 */
	var LayoutMain = React.forwardRef(function LayoutMain(_a, forwardedRef) {
	    var propClassName = _a.className, propTabIndex = _a.tabIndex, _b = _a.component, Component = _b === void 0 ? "main" : _b, propNavOffset = _a.navOffset, _c = _a.headerOffset, headerOffset = _c === void 0 ? false : _c, _d = _a.timeout, propTimeout = _d === void 0 ? DEFAULT_SHEET_TIMEOUT : _d, _e = _a.classNames, classNames = _e === void 0 ? DEFAULT_LAYOUT_MAIN_CLASSNAMES : _e, props = __rest$1q(_a, ["className", "tabIndex", "component", "navOffset", "headerOffset", "timeout", "classNames"]);
	    // this makes it so that the SkipToMainContent button can still
	    // focus the `<main>` element, but the `<main>` will no longer be
	    // focused if the user clicks inside. This is super nice since one
	    // of my bigger patterns is to click somewhere then press tab to
	    // focus a specific element. Without this fix, the first element in
	    // the `<main>` tag would be focused instead of the closest focusable
	    // element to the click area.
	    var tabIndex = propTabIndex;
	    if (useIsUserInteractionMode("keyboard") &&
	        typeof propTabIndex === "undefined") {
	        tabIndex = -1;
	    }
	    var _f = useLayoutConfig(), layout = _f.layout, visible = _f.visible;
	    var navOffset = propNavOffset;
	    if (typeof navOffset === "undefined") {
	        navOffset = visible && !isTemporaryLayout(layout);
	    }
	    var timeout = propTimeout;
	    var prevLayout = React.useRef(layout);
	    if (prevLayout.current !== layout) {
	        // this is kind of weird and hacky, but this will allow for the required
	        // classnames to be applied to the main element based on the current
	        // layout type without needing a unique `key` for the main content. this
	        // is super nice since we really don't want to remount the full app each
	        // time the layout changes.
	        timeout = 0;
	    }
	    var _g = useCSSTransition({
	        ref: forwardedRef,
	        transitionIn: !!navOffset,
	        temporary: false,
	        className: propClassName,
	        timeout: timeout,
	        classNames: classNames,
	        onEntered: function () {
	            prevLayout.current = layout;
	        },
	        onExited: function () {
	            prevLayout.current = layout;
	        },
	    }), _h = _g[1], ref = _h.ref, className = _h.className;
	    return (React__default.createElement(Component, __assign$1E({}, props, { ref: ref, tabIndex: tabIndex, className: classnames(styles$2({ "header-offset": headerOffset }), className) })));
	});
	{
	    try {
	        var PropTypes$1w = require("prop-types");
	        LayoutMain.propTypes = {
	            component: PropTypes$1w.oneOf(["div", "main"]),
	            className: PropTypes$1w.string,
	            tabIndex: PropTypes$1w.number,
	            navOffset: PropTypes$1w.bool,
	            headerOffset: PropTypes$1w.bool,
	            timeout: PropTypes$1w.oneOfType([
	                PropTypes$1w.number,
	                PropTypes$1w.shape({
	                    appear: PropTypes$1w.number,
	                    enter: PropTypes$1w.number,
	                    exit: PropTypes$1w.number,
	                }),
	            ]),
	            classNames: PropTypes$1w.oneOfType([
	                PropTypes$1w.string,
	                PropTypes$1w.shape({
	                    appear: PropTypes$1w.string,
	                    appearActive: PropTypes$1w.string,
	                    enter: PropTypes$1w.string,
	                    enterActive: PropTypes$1w.string,
	                    enterDone: PropTypes$1w.string,
	                    exit: PropTypes$1w.string,
	                    exitActive: PropTypes$1w.string,
	                    exitDone: PropTypes$1w.string,
	                }),
	            ]),
	        };
	    }
	    catch (error) { }
	}

	var __assign$1F = (undefined && undefined.__assign) || function () {
	    __assign$1F = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1F.apply(this, arguments);
	};
	var __rest$1r = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * The `LayoutCloseNavigationButton` is used to close the navigation panel for
	 * toggleable layouts.
	 */
	var LayoutCloseNavigationButton = React.forwardRef(function LayoutCloseNavigationButton(_a, ref) {
	    var propId = _a.id, ariaLabelledBy = _a["aria-labelledby"], _b = _a["aria-label"], ariaLabel = _b === void 0 ? ariaLabelledBy ? undefined : "Hide Navigation" : _b, onClick = _a.onClick, _c = _a.first, first = _c === void 0 ? true : _c, _d = _a.last, last = _d === void 0 ? true : _d, _e = _a.buttonType, buttonType = _e === void 0 ? "icon" : _e, propChildren = _a.children, rendered = _a.rendered, props = __rest$1r(_a, ["id", "aria-labelledby", "aria-label", "onClick", "first", "last", "buttonType", "children", "rendered"]);
	    var children = useIcon("back", propChildren);
	    var _f = useLayoutConfig(), baseId = _f.baseId, layout = _f.layout, hideNav = _f.hideNav;
	    var handleClick = React.useCallback(function (event) {
	        if (onClick) {
	            onClick(event);
	        }
	        hideNav();
	    }, [onClick, hideNav]);
	    var id = propId !== null && propId !== void 0 ? propId : baseId + "-nav-x";
	    var isRendered = rendered !== null && rendered !== void 0 ? rendered : isToggleableLayout(layout);
	    if (!isRendered) {
	        return null;
	    }
	    return (React__default.createElement(AppBarAction, __assign$1F({}, props, { id: id, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, ref: ref, first: first, last: last, buttonType: buttonType, onClick: handleClick }), children));
	});
	{
	    try {
	        var PropTypes$1x = require("prop-types");
	        LayoutCloseNavigationButton.propTypes = {
	            id: PropTypes$1x.string,
	            "aria-label": PropTypes$1x.string,
	            "aria-labelledby": PropTypes$1x.string,
	            first: PropTypes$1x.bool,
	            last: PropTypes$1x.bool,
	            onClick: PropTypes$1x.func,
	            children: PropTypes$1x.node,
	            buttonType: PropTypes$1x.oneOf(["icon", "text"]),
	            rendered: PropTypes$1x.bool,
	        };
	    }
	    catch (error) { }
	}

	var __assign$1G = (undefined && undefined.__assign) || function () {
	    __assign$1G = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1G.apply(this, arguments);
	};
	var __rest$1s = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var styles$3 = bem("rmd-layout-nav-header");
	/**
	 * The default implementation for the `AppBar` within the `LayoutNavigation`
	 * that allows for rendering a title along with the `LayoutCloseNavigationButton`.
	 */
	var LayoutNavigationHeader = React.forwardRef(function LayoutNavigationHeader(_a, ref) {
	    var _b = _a.theme, theme = _b === void 0 ? "clear" : _b, children = _a.children, className = _a.className, closeNav = _a.closeNav, closeNavProps = _a.closeNavProps, propTitle = _a.title, titleProps = _a.titleProps, _c = _a.disableBorderBottom, disableBorderBottom = _c === void 0 ? false : _c, props = __rest$1s(_a, ["theme", "children", "className", "closeNav", "closeNavProps", "title", "titleProps", "disableBorderBottom"]);
	    var layout = useLayoutConfig().layout;
	    if (layout === "clipped" || layout === "floating") {
	        return null;
	    }
	    var title = null;
	    if (propTitle) {
	        title = React__default.createElement(AppBarTitle, __assign$1G({}, titleProps), propTitle);
	    }
	    var action = closeNav;
	    if (typeof action === "undefined") {
	        action = React__default.createElement(LayoutCloseNavigationButton, __assign$1G({}, closeNavProps));
	    }
	    return (React__default.createElement(AppBar, __assign$1G({}, props, { ref: ref, theme: theme, className: classnames(styles$3({ bordered: !disableBorderBottom }), className) }),
	        title,
	        children,
	        action));
	});
	{
	    try {
	        var PropTypes$1y = require("prop-types");
	        LayoutNavigationHeader.propTypes = {
	            disableBorderBottom: PropTypes$1y.bool,
	            className: PropTypes$1y.string,
	            closeNav: PropTypes$1y.node,
	            closeNavProps: PropTypes$1y.object,
	            theme: PropTypes$1y.oneOf(["clear", "primary", "secondary", "default"]),
	            children: PropTypes$1y.node,
	            title: PropTypes$1y.node,
	            titleProps: PropTypes$1y.object,
	        };
	    }
	    catch (error) { }
	}

	/**
	 * A hook that implements the base functionality for expanding different tree
	 * items.
	 *
	 * @param defaultExpandedIds Either a list of tree item ids to be expanded by
	 * default or a function that will return the list of tree item ids to be
	 * expanded by default
	 * @return An object containing props that can be passed to the `Tree` component
	 * to handle the expansion state within the tree.
	 */
	function useTreeItemExpansion(defaultExpandedIds) {
	    var _a = React.useState(defaultExpandedIds), expandedIds = _a[0], setExpandedIds = _a[1];
	    var onItemExpansion = React.useCallback(function (itemId, expanded) {
	        setExpandedIds(function (expandedIds) {
	            var nextExpandedIds = expandedIds;
	            var i = expandedIds.indexOf(itemId);
	            if (i === -1 && expanded) {
	                nextExpandedIds = expandedIds.slice();
	                nextExpandedIds.push(itemId);
	            }
	            else if (i !== -1 && !expanded) {
	                nextExpandedIds = expandedIds.slice();
	                nextExpandedIds.splice(i, 1);
	            }
	            return nextExpandedIds;
	        });
	    }, []);
	    var onMultiItemExpansion = React.useCallback(function (itemIds) {
	        setExpandedIds(itemIds);
	    }, []);
	    return {
	        expandedIds: expandedIds,
	        onItemExpansion: onItemExpansion,
	        onMultiItemExpansion: onMultiItemExpansion,
	    };
	}

	/**
	 * A hook that implements the base functionality for selecting different tree
	 * items.
	 *
	 * @param defaultSelectedIds The default list of tree item ids that should be
	 * expanded by default
	 * @param multiSelect Boolean if the tree can have multiple items selected or
	 * not.
	 * @return an object containing props that can be passed to the `Tree` component
	 * to handle the selection state within the tree
	 */
	function useTreeItemSelection(defaultSelectedIds, multiSelect) {
	    if (multiSelect === void 0) { multiSelect = false; }
	    var _a = React.useState(defaultSelectedIds), selectedIds = _a[0], setSelectedIds = _a[1];
	    var onItemSelect = React.useCallback(function (itemId) {
	        setSelectedIds(function (selectedIds) {
	            if (!multiSelect) {
	                if (selectedIds[0] === itemId && selectedIds.length === 1) {
	                    return selectedIds;
	                }
	                return [itemId];
	            }
	            var i = selectedIds.indexOf(itemId);
	            var nextSelectedIds = selectedIds.slice();
	            if (i === -1) {
	                nextSelectedIds.push(itemId);
	            }
	            else {
	                nextSelectedIds.splice(i, 1);
	            }
	            return nextSelectedIds;
	        });
	    }, [multiSelect]);
	    var onMultiItemSelect = React.useCallback(function (itemIds) {
	        setSelectedIds(itemIds);
	    }, []);
	    return {
	        selectedIds: selectedIds,
	        multiSelect: multiSelect,
	        onItemSelect: onItemSelect,
	        onMultiItemSelect: onMultiItemSelect,
	    };
	}

	/**
	 * A "reasonable" default implementation for rendering a label for a tree item.
	 *
	 * @private
	 */
	function defaultGetItemLabel(item, labelKey) {
	    var result = item[labelKey];
	    if (typeof result === "undefined") {
	        result = item.children;
	    }
	    if (typeof result === "undefined") {
	        result = null;
	    }
	    return result;
	}

	var warnedOnce = false;
	/**
	 * A "reasonable" default implementation for the getItemValue prop on a tree
	 * that will warn about items that are not keyboard searchable in non-production
	 * environments.
	 *
	 * @private
	 */
	function defaultGetItemValue(item, valueKey) {
	    var result = item[valueKey];
	    {
	        var type = typeof result;
	        if (!warnedOnce && type !== "string" && type !== "number") {
	            warnedOnce = true;
	            /* eslint-disable no-console */
	            console.warn("Unable to extract a string or number from an item within the tree for the item:");
	            console.warn(item);
	            console.warn("");
	            console.warn("This will make the item unable to be searched by typing within the tree and should be fixed before pushing to production.");
	            console.warn(new Error().stack);
	        }
	    }
	    return "" + result;
	}

	var __assign$1H = (undefined && undefined.__assign) || function () {
	    __assign$1H = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1H.apply(this, arguments);
	};
	var __rest$1t = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * The `TreeGroup` component is used to render a tree item's nested items
	 * whenever the `expanded` prop is `true`. It uses the `Collapse` component
	 * behind the scenes to animate in-and-out of view and will fully unrender when
	 * the `expanded` prop is `false`.
	 */
	var TreeGroup = React.forwardRef(function TreeGroup(_a, ref) {
	    var style = _a.style, className = _a.className, collapsed = _a.collapsed, minHeight = _a.minHeight, minPaddingBottom = _a.minPaddingBottom, minPaddingTop = _a.minPaddingTop, timeout = _a.timeout, onEnter = _a.onEnter, onEntering = _a.onEntering, onEntered = _a.onEntered, onExit = _a.onExit, onExiting = _a.onExiting, onExited = _a.onExited, children = _a.children, temporary = _a.temporary, props = __rest$1t(_a, ["style", "className", "collapsed", "minHeight", "minPaddingBottom", "minPaddingTop", "timeout", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "children", "temporary"]);
	    return (React__default.createElement(Collapse, { style: style, className: classnames("rmd-tree-group", className), collapsed: collapsed, minHeight: minHeight, minPaddingBottom: minPaddingBottom, minPaddingTop: minPaddingTop, timeout: timeout, onEnter: onEnter, onEntering: onEntering, onEntered: onEntered, onExit: onExit, onExiting: onExiting, onExited: onExited, temporary: temporary },
	        React__default.createElement(List, __assign$1H({}, props, { ref: ref, role: "group" }), children)));
	});
	{
	    try {
	        var PropTypes$1z = require("prop-types");
	        TreeGroup.propTypes = {
	            style: PropTypes$1z.object,
	            className: PropTypes$1z.string,
	            collapsed: PropTypes$1z.bool.isRequired,
	            minHeight: PropTypes$1z.oneOfType([PropTypes$1z.string, PropTypes$1z.number]),
	            minPaddingTop: PropTypes$1z.oneOfType([PropTypes$1z.string, PropTypes$1z.number]),
	            minPaddingBottom: PropTypes$1z.oneOfType([
	                PropTypes$1z.string,
	                PropTypes$1z.number,
	            ]),
	            timeout: PropTypes$1z.oneOfType([
	                PropTypes$1z.number,
	                PropTypes$1z.shape({
	                    appear: PropTypes$1z.number,
	                    enter: PropTypes$1z.number,
	                    exit: PropTypes$1z.number,
	                }),
	            ]),
	            temporary: PropTypes$1z.bool,
	            children: PropTypes$1z.node,
	            onEnter: PropTypes$1z.func,
	            onEntering: PropTypes$1z.func,
	            onEntered: PropTypes$1z.func,
	            onExit: PropTypes$1z.func,
	            onExiting: PropTypes$1z.func,
	            onExited: PropTypes$1z.func,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1I = (undefined && undefined.__assign) || function () {
	    __assign$1I = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1I.apply(this, arguments);
	};
	var __rest$1u = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$10 = bem("rmd-tree-item");
	/**
	 * The `TreeItemExpanderIcon` is a simple wrapper of the `IconRotator` prop to
	 * be used within a `TreeView`.
	 */
	function TreeItemExpanderIcon(_a) {
	    var className = _a.className, children = _a.children, _b = _a.rotated, rotated = _b === void 0 ? false : _b, props = __rest$1u(_a, ["className", "children", "rotated"]);
	    var icon = useIcon("expander", children);
	    return (React__default.createElement(IconRotator, __assign$1I({}, props, { rotated: rotated, className: classnames(block$10("rotator-icon"), className) }), icon));
	}

	var __assign$1J = (undefined && undefined.__assign) || function () {
	    __assign$1J = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1J.apply(this, arguments);
	};
	var __rest$1v = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$11 = bem("rmd-tree-item");
	/**
	 * This component renders an item within a tree with optional child items. This
	 * should almost always be used from the `itemRenderer` prop from the `Tree`
	 * component as it provides a lot of the required a11y props for you.
	 */
	var TreeItem = React.forwardRef(function TreeItem(_a, ref) {
	    var _b;
	    var id = _a.id, propClassName = _a.className, liStyle = _a.liStyle, liClassName = _a.liClassName, liRef = _a.liRef, depth = _a.depth, listSize = _a.listSize, itemIndex = _a.itemIndex, renderChildItems = _a.renderChildItems, expanded = _a.expanded, selected = _a.selected, focused = _a.focused, propExpanderIcon = _a.expanderIcon, _c = _a.expanderLeft, expanderLeft = _c === void 0 ? false : _c, textClassName = _a.textClassName, secondaryTextClassName = _a.secondaryTextClassName, _d = _a.textChildren, textChildren = _d === void 0 ? true : _d, primaryText = _a.primaryText, secondaryText = _a.secondaryText, propLeftAddon = _a.leftAddon, _e = _a.leftAddonType, leftAddonType = _e === void 0 ? "icon" : _e, _f = _a.leftAddonPosition, leftAddonPosition = _f === void 0 ? "middle" : _f, propRightAddon = _a.rightAddon, _g = _a.rightAddonType, rightAddonType = _g === void 0 ? "icon" : _g, _h = _a.rightAddonPosition, rightAddonPosition = _h === void 0 ? "middle" : _h, forceAddonWrap = _a.forceAddonWrap, _j = _a.height, height = _j === void 0 ? "auto" : _j, _k = _a.threeLines, threeLines = _k === void 0 ? false : _k, children = _a.children, _l = _a.contentComponent, Content = _l === void 0 ? "span" : _l, propIsLink = _a.isLink, _m = _a.disabled, disabled = _m === void 0 ? false : _m, readOnly = _a.readOnly, onFocus = _a.onFocus, props = __rest$1v(_a, ["id", "className", "liStyle", "liClassName", "liRef", "depth", "listSize", "itemIndex", "renderChildItems", "expanded", "selected", "focused", "expanderIcon", "expanderLeft", "textClassName", "secondaryTextClassName", "textChildren", "primaryText", "secondaryText", "leftAddon", "leftAddonType", "leftAddonPosition", "rightAddon", "rightAddonType", "rightAddonPosition", "forceAddonWrap", "height", "threeLines", "children", "contentComponent", "isLink", "disabled", "readOnly", "onFocus"]);
	    var expanderIcon = useIcon("expander", propExpanderIcon);
	    var isLink = typeof propIsLink === "boolean"
	        ? propIsLink
	        : typeof Content !== "string" || Content === "a";
	    var _o = useInteractionStates({
	        disabled: disabled,
	        className: propClassName,
	        handlers: isLink ? props : undefined,
	        disableSpacebarClick: isLink,
	    }), ripples = _o.ripples, className = _o.className, handlers = _o.handlers;
	    var group;
	    var leftAddon = propLeftAddon;
	    var rightAddon = propRightAddon;
	    if (renderChildItems) {
	        var icon = (React__default.createElement(TreeItemExpanderIcon, { rotated: expanded }, expanderIcon));
	        if (expanderLeft) {
	            leftAddon = icon;
	        }
	        else {
	            rightAddon = icon;
	        }
	        group = React__default.createElement(TreeGroup, { collapsed: !expanded }, renderChildItems());
	    }
	    var handleFocus = React.useCallback(function (event) {
	        if (onFocus) {
	            onFocus(event);
	        }
	        event.preventDefault();
	        var tree = event.currentTarget.closest('[role="tree"]');
	        if (tree) {
	            tree.focus();
	        }
	    }, [onFocus]);
	    var a11y = __assign$1J(__assign$1J({ "aria-expanded": renderChildItems ? expanded : undefined, "aria-level": depth + 1, "aria-setsize": listSize, "aria-posinset": itemIndex + 1, "aria-disabled": disabled ? "true" : undefined, id: id, role: "treeitem", tabIndex: -1 }, handlers), { onFocus: handleFocus });
	    var noA11y = { role: "none" };
	    return (React__default.createElement("li", __assign$1J({}, (isLink ? noA11y : a11y), { ref: liRef, style: liStyle, className: classnames(block$11(), liClassName) }),
	        React__default.createElement(Content, __assign$1J({}, props, (isLink ? a11y : undefined), { ref: ref, className: classnames(block$11("content", (_b = {
	                    link: isLink,
	                    clickable: !disabled && !readOnly
	                },
	                _b[height] = height !== "auto" && height !== "normal",
	                _b["three-lines"] = !!secondaryText && threeLines,
	                _b.selected = selected,
	                _b.focused = focused,
	                _b)), className) }),
	            React__default.createElement(ListItemChildren, { textClassName: textClassName, secondaryTextClassName: secondaryTextClassName, textChildren: textChildren, primaryText: primaryText, secondaryText: secondaryText, leftAddon: leftAddon, leftAddonType: leftAddonType, leftAddonPosition: leftAddonPosition, rightAddon: rightAddon, rightAddonType: rightAddonType, rightAddonPosition: rightAddonPosition, forceAddonWrap: forceAddonWrap }, children),
	            ripples),
	        group));
	});
	{
	    try {
	        var PropTypes$1A = require("prop-types");
	        TreeItem.propTypes = {
	            id: PropTypes$1A.string.isRequired,
	            depth: PropTypes$1A.number.isRequired,
	            itemIndex: PropTypes$1A.number.isRequired,
	            listSize: PropTypes$1A.number.isRequired,
	            selected: PropTypes$1A.bool.isRequired,
	            expanded: PropTypes$1A.bool.isRequired,
	            focused: PropTypes$1A.bool.isRequired,
	            renderChildItems: PropTypes$1A.func,
	            className: PropTypes$1A.string,
	            liRef: PropTypes$1A.oneOfType([PropTypes$1A.func, PropTypes$1A.object]),
	            liStyle: PropTypes$1A.object,
	            liClassName: PropTypes$1A.string,
	            textClassName: PropTypes$1A.string,
	            secondaryTextClassName: PropTypes$1A.string,
	            isLink: PropTypes$1A.bool,
	            onFocus: PropTypes$1A.func,
	            contentComponent: PropTypes$1A.oneOfType([
	                PropTypes$1A.string,
	                PropTypes$1A.func,
	                PropTypes$1A.object,
	            ]),
	            disabled: PropTypes$1A.bool,
	            readOnly: PropTypes$1A.bool,
	            expanderLeft: PropTypes$1A.bool,
	            expanderIcon: PropTypes$1A.node,
	            height: PropTypes$1A.oneOf([
	                "auto",
	                "normal",
	                "medium",
	                "large",
	                "extra-large",
	            ]),
	            threeLines: PropTypes$1A.bool,
	            textChildren: PropTypes$1A.bool,
	            children: PropTypes$1A.node,
	            primaryText: PropTypes$1A.node,
	            secondaryText: PropTypes$1A.node,
	            leftAddon: PropTypes$1A.node,
	            leftAddonType: PropTypes$1A.oneOf([
	                "icon",
	                "avatar",
	                "media",
	                "large-media",
	            ]),
	            leftAddonPosition: PropTypes$1A.oneOf(["top", "middle", "bottom"]),
	            rightAddon: PropTypes$1A.node,
	            rightAddonType: PropTypes$1A.oneOf([
	                "icon",
	                "avatar",
	                "media",
	                "large-media",
	            ]),
	            rightAddonPosition: PropTypes$1A.oneOf(["top", "middle", "bottom"]),
	            forceAddonWrap: PropTypes$1A.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$1K = (undefined && undefined.__assign) || function () {
	    __assign$1K = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1K.apply(this, arguments);
	};
	function isElementType(contentComponent) {
	    return typeof contentComponent !== "undefined";
	}
	/**
	 * A "reasonable" default implementation for rendering a tree item that extracts
	 * the most used ListItem props and passes them down to the `TreeItem`.
	 *
	 * This is actually exported from this package so it can be used along with a
	 * custom renderer for all items that have `isCustom` enabled.
	 *
	 * ```tsx
	 * const itemRenderer: TreeItemRenderer<MyTreeItem> = (
	 *   itemProps,
	 *   item,
	 *   treeProps
	 * ) => {
	 *   const { key } = itemProps;
	 *   const { isCustom } = item;
	 *   if (isCustom) {
	 *     return <MyFancyNonTreeItem item={item} key={key} />
	 *   }
	 *
	 *   return defaultTreeItemRenderer(itemProps, item, treeProps);
	 * }
	 * ```
	 *
	 * @param itemProps The providied tree item props that should be passed down for
	 * keyboard functionality, accessibility, and a `key` for the item.
	 * @param item The item itself. This is used to extract any of the common
	 * ListItemChildren props.
	 * @param treeProps The props for the Tree this item is being rendered in. This
	 * is really used so the `expanderLeft`, `expanderIcon`, `labelKey`,
	 * `getItemLabel`, and `getItemProps` can be used to render the TreeItem itself.
	 * @return a `TreeItem` or a custom `ReactElement`
	 */
	function defaultTreeItemRenderer(itemProps, item, treeProps) {
	    var treeItem = item;
	    var focused = itemProps.focused, selected = itemProps.selected, expanded = itemProps.expanded;
	    var expanderLeft = treeProps.expanderLeft, expanderIcon = treeProps.expanderIcon, labelKey = treeProps.labelKey, getItemLabel = treeProps.getItemLabel, getItemProps = treeProps.getItemProps, linkComponent = treeProps.linkComponent;
	    var leftAddon = treeItem.leftAddon, leftAddonType = treeItem.leftAddonType, leftAddonPosition = treeItem.leftAddonPosition, rightAddon = treeItem.rightAddon, rightAddonType = treeItem.rightAddonType, rightAddonPosition = treeItem.rightAddonPosition, as = treeItem.as, to = treeItem.to, href = treeItem.href;
	    var isLink;
	    var readOnly;
	    var disabled;
	    if (typeof treeItem.isLink === "boolean") {
	        (isLink = treeItem.isLink);
	    }
	    if (typeof treeItem.readOnly === "boolean") {
	        (readOnly = treeItem.readOnly);
	    }
	    if (typeof treeItem.disabled === "boolean") {
	        (disabled = treeItem.disabled);
	    }
	    var overrides = getItemProps(__assign$1K(__assign$1K({}, treeItem), { focused: focused,
	        selected: selected,
	        expanded: expanded }));
	    var children = (overrides && overrides.children) || undefined;
	    if (typeof children === "undefined") {
	        children = getItemLabel(treeItem, labelKey);
	    }
	    var contentComponent;
	    if (isElementType(treeItem.contentComponent)) {
	        (contentComponent = treeItem.contentComponent);
	    }
	    if (isLink !== false && (to || href || isLink)) {
	        contentComponent = contentComponent || linkComponent;
	    }
	    return (React__default.createElement(TreeItem, __assign$1K({}, itemProps, { as: as, to: to, href: href, isLink: isLink, contentComponent: contentComponent, readOnly: readOnly, disabled: disabled, leftAddon: leftAddon, leftAddonType: leftAddonType, leftAddonPosition: leftAddonPosition, rightAddon: rightAddon, rightAddonType: rightAddonType, rightAddonPosition: rightAddonPosition, expanderLeft: expanderLeft, expanderIcon: expanderIcon }, overrides), children));
	}

	/**
	 * A small util for recursively generating a unique id for each tree item based
	 * on the current depth within the tree and the index within the current list.
	 *
	 * @param treeId The base id of the tree element
	 * @param index The current index of the item
	 * @param parentIndexes A list of parent indexes that are joined together with
	 * `'-'` to generate the full id.
	 * @private
	 */
	function getTreeItemId(treeId, index, parentIndexes) {
	    if (parentIndexes === void 0) { parentIndexes = []; }
	    if (!parentIndexes.length) {
	        return treeId + "-item-" + (index + 1);
	    }
	    return treeId + "-item-" + parentIndexes.join("-") + "-" + (index + 1);
	}

	var __spreadArrays$5 = (undefined && undefined.__spreadArrays) || function () {
	    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	    for (var r = Array(s), k = 0, i = 0; i < il; i++)
	        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
	            r[k] = a[j];
	    return r;
	};
	function flatten(_a) {
	    var list = _a.list, item = _a.item, index = _a.index, baseId = _a.baseId, parentIndexes = _a.parentIndexes, valueKey = _a.valueKey, getItemValue = _a.getItemValue;
	    if (item.isCustom) {
	        return list;
	    }
	    var id = getTreeItemId(baseId, index, parentIndexes);
	    var value = getItemValue(item, valueKey);
	    var itemId = item.itemId, parentId = item.parentId, childItems = item.childItems;
	    list.push({
	        id: id,
	        itemId: itemId,
	        parentId: parentId,
	        isParent: !!childItems,
	        value: value,
	    });
	    if (!childItems) {
	        return list;
	    }
	    var nextIndexes = __spreadArrays$5(parentIndexes, [index + 1]);
	    childItems.forEach(function (child, childIndex) {
	        flatten({
	            list: list,
	            item: child,
	            index: childIndex,
	            valueKey: valueKey,
	            getItemValue: getItemValue,
	            baseId: baseId,
	            parentIndexes: nextIndexes,
	        });
	    });
	    return list;
	}
	/**
	 * Creates a flattened and ordered list of all the tree items that are current visible
	 * in the DOM based on the expanded ids. This is only required for handling keyboard
	 * navigation with `aria-activedescendant` movement so the items can be "focused" with
	 * typeahead and keyboard movement since the keyboard movement API requires DOM refs
	 * to be passed to each element.
	 *
	 * This flattened list will remove the `childItems` (if it existed) on each item for
	 * simplicity and the child items aren't needed for this flattened list.
	 *
	 * @private
	 */
	function useFlattenedTreeList(_a) {
	    var id = _a.id, items = _a.items, rootId = _a.rootId, expandedIds = _a.expandedIds, valueKey = _a.valueKey, getItemValue = _a.getItemValue;
	    var flattenedItems = React.useMemo(function () {
	        return items.reduce(function (list, item, index) {
	            return flatten({
	                list: list,
	                item: item,
	                index: index,
	                valueKey: valueKey,
	                getItemValue: getItemValue,
	                baseId: id,
	                parentIndexes: [],
	            });
	        }, []);
	    }, [getItemValue, id, items, valueKey]);
	    var _b = React.useMemo(function () {
	        var index = 0;
	        return flattenedItems.reduce(function (collection, item) {
	            var _a, _b;
	            var parentId = item.parentId, itemId = item.itemId;
	            var isVisible = parentId === rootId;
	            if (parentId !== null && expandedIds.includes(parentId)) {
	                // need to also make sure that the parent is visible
	                isVisible =
	                    ((_b = (_a = collection.itemRefs[parentId]) === null || _a === void 0 ? void 0 : _a.visibleIndex) !== null && _b !== void 0 ? _b : -1) !== -1;
	            }
	            collection.itemRefs[itemId] = {
	                id: item.id,
	                ref: { current: null },
	                visibleIndex: isVisible ? index : -1,
	            };
	            if (isVisible) {
	                index += 1;
	                collection.visibleItems.push(item);
	            }
	            return collection;
	        }, { visibleItems: [], itemRefs: {} });
	    }, [expandedIds, flattenedItems, rootId]), visibleItems = _b.visibleItems, itemRefs = _b.itemRefs;
	    return [visibleItems, itemRefs, flattenedItems];
	}

	var __assign$1L = (undefined && undefined.__assign) || function () {
	    __assign$1L = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1L.apply(this, arguments);
	};
	/**
	 * This util performantly builds a nested list of tree items from a giant flat
	 * list of items by linking items together with the provided `parentId`. This
	 * will also recursively build the tree and _hopefully_ all items will be added.
	 *
	 * If there are no children for a specific item
	 *
	 * TODO: Add a dev-only warning/error if the tree is built, but there are some
	 * items that never referenced another `itemId`
	 *
	 * @private
	 */
	function buildTree(parentId, items, sort) {
	    var childItems = [];
	    // doing a "reverse" order filter/move so that the items array shrinks while
	    // looping. This makes it so that the entire items array doesn't need to
	    // continually be looped through as more items are added to the tree, only the
	    // remaining items will have to be looped
	    var i = items.length;
	    while (i > 0) {
	        i -= 1;
	        if (items[i] && items[i].parentId === parentId) {
	            var item = items.splice(i, 1)[0];
	            // shallow cloning so childItems doesn't get applied to the original data
	            // set
	            childItems.unshift(__assign$1L({}, item));
	        }
	    }
	    if (!childItems.length) {
	        return undefined;
	    }
	    childItems.forEach(function (childItem) {
	        childItem.childItems = buildTree(childItem.itemId, items, sort);
	    });
	    return sort ? sort(childItems) : childItems;
	}
	/**
	 * This is an internal hook that will create a renderable nested list view of
	 * the tree data.
	 *
	 * @private
	 * @param tree The full tree to convert to a nested list representation
	 * @param sort An optional function that sorts the items at each level
	 * @param rootId The starting `parentId` to use while building the tree.  This
	 * defaults to `null` since this is most likely the general use case, but if
	 * there's a different unique identifier for the "root level" items, that can be
	 * used instead.
	 */
	function useNestedTreeList(tree, sort, rootId) {
	    if (rootId === void 0) { rootId = null; }
	    return React.useMemo(function () { return buildTree(rootId, Object.values(tree), sort) || []; }, [
	        rootId,
	        sort,
	        tree,
	    ]);
	}

	var __assign$1M = (undefined && undefined.__assign) || function () {
	    __assign$1M = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1M.apply(this, arguments);
	};
	var __spreadArrays$6 = (undefined && undefined.__spreadArrays) || function () {
	    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	    for (var r = Array(s), k = 0, i = 0; i < il; i++)
	        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
	            r[k] = a[j];
	    return r;
	};
	/**
	 * This hook handles all the complex and "fun" stuff for selecting keyboard
	 * accessibility within a tree and enabling keyboard movement, selection, and
	 * expansion.
	 *
	 * @private
	 */
	function useTreeMovement(_a) {
	    var id = _a.id, data = _a.data, rootId = _a.rootId, sort = _a.sort, onBlur = _a.onBlur, onFocus = _a.onFocus, onKeyDown = _a.onKeyDown, multiSelect = _a.multiSelect, selectedIds = _a.selectedIds, onItemSelect = _a.onItemSelect, onMultiItemSelect = _a.onMultiItemSelect, expandedIds = _a.expandedIds, onItemExpansion = _a.onItemExpansion, onMultiItemExpansion = _a.onMultiItemExpansion, valueKey = _a.valueKey, getItemValue = _a.getItemValue;
	    var items = useNestedTreeList(data, sort, rootId);
	    var _b = useFlattenedTreeList({
	        id: id,
	        items: items,
	        expandedIds: expandedIds,
	        rootId: rootId,
	        valueKey: valueKey,
	        getItemValue: getItemValue,
	    }), visibleItems = _b[0], itemIdRefs = _b[1], flattenedItems = _b[2];
	    var isKeyboard = useIsUserInteractionMode("keyboard");
	    var _c = useActiveDescendantMovement(__assign$1M(__assign$1M({}, VERTICAL_TREE), { items: visibleItems, baseId: id, getId: function (_baseId, index) {
	            return (visibleItems[index] || { id: "" }).id;
	        },
	        onSpace: function (focusedIndex) {
	            var item = visibleItems[focusedIndex];
	            if (!item) {
	                return;
	            }
	            var itemId = item.itemId;
	            onItemSelect(itemId);
	        },
	        onChange: function (data) {
	            var index = data.index, target = data.target, query = data.query;
	            var itemId = visibleItems[index].itemId;
	            var item = itemIdRefs[itemId].ref.current;
	            if (item && target && target.scrollHeight > target.offsetHeight) {
	                scrollIntoView(target, item);
	            }
	            if (!multiSelect) {
	                return;
	            }
	            var isToStart = query.endsWith(exports.JumpMovementKey.ControlShiftHome);
	            var isToEnd = query.endsWith(exports.JumpMovementKey.ControlShiftEnd);
	            if (!isToStart && !isToEnd) {
	                return;
	            }
	            var start = isToStart ? 0 : focusedIndex;
	            var end = isToStart ? focusedIndex + 1 : undefined;
	            var jumpSelectedIds = visibleItems
	                .slice(start, end)
	                .map(function (_a) {
	                var itemId = _a.itemId;
	                return itemId;
	            });
	            var uniqueSelectedIds = Array.from(new Set(__spreadArrays$6(selectedIds, jumpSelectedIds)));
	            if (selectedIds.length !== uniqueSelectedIds.length) {
	                onMultiItemSelect(uniqueSelectedIds);
	            }
	        },
	        onKeyDown: function (event) {
	            var _a, _b, _c, _d;
	            if (onKeyDown) {
	                onKeyDown(event);
	            }
	            var item = visibleItems[focusedIndex];
	            if (!item) {
	                return;
	            }
	            var itemId = item.itemId, parentId = item.parentId, isParent = item.isParent;
	            switch (event.key) {
	                case "Enter": {
	                    if (isParent) {
	                        onItemExpansion(itemId, !expandedIds.includes(itemId));
	                        return;
	                    }
	                    var node = itemIdRefs[itemId].ref.current;
	                    var anchor = node &&
	                        node.getAttribute("role") === "none" &&
	                        node.querySelector("a[href]");
	                    if (!anchor) {
	                        onItemSelect(itemId);
	                        return;
	                    }
	                    // if a user is navigating through the app with a keyboard and presses
	                    // cmd+shift+enter (Mac) or ctrl+shift+enter (Windows), the link will
	                    // be forcefully opened in a new tab irregardless of the target
	                    // attribute on the anchor tag. Since a tree doesn't actually focus
	                    // the link in this case, need to "polyfill" it with this workaround.
	                    // the `meta` key is for Mac and `ctrlKey` for Windows
	                    var forceNewTab = event.shiftKey && (event.metaKey || event.ctrlKey);
	                    var prevTarget = anchor.target;
	                    if (forceNewTab) {
	                        anchor.target = "_blank";
	                    }
	                    anchor.click();
	                    if (forceNewTab) {
	                        anchor.target = prevTarget;
	                    }
	                    break;
	                }
	                case "ArrowRight":
	                    if (!isParent) {
	                        return;
	                    }
	                    if (!expandedIds.includes(itemId)) {
	                        onItemExpansion(itemId, true);
	                    }
	                    else {
	                        var nextIndex = focusedIndex + 1;
	                        var nextItem = (_b = itemIdRefs[(_a = visibleItems[nextIndex]) === null || _a === void 0 ? void 0 : _a.itemId]) === null || _b === void 0 ? void 0 : _b.ref.current;
	                        setFocusedIndex(nextIndex);
	                        scrollIntoView(event.currentTarget, nextItem);
	                    }
	                    break;
	                case "ArrowLeft":
	                    if (isParent && expandedIds.includes(itemId)) {
	                        onItemExpansion(itemId, false);
	                    }
	                    else if (parentId !== rootId) {
	                        var parentIndex = visibleItems.findIndex(function (item) { return item.itemId === parentId; });
	                        var parentItem = (_d = itemIdRefs[(_c = visibleItems[parentIndex]) === null || _c === void 0 ? void 0 : _c.itemId]) === null || _d === void 0 ? void 0 : _d.ref.current;
	                        setFocusedIndex(parentIndex);
	                        scrollIntoView(event.currentTarget, parentItem);
	                    }
	                    break;
	                case "a": {
	                    if (!multiSelect || !event.ctrlKey) {
	                        return;
	                    }
	                    event.preventDefault();
	                    var allItemIds = visibleItems.map(function (_a) {
	                        var itemId = _a.itemId;
	                        return itemId;
	                    });
	                    if (selectedIds.length === allItemIds.length) {
	                        onMultiItemSelect([]);
	                    }
	                    else {
	                        onMultiItemSelect(allItemIds);
	                    }
	                    break;
	                }
	                case "*": {
	                    var item_1 = visibleItems[focusedIndex];
	                    if (!item_1) {
	                        return;
	                    }
	                    var expectedExpandedIds = visibleItems
	                        .filter(function (_a) {
	                        var isParent = _a.isParent, parentId = _a.parentId;
	                        return isParent && parentId === item_1.parentId;
	                    })
	                        .map(function (_a) {
	                        var itemId = _a.itemId;
	                        return itemId;
	                    });
	                    var nextIds = Array.from(new Set(__spreadArrays$6(expandedIds, expectedExpandedIds)));
	                    if (nextIds.length !== expandedIds.length) {
	                        onMultiItemExpansion(nextIds);
	                        // since new items will be rendered, need to also update the focused
	                        // index so the currently active item is still the "focused" item
	                        //
	                        // TODO: Look into a much better way to handle this sort of stuff..
	                        // This still doesn't correctly scroll the active element into view.
	                        // I should probably move all the scroll behavior into a useEffect
	                        // for whenever the focusedIndex changes.
	                        var visibleCount = 0;
	                        var lookup = {};
	                        for (var i = 0; i < flattenedItems.length; i += 1) {
	                            var item_2 = flattenedItems[i];
	                            var isVisible = item_2.parentId === rootId;
	                            if (item_2.parentId !== null && nextIds.includes(item_2.parentId)) {
	                                isVisible = !!lookup[item_2.parentId];
	                            }
	                            lookup[item_2.itemId] = isVisible;
	                            if (itemId === item_2.itemId) {
	                                setFocusedIndex(visibleCount);
	                                return;
	                            }
	                            if (isVisible) {
	                                visibleCount += 1;
	                            }
	                        }
	                    }
	                }
	                // no default
	            }
	        } })), activeId = _c.activeId, handleKeyDown = _c.onKeyDown, focusedIndex = _c.focusedIndex, setFocusedIndex = _c.setFocusedIndex;
	    var lastFocus = React.useRef(0);
	    var handleBlur = React.useCallback(function (event) {
	        if (onBlur) {
	            onBlur(event);
	        }
	        if (document.activeElement &&
	            event.currentTarget.contains(document.activeElement)) {
	            return;
	        }
	        lastFocus.current = focusedIndex;
	        setFocusedIndex(-1);
	    }, [focusedIndex, onBlur, setFocusedIndex]);
	    var handleFocus = React.useCallback(function (event) {
	        var _a, _b;
	        if (onFocus) {
	            onFocus(event);
	        }
	        if (focusedIndex !== -1) {
	            // this happens when a tree item is clicked with the mouse or touch
	            return;
	        }
	        var index = -1;
	        // try to "focus" the first selected itemId if there is a selection.
	        if (selectedIds.length) {
	            index = visibleItems.findIndex(function (item) {
	                return selectedIds.includes(item.itemId);
	            });
	        }
	        // fallback to the first visible tree item if there were no selected ids
	        if (index === -1) {
	            index = Math.max(0, Math.min(lastFocus.current, visibleItems.length));
	        }
	        var currentItem = (_b = itemIdRefs[(_a = visibleItems[index]) === null || _a === void 0 ? void 0 : _a.itemId]) === null || _b === void 0 ? void 0 : _b.ref.current;
	        if (currentItem && isKeyboard) {
	            scrollIntoView(event.currentTarget, currentItem);
	        }
	        setFocusedIndex(index);
	    }, [
	        focusedIndex,
	        isKeyboard,
	        itemIdRefs,
	        onFocus,
	        selectedIds,
	        setFocusedIndex,
	        visibleItems,
	    ]);
	    var setActiveId = React.useCallback(function (itemId) {
	        var index = visibleItems.findIndex(function (item) { return item.itemId === itemId; });
	        if (index !== -1) {
	            setFocusedIndex(index);
	        }
	    }, [setFocusedIndex, visibleItems]);
	    return {
	        items: items,
	        activeId: activeId,
	        setActiveId: setActiveId,
	        itemIdRefs: itemIdRefs,
	        handleBlur: handleBlur,
	        handleFocus: handleFocus,
	        handleKeyDown: handleKeyDown,
	    };
	}

	var __assign$1N = (undefined && undefined.__assign) || function () {
	    __assign$1N = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1N.apply(this, arguments);
	};
	var __rest$1w = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var __spreadArrays$7 = (undefined && undefined.__spreadArrays) || function () {
	    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	    for (var r = Array(s), k = 0, i = 0; i < il; i++)
	        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
	            r[k] = a[j];
	    return r;
	};
	var block$12 = bem("rmd-tree");
	var defaultGetItemProps = function () { return undefined; };
	/**
	 * Creates an accessible tree widget that allows you to show hierarchical data
	 * in a list presentation view. This component requires the selection and
	 * expansion state to be provided/controlled but you can use the
	 * `useTreeItemSelection` and `useTreeItemExpansion` hooks for a great starting
	 * point for this functionality.
	 */
	var Tree = React.forwardRef(function Tree(// eslint-disable-line @typescript-eslint/no-explicit-any
	_a, ref) {
	    var id = _a.id, className = _a.className, _b = _a.itemRenderer, itemRenderer = _b === void 0 ? defaultTreeItemRenderer : _b, data = _a.data, _c = _a.multiSelect, multiSelect = _c === void 0 ? false : _c, selectedIds = _a.selectedIds, onItemSelect = _a.onItemSelect, onMultiItemSelect = _a.onMultiItemSelect, expandedIds = _a.expandedIds, onItemExpansion = _a.onItemExpansion, onMultiItemExpansion = _a.onMultiItemExpansion, _d = _a.expanderLeft, expanderLeft = _d === void 0 ? false : _d, propExpanderIcon = _a.expanderIcon, _e = _a.labelKey, labelKey = _e === void 0 ? "name" : _e, _f = _a.valueKey, valueKey = _f === void 0 ? "name" : _f, _g = _a.getItemLabel, getItemLabel = _g === void 0 ? defaultGetItemLabel : _g, _h = _a.getItemValue, getItemValue = _h === void 0 ? defaultGetItemValue : _h, _j = _a.getItemProps, getItemProps = _j === void 0 ? defaultGetItemProps : _j, linkComponent = _a.linkComponent, sort = _a.sort, _k = _a.rootId, rootId = _k === void 0 ? null : _k, onBlur = _a.onBlur, onFocus = _a.onFocus, onKeyDown = _a.onKeyDown, props = __rest$1w(_a, // eslint-disable-line @typescript-eslint/no-explicit-any
	    ["id", "className", "itemRenderer", "data", "multiSelect", "selectedIds", "onItemSelect", "onMultiItemSelect", "expandedIds", "onItemExpansion", "onMultiItemExpansion", "expanderLeft", "expanderIcon", "labelKey", "valueKey", "getItemLabel", "getItemValue", "getItemProps", "linkComponent", "sort", "rootId", "onBlur", "onFocus", "onKeyDown"]);
	    var expanderIcon = useIcon("dropdown", propExpanderIcon);
	    var _l = useTreeMovement({
	        id: id,
	        data: data,
	        sort: sort,
	        rootId: rootId,
	        onBlur: onBlur,
	        onFocus: onFocus,
	        onKeyDown: onKeyDown,
	        multiSelect: multiSelect,
	        selectedIds: selectedIds,
	        onItemSelect: onItemSelect,
	        onMultiItemSelect: onMultiItemSelect,
	        expandedIds: expandedIds,
	        onItemExpansion: onItemExpansion,
	        onMultiItemExpansion: onMultiItemExpansion,
	        valueKey: valueKey,
	        getItemValue: getItemValue,
	    }), items = _l.items, activeId = _l.activeId, setActiveId = _l.setActiveId, itemIdRefs = _l.itemIdRefs, handleBlur = _l.handleBlur, handleFocus = _l.handleFocus, handleKeyDown = _l.handleKeyDown;
	    var renderChildItems = function (items, depth, parentIndexes) {
	        var listSize = items.length;
	        return items.map(function (item, index) {
	            var _a;
	            var itemId = item.itemId, childItems = item.childItems, isCustom = item.isCustom;
	            var selected = selectedIds.includes(itemId);
	            var expanded = expandedIds.includes(itemId);
	            var id = "";
	            var ref;
	            var visibleIndex = -1;
	            if (!isCustom) {
	                (_a = itemIdRefs[itemId], id = _a.id, ref = _a.ref, visibleIndex = _a.visibleIndex);
	            }
	            var focused = id === activeId;
	            return itemRenderer({
	                key: itemId,
	                id: id,
	                liRef: ref,
	                depth: depth,
	                listSize: listSize,
	                itemIndex: index,
	                selected: selected,
	                expanded: expanded,
	                focused: focused,
	                onClick: function () {
	                    setActiveId(itemId);
	                    onItemSelect(itemId);
	                    if (childItems) {
	                        onItemExpansion(itemId, !expanded);
	                    }
	                },
	                renderChildItems: childItems
	                    ? function () {
	                        return renderChildItems(childItems, depth + 1, __spreadArrays$7(parentIndexes, [
	                            index + 1,
	                        ]));
	                    }
	                    : undefined,
	            }, __assign$1N(__assign$1N({}, item), { visibleIndex: visibleIndex }), __assign$1N({ id: id,
	                expanderLeft: expanderLeft, expanderIcon: expanderIcon, multiSelect: multiSelect,
	                labelKey: labelKey,
	                valueKey: valueKey,
	                getItemLabel: getItemLabel,
	                getItemValue: getItemValue,
	                getItemProps: getItemProps,
	                linkComponent: linkComponent,
	                rootId: rootId }, props));
	        });
	    };
	    return (React__default.createElement(List, __assign$1N({}, props, { ref: ref, id: id, "aria-activedescendant": activeId, "aria-multiselectable": multiSelect || undefined, role: "tree", tabIndex: 0, className: classnames(block$12(), className), onBlur: handleBlur, onFocus: handleFocus, onKeyDown: handleKeyDown }), renderChildItems(items, 0, [])));
	});
	{
	    try {
	        var PropTypes$1B = require("prop-types");
	        Tree.propTypes = {
	            id: PropTypes$1B.string.isRequired,
	            className: PropTypes$1B.string,
	            onBlur: PropTypes$1B.func,
	            onFocus: PropTypes$1B.func,
	            onKeyDown: PropTypes$1B.func,
	            "aria-label": PropTypes$1B.string,
	            "aria-labelledby": PropTypes$1B.string,
	            // TODO: Update to custom prop validation for itemId and parentId
	            data: PropTypes$1B.object.isRequired,
	            rootId: PropTypes$1B.string,
	            sort: PropTypes$1B.func,
	            selectedIds: PropTypes$1B.arrayOf(PropTypes$1B.string).isRequired,
	            onItemSelect: PropTypes$1B.func.isRequired,
	            onMultiItemSelect: PropTypes$1B.func.isRequired,
	            expandedIds: PropTypes$1B.arrayOf(PropTypes$1B.string).isRequired,
	            onItemExpansion: PropTypes$1B.func.isRequired,
	            onMultiItemExpansion: PropTypes$1B.func.isRequired,
	            multiSelect: PropTypes$1B.bool,
	            expanderLeft: PropTypes$1B.bool,
	            expanderIcon: PropTypes$1B.node,
	            itemRenderer: PropTypes$1B.func,
	            labelKey: PropTypes$1B.string,
	            valueKey: PropTypes$1B.string,
	            getItemLabel: PropTypes$1B.func,
	            getItemValue: PropTypes$1B.func,
	            getItemProps: PropTypes$1B.func,
	            linkComponent: PropTypes$1B.oneOfType([
	                PropTypes$1B.func,
	                PropTypes$1B.object,
	                PropTypes$1B.oneOf(["a"]),
	            ]),
	        };
	    }
	    catch (e) { }
	}

	var __spreadArrays$8 = (undefined && undefined.__spreadArrays) || function () {
	    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	    for (var r = Array(s), k = 0, i = 0; i < il; i++)
	        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
	            r[k] = a[j];
	    return r;
	};
	/**
	 * Gets all the child items for a specific parent item id. If the `recursive`
	 * argument is enabled, all children of the items will also be returned instead
	 * of only the top level items.
	 *
	 * @param data Either the flattened tree data or a list of all the tree data to
	 * iterate over
	 * @param parentId The parent id to get children of
	 * @param recursive Boolean if the children's children should also be returned
	 * @return a list of all the items for a specific parent item id. Note: if the
	 * recursive param is enabled, the list will be ordered so that the children of
	 * a item will appear before the next item at the same level. So you either need
	 * to sort by `parentId` or something else if you want a specific order.
	 */
	function getChildItems(data, parentId, recursive) {
	    if (recursive === void 0) { recursive = false; }
	    var items = Array.isArray(data) ? data : Object.values(data);
	    return items.reduce(function (list, item) {
	        if (parentId !== item.parentId) {
	            return list;
	        }
	        return __spreadArrays$8(list, [
	            item
	        ], (recursive ? getChildItems(items, item.itemId, recursive) : []));
	    }, []);
	}

	/**
	 * This will get all the items from the provided itemId up to the root of the
	 * tree that can be used for drag and drop behavior or building a breadcrumb
	 * list.
	 *
	 * @param data The flattened tree data to navigate.
	 * @param itemId The item id to start the search at.
	 * @return an ordered list of the current item followed by all the direct
	 * parents of that item.
	 */
	function getItemsFrom(data, itemId) {
	    var items = [];
	    var currentId = itemId;
	    while (currentId) {
	        var item = data[currentId];
	        currentId = (item && item.parentId) || null;
	        if (item) {
	            items.push(item);
	        }
	    }
	    return items;
	}

	/**
	 * This is the default navigation item renderer provided by the layout package
	 * that has some reasonable defaults for creating a navigation tree. This is
	 * just an extension of the base `defaultTreeItemRenderer` from the
	 * `@react-md/tree` package that adds in some support for also rendering
	 * dividers and subheader elements.
	 */
	var defaultNavigationItemRenderer = function (itemProps, item, treeProps) {
	    var key = itemProps.key;
	    var divider = item.divider, subheader = item.subheader;
	    if (divider) {
	        return React__default.createElement(Divider, { key: key });
	    }
	    if (subheader) {
	        return (React__default.createElement(ListSubheader, { key: key, role: "none" }, item.children));
	    }
	    return defaultTreeItemRenderer(itemProps, item, treeProps);
	};

	var __assign$1O = (undefined && undefined.__assign) || function () {
	    __assign$1O = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1O.apply(this, arguments);
	};
	var __rest$1x = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * Renders the navigation tree for the Layout component that adds some
	 * reasonable defaults to work with navigation items.
	 */
	var LayoutTree = React.forwardRef(function LayoutTree(_a, ref) {
	    var propId = _a.id, ariaLabelledBy = _a["aria-labelledby"], _b = _a["aria-label"], ariaLabel = _b === void 0 ? ariaLabelledBy ? undefined : "Navigation" : _b, className = _a.className, navStyle = _a.navStyle, navClassName = _a.navClassName, navItems = _a.navItems, _c = _a.labelKey, labelKey = _c === void 0 ? "children" : _c, _d = _a.valueKey, valueKey = _d === void 0 ? "children" : _d, _e = _a.itemRenderer, itemRenderer = _e === void 0 ? defaultNavigationItemRenderer : _e, selectedIds = _a.selectedIds, _f = _a.disableTemporaryAutoclose, disableTemporaryAutoclose = _f === void 0 ? false : _f, props = __rest$1x(_a, ["id", "aria-labelledby", "aria-label", "className", "navStyle", "navClassName", "navItems", "labelKey", "valueKey", "itemRenderer", "selectedIds", "disableTemporaryAutoclose"]);
	    var _g = useLayoutConfig(), baseId = _g.baseId, layout = _g.layout, hideNav = _g.hideNav, visible = _g.visible;
	    var selectedId = selectedIds[0];
	    var lastSelectedId = React.useRef(selectedId);
	    var isTemporary = isTemporaryLayout(layout);
	    var id = propId !== null && propId !== void 0 ? propId : baseId + "-navigation-tree";
	    React.useEffect(function () {
	        if (disableTemporaryAutoclose ||
	            !isTemporary ||
	            !visible ||
	            lastSelectedId.current === selectedId) {
	            // need to update the lastSelectedId since the selectedId might've changed
	            // by a route change OUTSIDE of the navigation drawer. if it isn't
	            // updated, it'll automatically close the next time it is opened.
	            lastSelectedId.current = selectedId;
	            return;
	        }
	        lastSelectedId.current = selectedId;
	        hideNav();
	    }, [disableTemporaryAutoclose, isTemporary, visible, hideNav, selectedId]);
	    return (React__default.createElement("nav", { id: id + "-nav", style: navStyle, className: classnames("rmd-layout-nav", navClassName) },
	        React__default.createElement(Tree, __assign$1O({}, props, { id: id, ref: ref, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, data: navItems, labelKey: labelKey, valueKey: valueKey, selectedIds: selectedIds, itemRenderer: itemRenderer, className: classnames("rmd-layout-tree", className) }))));
	});
	{
	    try {
	        var PropTypes$1C = require("prop-types");
	        LayoutTree.propTypes = {
	            id: PropTypes$1C.string,
	            "aria-label": PropTypes$1C.string,
	            "aria-labelledby": PropTypes$1C.string,
	            className: PropTypes$1C.string,
	            navStyle: PropTypes$1C.object,
	            navClassName: PropTypes$1C.string,
	            children: PropTypes$1C.node,
	            labelKey: PropTypes$1C.string,
	            valueKey: PropTypes$1C.string,
	            navItems: PropTypes$1C.object.isRequired,
	            selectedIds: PropTypes$1C.arrayOf(PropTypes$1C.string).isRequired,
	            itemRenderer: PropTypes$1C.func,
	            disableTemporaryAutoclose: PropTypes$1C.bool,
	        };
	    }
	    catch (error) { }
	}

	var __assign$1P = (undefined && undefined.__assign) || function () {
	    __assign$1P = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1P.apply(this, arguments);
	};
	var __rest$1y = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var styles$4 = bem("rmd-layout-navigation");
	/**
	 * The container for the main navigation within the `Layout` that renders
	 * differently depending on the current layout type.
	 */
	var LayoutNavigation = React.forwardRef(function LayoutNavigation(_a, ref) {
	    var propId = _a.id, _b = _a["aria-label"], ariaLabel = _b === void 0 ? "Navigation" : _b, ariaLabelledby = _a["aria-labelledby"], className = _a.className, children = _a.children, propHeader = _a.header, headerProps = _a.headerProps, headerTitle = _a.headerTitle, headerTitleProps = _a.headerTitleProps, closeNav = _a.closeNav, closeNavProps = _a.closeNavProps, treeProps = _a.treeProps, props = __rest$1y(_a, ["id", "aria-label", "aria-labelledby", "className", "children", "header", "headerProps", "headerTitle", "headerTitleProps", "closeNav", "closeNavProps", "treeProps"]);
	    var _c = useLayoutConfig(), baseId = _c.baseId, layout = _c.layout, visible = _c.visible, hideNav = _c.hideNav;
	    var id = propId || baseId + "-nav-container";
	    var isTemporary = isTemporaryLayout(layout);
	    var isPersistent = isPersistentLayout(layout);
	    var isToggleable = isToggleableLayout(layout);
	    var floating = layout === "floating";
	    var header = propHeader;
	    if (typeof header === "undefined") {
	        header = (React__default.createElement(LayoutNavigationHeader, __assign$1P({ closeNav: closeNav, closeNavProps: closeNavProps, title: headerTitle, titleProps: headerTitleProps }, headerProps)));
	    }
	    return (React__default.createElement(Sheet, __assign$1P({}, props, { key: layout, id: id, ref: ref, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledby, role: !isPersistent ? "dialog" : "none", visible: visible, onRequestClose: hideNav, 
	        // do not want to portal for the other types so that logical tab order
	        // is preserved
	        portal: isTemporary, overlay: isTemporary, disableScrollLock: !isTemporary, disableTabFocusWrap: isToggleable, className: classnames(styles$4({
	            floating: floating,
	            "header-offset": layout === "clipped" || floating,
	        }), className) }),
	        header,
	        treeProps && React__default.createElement(LayoutTree, __assign$1P({}, treeProps)),
	        children));
	});
	{
	    try {
	        var PropTypes$1D = require("prop-types");
	        LayoutNavigation.propTypes = {
	            id: PropTypes$1D.string,
	            "aria-label": PropTypes$1D.string,
	            "aria-labelledby": PropTypes$1D.string,
	            className: PropTypes$1D.string,
	            children: PropTypes$1D.node,
	            treeProps: PropTypes$1D.object,
	            header: PropTypes$1D.node,
	            headerProps: PropTypes$1D.object,
	            headerTitle: PropTypes$1D.node,
	            headerTitleProps: PropTypes$1D.object,
	            closeNav: PropTypes$1D.node,
	            closeNavProps: PropTypes$1D.object,
	        };
	    }
	    catch (error) { }
	}

	var __assign$1Q = (undefined && undefined.__assign) || function () {
	    __assign$1Q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1Q.apply(this, arguments);
	};
	var __spreadArrays$9 = (undefined && undefined.__spreadArrays) || function () {
	    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	    for (var r = Array(s), k = 0, i = 0; i < il; i++)
	        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
	            r[k] = a[j];
	    return r;
	};
	/**
	 * The layout to use for your app. There are 9 different types of layouts
	 * supported out of the box that work for a decent amount of apps out of the
	 * box.
	 *
	 * Note: You will need to ensure that the base `Configuration` component is a
	 * parent of this `Layout` component to work since it relies on the
	 * `AppSizeContext` for automatically updating the layout based on media
	 * queries.
	 */
	var Layout = function (_a) {
	    var _b;
	    var _c = _a.id, id = _c === void 0 ? "layout" : _c, propAppBar = _a.appBar, appBarProps = _a.appBarProps, _d = _a.navAfterAppBar, navAfterAppBar = _d === void 0 ? false : _d, children = _a.children, skipProps = _a.skipProps, mainProps = _a.mainProps, _e = _a.phoneLayout, phoneLayout = _e === void 0 ? DEFAULT_PHONE_LAYOUT : _e, _f = _a.tabletLayout, tabletLayout = _f === void 0 ? DEFAULT_TABLET_LAYOUT : _f, _g = _a.landscapeTabletLayout, landscapeTabletLayout = _g === void 0 ? DEFAULT_LANDSCAPE_TABLET_LAYOUT : _g, _h = _a.desktopLayout, desktopLayout = _h === void 0 ? DEFAULT_DESKTOP_LAYOUT : _h, largeDesktopLayout = _a.largeDesktopLayout, customTitle = _a.customTitle, title = _a.title, titleProps = _a.titleProps, navToggle = _a.navToggle, navToggleProps = _a.navToggleProps, propNav = _a.nav, navProps = _a.navProps, navHeader = _a.navHeader, navHeaderProps = _a.navHeaderProps, navHeaderTitle = _a.navHeaderTitle, navHeaderTitleProps = _a.navHeaderTitleProps, closeNav = _a.closeNav, closeNavProps = _a.closeNavProps, treeProps = _a.treeProps;
	    var fixedAppBar = (_b = appBarProps === null || appBarProps === void 0 ? void 0 : appBarProps.fixed) !== null && _b !== void 0 ? _b : typeof propAppBar === "undefined";
	    var mainId = (mainProps === null || mainProps === void 0 ? void 0 : mainProps.id) || id + "-main";
	    var appBar = propAppBar;
	    if (typeof appBar === "undefined") {
	        appBar = (React__default.createElement(LayoutAppBar, __assign$1Q({}, appBarProps, { customTitle: customTitle, title: title, titleProps: titleProps, navToggle: navToggle, navToggleProps: navToggleProps })));
	    }
	    var nav = propNav;
	    if (typeof nav === "undefined") {
	        nav = (React__default.createElement(LayoutNavigation, __assign$1Q({ header: navHeader, headerProps: navHeaderProps, headerTitle: navHeaderTitle, headerTitleProps: navHeaderTitleProps, closeNav: closeNav, closeNavProps: closeNavProps, treeProps: treeProps }, navProps)));
	    }
	    return (React__default.createElement(LayoutProvider, { baseId: id, phoneLayout: phoneLayout, tabletLayout: tabletLayout, landscapeTabletLayout: landscapeTabletLayout, desktopLayout: desktopLayout, largeDesktopLayout: largeDesktopLayout },
	        React__default.createElement(SkipToMainContent, __assign$1Q({}, skipProps, { mainId: mainId })),
	        navAfterAppBar && appBar,
	        nav,
	        !navAfterAppBar && appBar,
	        React__default.createElement(LayoutMain, __assign$1Q({ headerOffset: fixedAppBar }, mainProps, { id: mainId }), children)));
	};
	{
	    try {
	        var PropTypes$1E = require("prop-types");
	        var phoneLayouts$1 = ["temporary", "temporary-mini"];
	        var tabletLayouts$1 = __spreadArrays$9(phoneLayouts$1, ["toggleable", "toggleable-mini"]);
	        var wideLayouts$1 = __spreadArrays$9(tabletLayouts$1, [
	            "clipped",
	            "floating",
	            "full-height",
	        ]);
	        Layout.propTypes = {
	            id: PropTypes$1E.string,
	            children: PropTypes$1E.node,
	            phoneLayout: PropTypes$1E.oneOf(phoneLayouts$1),
	            tabletLayout: PropTypes$1E.oneOf(tabletLayouts$1),
	            landscapeTabletLayout: PropTypes$1E.oneOf(wideLayouts$1),
	            desktopLayout: PropTypes$1E.oneOf(wideLayouts$1),
	            largeDesktopLayout: PropTypes$1E.oneOf(wideLayouts$1),
	            appBar: PropTypes$1E.node,
	            appBarProps: PropTypes$1E.object,
	            navAfterAppBar: PropTypes$1E.bool,
	            customTitle: PropTypes$1E.node,
	            title: PropTypes$1E.node,
	            titleProps: PropTypes$1E.object,
	            navToggle: PropTypes$1E.node,
	            navToggleProps: PropTypes$1E.object,
	            skipProps: PropTypes$1E.object,
	            nav: PropTypes$1E.node,
	            navProps: PropTypes$1E.object,
	            navHeader: PropTypes$1E.node,
	            navHeaderProps: PropTypes$1E.object,
	            navHeaderTitle: PropTypes$1E.node,
	            navHeaderTitleProps: PropTypes$1E.object,
	            closeNav: PropTypes$1E.node,
	            closeNavProps: PropTypes$1E.object,
	            treeProps: PropTypes$1E.object,
	            mainProps: PropTypes$1E.object,
	        };
	    }
	    catch (error) { }
	}

	var __spreadArrays$a = (undefined && undefined.__spreadArrays) || function () {
	    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	    for (var r = Array(s), k = 0, i = 0; i < il; i++)
	        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
	            r[k] = a[j];
	    return r;
	};
	/**
	 * @private
	 */
	var getParentIds = function (itemId, navItems) { return getItemsFrom(navItems, itemId).map(function (_a) {
	    var itemId = _a.itemId;
	    return itemId;
	}); };
	/**
	 * This is used to disable the item select and multi item select functionality
	 * since only one id can be selected at a time, and it'll always be the current
	 * pathname's itemId
	 *
	 * @private
	 */
	var noop$4 = function () { };
	/**
	 * This is a pretty reasonable default implementation for having a navigation
	 * tree within the Layout component. The way it'll work is that the current
	 * route will be the only selected item within the tree. When the pathname
	 * changes, the selectedIds will be updated to only be the current pathname once
	 * again.
	 *
	 * This means that you can use whatever routing library or history provider that
	 * ensures that your layout re-renders on a path change.
	 *
	 * @see LayoutNavigationTree for description of the navItems
	 * @param navItems All the navigation items within your layout. This is used for
	 * determining which parent tree items should be expanded when the route changes
	 * so the current route won't be hidden from view. This sort of flow happens if
	 * you have a link outside of the navigation tree.
	 * @param pathname The current pathname
	 * @param linkComponent The link component to use within the navigation tree for
	 * any item that has a `to` or `href` attribute. This defaults to the `Link`
	 * from `@react-md/link` but should be changed to whatever link component you
	 * need if using a routing library like `react-router`.
	 * @return the required `Tree` selection and expansion state and handlers that
	 * should be passed to the `Layout` component.
	 */
	function useLayoutNavigation(navItems, pathname, linkComponent) {
	    if (linkComponent === void 0) { linkComponent = Link; }
	    var itemId = pathname.replace(/\?.*$/, "");
	    var _a = useTreeItemExpansion(function () { return getParentIds(itemId, navItems); }), expandedIds = _a.expandedIds, onItemExpansion = _a.onItemExpansion, onMultiItemExpansion = _a.onMultiItemExpansion;
	    var prevItemId = React.useRef(itemId);
	    var prevNavItems = React.useRef(navItems);
	    if (prevItemId.current !== itemId || prevNavItems.current !== navItems) {
	        prevItemId.current = itemId;
	        prevNavItems.current = navItems;
	        onMultiItemExpansion(Array.from(new Set(__spreadArrays$a(expandedIds, getParentIds(itemId, navItems)))));
	    }
	    return {
	        navItems: navItems,
	        multiSelect: false,
	        selectedIds: [itemId],
	        onItemSelect: noop$4,
	        onMultiItemSelect: noop$4,
	        expandedIds: expandedIds,
	        onItemExpansion: onItemExpansion,
	        onMultiItemExpansion: onMultiItemExpansion,
	        linkComponent: linkComponent,
	    };
	}

	var __assign$1R = (undefined && undefined.__assign) || function () {
	    __assign$1R = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1R.apply(this, arguments);
	};
	var Rotation3DFontIcon = React.forwardRef(function Rotation3DFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$1R({}, props, { ref: ref }), "3d_rotation"));
	});

	var __assign$1S = (undefined && undefined.__assign) || function () {
	    __assign$1S = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1S.apply(this, arguments);
	};
	var AcUnitFontIcon = React.forwardRef(function AcUnitFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$1S({}, props, { ref: ref }), "ac_unit"));
	});

	var __assign$1T = (undefined && undefined.__assign) || function () {
	    __assign$1T = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1T.apply(this, arguments);
	};
	var AccessAlarmFontIcon = React.forwardRef(function AccessAlarmFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$1T({}, props, { ref: ref }), "access_alarm"));
	});

	var __assign$1U = (undefined && undefined.__assign) || function () {
	    __assign$1U = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1U.apply(this, arguments);
	};
	var AccessAlarmsFontIcon = React.forwardRef(function AccessAlarmsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$1U({}, props, { ref: ref }), "access_alarms"));
	});

	var __assign$1V = (undefined && undefined.__assign) || function () {
	    __assign$1V = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1V.apply(this, arguments);
	};
	var AccessTimeFontIcon = React.forwardRef(function AccessTimeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$1V({}, props, { ref: ref }), "access_time"));
	});

	var __assign$1W = (undefined && undefined.__assign) || function () {
	    __assign$1W = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1W.apply(this, arguments);
	};
	var AccessibilityFontIcon = React.forwardRef(function AccessibilityFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$1W({}, props, { ref: ref }), "accessibility"));
	});

	var __assign$1X = (undefined && undefined.__assign) || function () {
	    __assign$1X = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1X.apply(this, arguments);
	};
	var AccessibleFontIcon = React.forwardRef(function AccessibleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$1X({}, props, { ref: ref }), "accessible"));
	});

	var __assign$1Y = (undefined && undefined.__assign) || function () {
	    __assign$1Y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1Y.apply(this, arguments);
	};
	var AccountBalanceWalletFontIcon = React.forwardRef(function AccountBalanceWalletFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$1Y({}, props, { ref: ref }), "account_balance_wallet"));
	});

	var __assign$1Z = (undefined && undefined.__assign) || function () {
	    __assign$1Z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1Z.apply(this, arguments);
	};
	var AccountBalanceFontIcon = React.forwardRef(function AccountBalanceFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$1Z({}, props, { ref: ref }), "account_balance"));
	});

	var __assign$1_ = (undefined && undefined.__assign) || function () {
	    __assign$1_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1_.apply(this, arguments);
	};
	var AccountBoxFontIcon = React.forwardRef(function AccountBoxFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$1_({}, props, { ref: ref }), "account_box"));
	});

	var __assign$1$ = (undefined && undefined.__assign) || function () {
	    __assign$1$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1$.apply(this, arguments);
	};
	var AccountCircleFontIcon = React.forwardRef(function AccountCircleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$1$({}, props, { ref: ref }), "account_circle"));
	});

	var __assign$20 = (undefined && undefined.__assign) || function () {
	    __assign$20 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$20.apply(this, arguments);
	};
	var AdbFontIcon = React.forwardRef(function AdbFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$20({}, props, { ref: ref }), "adb"));
	});

	var __assign$21 = (undefined && undefined.__assign) || function () {
	    __assign$21 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$21.apply(this, arguments);
	};
	var AddAPhotoFontIcon = React.forwardRef(function AddAPhotoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$21({}, props, { ref: ref }), "add_a_photo"));
	});

	var __assign$22 = (undefined && undefined.__assign) || function () {
	    __assign$22 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$22.apply(this, arguments);
	};
	var AddAlarmFontIcon = React.forwardRef(function AddAlarmFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$22({}, props, { ref: ref }), "add_alarm"));
	});

	var __assign$23 = (undefined && undefined.__assign) || function () {
	    __assign$23 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$23.apply(this, arguments);
	};
	var AddAlertFontIcon = React.forwardRef(function AddAlertFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$23({}, props, { ref: ref }), "add_alert"));
	});

	var __assign$24 = (undefined && undefined.__assign) || function () {
	    __assign$24 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$24.apply(this, arguments);
	};
	var AddBoxFontIcon = React.forwardRef(function AddBoxFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$24({}, props, { ref: ref }), "add_box"));
	});

	var __assign$25 = (undefined && undefined.__assign) || function () {
	    __assign$25 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$25.apply(this, arguments);
	};
	var AddCircleOutlineFontIcon = React.forwardRef(function AddCircleOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$25({}, props, { ref: ref }), "add_circle_outline"));
	});

	var __assign$26 = (undefined && undefined.__assign) || function () {
	    __assign$26 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$26.apply(this, arguments);
	};
	var AddCircleFontIcon = React.forwardRef(function AddCircleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$26({}, props, { ref: ref }), "add_circle"));
	});

	var __assign$27 = (undefined && undefined.__assign) || function () {
	    __assign$27 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$27.apply(this, arguments);
	};
	var AddLocationFontIcon = React.forwardRef(function AddLocationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$27({}, props, { ref: ref }), "add_location"));
	});

	var __assign$28 = (undefined && undefined.__assign) || function () {
	    __assign$28 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$28.apply(this, arguments);
	};
	var AddShoppingCartFontIcon = React.forwardRef(function AddShoppingCartFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$28({}, props, { ref: ref }), "add_shopping_cart"));
	});

	var __assign$29 = (undefined && undefined.__assign) || function () {
	    __assign$29 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$29.apply(this, arguments);
	};
	var AddToPhotosFontIcon = React.forwardRef(function AddToPhotosFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$29({}, props, { ref: ref }), "add_to_photos"));
	});

	var __assign$2a = (undefined && undefined.__assign) || function () {
	    __assign$2a = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2a.apply(this, arguments);
	};
	var AddToQueueFontIcon = React.forwardRef(function AddToQueueFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2a({}, props, { ref: ref }), "add_to_queue"));
	});

	var __assign$2b = (undefined && undefined.__assign) || function () {
	    __assign$2b = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2b.apply(this, arguments);
	};
	var AddFontIcon = React.forwardRef(function AddFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2b({}, props, { ref: ref }), "add"));
	});

	var __assign$2c = (undefined && undefined.__assign) || function () {
	    __assign$2c = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2c.apply(this, arguments);
	};
	var AdjustFontIcon = React.forwardRef(function AdjustFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2c({}, props, { ref: ref }), "adjust"));
	});

	var __assign$2d = (undefined && undefined.__assign) || function () {
	    __assign$2d = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2d.apply(this, arguments);
	};
	var AirlineSeatFlatAngledFontIcon = React.forwardRef(function AirlineSeatFlatAngledFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2d({}, props, { ref: ref }), "airline_seat_flat_angled"));
	});

	var __assign$2e = (undefined && undefined.__assign) || function () {
	    __assign$2e = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2e.apply(this, arguments);
	};
	var AirlineSeatFlatFontIcon = React.forwardRef(function AirlineSeatFlatFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2e({}, props, { ref: ref }), "airline_seat_flat"));
	});

	var __assign$2f = (undefined && undefined.__assign) || function () {
	    __assign$2f = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2f.apply(this, arguments);
	};
	var AirlineSeatIndividualSuiteFontIcon = React.forwardRef(function AirlineSeatIndividualSuiteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2f({}, props, { ref: ref }), "airline_seat_individual_suite"));
	});

	var __assign$2g = (undefined && undefined.__assign) || function () {
	    __assign$2g = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2g.apply(this, arguments);
	};
	var AirlineSeatLegroomExtraFontIcon = React.forwardRef(function AirlineSeatLegroomExtraFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2g({}, props, { ref: ref }), "airline_seat_legroom_extra"));
	});

	var __assign$2h = (undefined && undefined.__assign) || function () {
	    __assign$2h = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2h.apply(this, arguments);
	};
	var AirlineSeatLegroomNormalFontIcon = React.forwardRef(function AirlineSeatLegroomNormalFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2h({}, props, { ref: ref }), "airline_seat_legroom_normal"));
	});

	var __assign$2i = (undefined && undefined.__assign) || function () {
	    __assign$2i = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2i.apply(this, arguments);
	};
	var AirlineSeatLegroomReducedFontIcon = React.forwardRef(function AirlineSeatLegroomReducedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2i({}, props, { ref: ref }), "airline_seat_legroom_reduced"));
	});

	var __assign$2j = (undefined && undefined.__assign) || function () {
	    __assign$2j = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2j.apply(this, arguments);
	};
	var AirlineSeatReclineExtraFontIcon = React.forwardRef(function AirlineSeatReclineExtraFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2j({}, props, { ref: ref }), "airline_seat_recline_extra"));
	});

	var __assign$2k = (undefined && undefined.__assign) || function () {
	    __assign$2k = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2k.apply(this, arguments);
	};
	var AirlineSeatReclineNormalFontIcon = React.forwardRef(function AirlineSeatReclineNormalFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2k({}, props, { ref: ref }), "airline_seat_recline_normal"));
	});

	var __assign$2l = (undefined && undefined.__assign) || function () {
	    __assign$2l = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2l.apply(this, arguments);
	};
	var AirplanemodeActiveFontIcon = React.forwardRef(function AirplanemodeActiveFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2l({}, props, { ref: ref }), "airplanemode_active"));
	});

	var __assign$2m = (undefined && undefined.__assign) || function () {
	    __assign$2m = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2m.apply(this, arguments);
	};
	var AirplanemodeInactiveFontIcon = React.forwardRef(function AirplanemodeInactiveFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2m({}, props, { ref: ref }), "airplanemode_inactive"));
	});

	var __assign$2n = (undefined && undefined.__assign) || function () {
	    __assign$2n = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2n.apply(this, arguments);
	};
	var AirplayFontIcon = React.forwardRef(function AirplayFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2n({}, props, { ref: ref }), "airplay"));
	});

	var __assign$2o = (undefined && undefined.__assign) || function () {
	    __assign$2o = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2o.apply(this, arguments);
	};
	var AirportShuttleFontIcon = React.forwardRef(function AirportShuttleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2o({}, props, { ref: ref }), "airport_shuttle"));
	});

	var __assign$2p = (undefined && undefined.__assign) || function () {
	    __assign$2p = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2p.apply(this, arguments);
	};
	var AlarmAddFontIcon = React.forwardRef(function AlarmAddFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2p({}, props, { ref: ref }), "alarm_add"));
	});

	var __assign$2q = (undefined && undefined.__assign) || function () {
	    __assign$2q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2q.apply(this, arguments);
	};
	var AlarmOffFontIcon = React.forwardRef(function AlarmOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2q({}, props, { ref: ref }), "alarm_off"));
	});

	var __assign$2r = (undefined && undefined.__assign) || function () {
	    __assign$2r = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2r.apply(this, arguments);
	};
	var AlarmOnFontIcon = React.forwardRef(function AlarmOnFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2r({}, props, { ref: ref }), "alarm_on"));
	});

	var __assign$2s = (undefined && undefined.__assign) || function () {
	    __assign$2s = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2s.apply(this, arguments);
	};
	var AlarmFontIcon = React.forwardRef(function AlarmFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2s({}, props, { ref: ref }), "alarm"));
	});

	var __assign$2t = (undefined && undefined.__assign) || function () {
	    __assign$2t = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2t.apply(this, arguments);
	};
	var AlbumFontIcon = React.forwardRef(function AlbumFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2t({}, props, { ref: ref }), "album"));
	});

	var __assign$2u = (undefined && undefined.__assign) || function () {
	    __assign$2u = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2u.apply(this, arguments);
	};
	var AllInclusiveFontIcon = React.forwardRef(function AllInclusiveFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2u({}, props, { ref: ref }), "all_inclusive"));
	});

	var __assign$2v = (undefined && undefined.__assign) || function () {
	    __assign$2v = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2v.apply(this, arguments);
	};
	var AllOutFontIcon = React.forwardRef(function AllOutFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2v({}, props, { ref: ref }), "all_out"));
	});

	var __assign$2w = (undefined && undefined.__assign) || function () {
	    __assign$2w = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2w.apply(this, arguments);
	};
	var AndroidFontIcon = React.forwardRef(function AndroidFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2w({}, props, { ref: ref }), "android"));
	});

	var __assign$2x = (undefined && undefined.__assign) || function () {
	    __assign$2x = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2x.apply(this, arguments);
	};
	var AnnouncementFontIcon = React.forwardRef(function AnnouncementFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2x({}, props, { ref: ref }), "announcement"));
	});

	var __assign$2y = (undefined && undefined.__assign) || function () {
	    __assign$2y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2y.apply(this, arguments);
	};
	var AppsFontIcon = React.forwardRef(function AppsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2y({}, props, { ref: ref }), "apps"));
	});

	var __assign$2z = (undefined && undefined.__assign) || function () {
	    __assign$2z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2z.apply(this, arguments);
	};
	var ArchiveFontIcon = React.forwardRef(function ArchiveFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2z({}, props, { ref: ref }), "archive"));
	});

	var __assign$2A = (undefined && undefined.__assign) || function () {
	    __assign$2A = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2A.apply(this, arguments);
	};
	var ArrowBackFontIcon = React.forwardRef(function ArrowBackFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2A({}, props, { ref: ref }), "arrow_back"));
	});

	var __assign$2B = (undefined && undefined.__assign) || function () {
	    __assign$2B = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2B.apply(this, arguments);
	};
	var ArrowDownwardFontIcon = React.forwardRef(function ArrowDownwardFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2B({}, props, { ref: ref }), "arrow_downward"));
	});

	var __assign$2C = (undefined && undefined.__assign) || function () {
	    __assign$2C = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2C.apply(this, arguments);
	};
	var ArrowDropDownCircleFontIcon = React.forwardRef(function ArrowDropDownCircleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2C({}, props, { ref: ref }), "arrow_drop_down_circle"));
	});

	var __assign$2D = (undefined && undefined.__assign) || function () {
	    __assign$2D = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2D.apply(this, arguments);
	};
	var ArrowDropDownFontIcon = React.forwardRef(function ArrowDropDownFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2D({}, props, { ref: ref }), "arrow_drop_down"));
	});

	var __assign$2E = (undefined && undefined.__assign) || function () {
	    __assign$2E = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2E.apply(this, arguments);
	};
	var ArrowDropUpFontIcon = React.forwardRef(function ArrowDropUpFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2E({}, props, { ref: ref }), "arrow_drop_up"));
	});

	var __assign$2F = (undefined && undefined.__assign) || function () {
	    __assign$2F = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2F.apply(this, arguments);
	};
	var ArrowForwardFontIcon = React.forwardRef(function ArrowForwardFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2F({}, props, { ref: ref }), "arrow_forward"));
	});

	var __assign$2G = (undefined && undefined.__assign) || function () {
	    __assign$2G = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2G.apply(this, arguments);
	};
	var ArrowUpwardFontIcon = React.forwardRef(function ArrowUpwardFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2G({}, props, { ref: ref }), "arrow_upward"));
	});

	var __assign$2H = (undefined && undefined.__assign) || function () {
	    __assign$2H = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2H.apply(this, arguments);
	};
	var ArtTrackFontIcon = React.forwardRef(function ArtTrackFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2H({}, props, { ref: ref }), "art_track"));
	});

	var __assign$2I = (undefined && undefined.__assign) || function () {
	    __assign$2I = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2I.apply(this, arguments);
	};
	var AspectRatioFontIcon = React.forwardRef(function AspectRatioFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2I({}, props, { ref: ref }), "aspect_ratio"));
	});

	var __assign$2J = (undefined && undefined.__assign) || function () {
	    __assign$2J = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2J.apply(this, arguments);
	};
	var AssessmentFontIcon = React.forwardRef(function AssessmentFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2J({}, props, { ref: ref }), "assessment"));
	});

	var __assign$2K = (undefined && undefined.__assign) || function () {
	    __assign$2K = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2K.apply(this, arguments);
	};
	var AssignmentIndFontIcon = React.forwardRef(function AssignmentIndFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2K({}, props, { ref: ref }), "assignment_ind"));
	});

	var __assign$2L = (undefined && undefined.__assign) || function () {
	    __assign$2L = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2L.apply(this, arguments);
	};
	var AssignmentLateFontIcon = React.forwardRef(function AssignmentLateFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2L({}, props, { ref: ref }), "assignment_late"));
	});

	var __assign$2M = (undefined && undefined.__assign) || function () {
	    __assign$2M = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2M.apply(this, arguments);
	};
	var AssignmentReturnFontIcon = React.forwardRef(function AssignmentReturnFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2M({}, props, { ref: ref }), "assignment_return"));
	});

	var __assign$2N = (undefined && undefined.__assign) || function () {
	    __assign$2N = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2N.apply(this, arguments);
	};
	var AssignmentReturnedFontIcon = React.forwardRef(function AssignmentReturnedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2N({}, props, { ref: ref }), "assignment_returned"));
	});

	var __assign$2O = (undefined && undefined.__assign) || function () {
	    __assign$2O = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2O.apply(this, arguments);
	};
	var AssignmentTurnedInFontIcon = React.forwardRef(function AssignmentTurnedInFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2O({}, props, { ref: ref }), "assignment_turned_in"));
	});

	var __assign$2P = (undefined && undefined.__assign) || function () {
	    __assign$2P = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2P.apply(this, arguments);
	};
	var AssignmentFontIcon = React.forwardRef(function AssignmentFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2P({}, props, { ref: ref }), "assignment"));
	});

	var __assign$2Q = (undefined && undefined.__assign) || function () {
	    __assign$2Q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2Q.apply(this, arguments);
	};
	var AssistantPhotoFontIcon = React.forwardRef(function AssistantPhotoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2Q({}, props, { ref: ref }), "assistant_photo"));
	});

	var __assign$2R = (undefined && undefined.__assign) || function () {
	    __assign$2R = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2R.apply(this, arguments);
	};
	var AssistantFontIcon = React.forwardRef(function AssistantFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2R({}, props, { ref: ref }), "assistant"));
	});

	var __assign$2S = (undefined && undefined.__assign) || function () {
	    __assign$2S = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2S.apply(this, arguments);
	};
	var AttachFileFontIcon = React.forwardRef(function AttachFileFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2S({}, props, { ref: ref }), "attach_file"));
	});

	var __assign$2T = (undefined && undefined.__assign) || function () {
	    __assign$2T = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2T.apply(this, arguments);
	};
	var AttachMoneyFontIcon = React.forwardRef(function AttachMoneyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2T({}, props, { ref: ref }), "attach_money"));
	});

	var __assign$2U = (undefined && undefined.__assign) || function () {
	    __assign$2U = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2U.apply(this, arguments);
	};
	var AttachmentFontIcon = React.forwardRef(function AttachmentFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2U({}, props, { ref: ref }), "attachment"));
	});

	var __assign$2V = (undefined && undefined.__assign) || function () {
	    __assign$2V = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2V.apply(this, arguments);
	};
	var AudiotrackFontIcon = React.forwardRef(function AudiotrackFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2V({}, props, { ref: ref }), "audiotrack"));
	});

	var __assign$2W = (undefined && undefined.__assign) || function () {
	    __assign$2W = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2W.apply(this, arguments);
	};
	var AutorenewFontIcon = React.forwardRef(function AutorenewFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2W({}, props, { ref: ref }), "autorenew"));
	});

	var __assign$2X = (undefined && undefined.__assign) || function () {
	    __assign$2X = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2X.apply(this, arguments);
	};
	var AvTimerFontIcon = React.forwardRef(function AvTimerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2X({}, props, { ref: ref }), "av_timer"));
	});

	var __assign$2Y = (undefined && undefined.__assign) || function () {
	    __assign$2Y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2Y.apply(this, arguments);
	};
	var BackspaceFontIcon = React.forwardRef(function BackspaceFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2Y({}, props, { ref: ref }), "backspace"));
	});

	var __assign$2Z = (undefined && undefined.__assign) || function () {
	    __assign$2Z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2Z.apply(this, arguments);
	};
	var BackupFontIcon = React.forwardRef(function BackupFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2Z({}, props, { ref: ref }), "backup"));
	});

	var __assign$2_ = (undefined && undefined.__assign) || function () {
	    __assign$2_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2_.apply(this, arguments);
	};
	var BatteryAlertFontIcon = React.forwardRef(function BatteryAlertFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2_({}, props, { ref: ref }), "battery_alert"));
	});

	var __assign$2$ = (undefined && undefined.__assign) || function () {
	    __assign$2$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2$.apply(this, arguments);
	};
	var BatteryChargingFullFontIcon = React.forwardRef(function BatteryChargingFullFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$2$({}, props, { ref: ref }), "battery_charging_full"));
	});

	var __assign$30 = (undefined && undefined.__assign) || function () {
	    __assign$30 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$30.apply(this, arguments);
	};
	var BatteryFullFontIcon = React.forwardRef(function BatteryFullFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$30({}, props, { ref: ref }), "battery_full"));
	});

	var __assign$31 = (undefined && undefined.__assign) || function () {
	    __assign$31 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$31.apply(this, arguments);
	};
	var BatteryStdFontIcon = React.forwardRef(function BatteryStdFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$31({}, props, { ref: ref }), "battery_std"));
	});

	var __assign$32 = (undefined && undefined.__assign) || function () {
	    __assign$32 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$32.apply(this, arguments);
	};
	var BatteryUnknownFontIcon = React.forwardRef(function BatteryUnknownFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$32({}, props, { ref: ref }), "battery_unknown"));
	});

	var __assign$33 = (undefined && undefined.__assign) || function () {
	    __assign$33 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$33.apply(this, arguments);
	};
	var BeachAccessFontIcon = React.forwardRef(function BeachAccessFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$33({}, props, { ref: ref }), "beach_access"));
	});

	var __assign$34 = (undefined && undefined.__assign) || function () {
	    __assign$34 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$34.apply(this, arguments);
	};
	var BeenhereFontIcon = React.forwardRef(function BeenhereFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$34({}, props, { ref: ref }), "beenhere"));
	});

	var __assign$35 = (undefined && undefined.__assign) || function () {
	    __assign$35 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$35.apply(this, arguments);
	};
	var BlockFontIcon = React.forwardRef(function BlockFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$35({}, props, { ref: ref }), "block"));
	});

	var __assign$36 = (undefined && undefined.__assign) || function () {
	    __assign$36 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$36.apply(this, arguments);
	};
	var BluetoothAudioFontIcon = React.forwardRef(function BluetoothAudioFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$36({}, props, { ref: ref }), "bluetooth_audio"));
	});

	var __assign$37 = (undefined && undefined.__assign) || function () {
	    __assign$37 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$37.apply(this, arguments);
	};
	var BluetoothConnectedFontIcon = React.forwardRef(function BluetoothConnectedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$37({}, props, { ref: ref }), "bluetooth_connected"));
	});

	var __assign$38 = (undefined && undefined.__assign) || function () {
	    __assign$38 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$38.apply(this, arguments);
	};
	var BluetoothDisabledFontIcon = React.forwardRef(function BluetoothDisabledFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$38({}, props, { ref: ref }), "bluetooth_disabled"));
	});

	var __assign$39 = (undefined && undefined.__assign) || function () {
	    __assign$39 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$39.apply(this, arguments);
	};
	var BluetoothSearchingFontIcon = React.forwardRef(function BluetoothSearchingFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$39({}, props, { ref: ref }), "bluetooth_searching"));
	});

	var __assign$3a = (undefined && undefined.__assign) || function () {
	    __assign$3a = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3a.apply(this, arguments);
	};
	var BluetoothFontIcon = React.forwardRef(function BluetoothFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3a({}, props, { ref: ref }), "bluetooth"));
	});

	var __assign$3b = (undefined && undefined.__assign) || function () {
	    __assign$3b = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3b.apply(this, arguments);
	};
	var BlurCircularFontIcon = React.forwardRef(function BlurCircularFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3b({}, props, { ref: ref }), "blur_circular"));
	});

	var __assign$3c = (undefined && undefined.__assign) || function () {
	    __assign$3c = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3c.apply(this, arguments);
	};
	var BlurLinearFontIcon = React.forwardRef(function BlurLinearFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3c({}, props, { ref: ref }), "blur_linear"));
	});

	var __assign$3d = (undefined && undefined.__assign) || function () {
	    __assign$3d = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3d.apply(this, arguments);
	};
	var BlurOffFontIcon = React.forwardRef(function BlurOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3d({}, props, { ref: ref }), "blur_off"));
	});

	var __assign$3e = (undefined && undefined.__assign) || function () {
	    __assign$3e = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3e.apply(this, arguments);
	};
	var BlurOnFontIcon = React.forwardRef(function BlurOnFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3e({}, props, { ref: ref }), "blur_on"));
	});

	var __assign$3f = (undefined && undefined.__assign) || function () {
	    __assign$3f = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3f.apply(this, arguments);
	};
	var BookFontIcon = React.forwardRef(function BookFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3f({}, props, { ref: ref }), "book"));
	});

	var __assign$3g = (undefined && undefined.__assign) || function () {
	    __assign$3g = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3g.apply(this, arguments);
	};
	var BookmarkBorderFontIcon = React.forwardRef(function BookmarkBorderFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3g({}, props, { ref: ref }), "bookmark_border"));
	});

	var __assign$3h = (undefined && undefined.__assign) || function () {
	    __assign$3h = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3h.apply(this, arguments);
	};
	var BookmarkFontIcon = React.forwardRef(function BookmarkFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3h({}, props, { ref: ref }), "bookmark"));
	});

	var __assign$3i = (undefined && undefined.__assign) || function () {
	    __assign$3i = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3i.apply(this, arguments);
	};
	var BorderAllFontIcon = React.forwardRef(function BorderAllFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3i({}, props, { ref: ref }), "border_all"));
	});

	var __assign$3j = (undefined && undefined.__assign) || function () {
	    __assign$3j = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3j.apply(this, arguments);
	};
	var BorderBottomFontIcon = React.forwardRef(function BorderBottomFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3j({}, props, { ref: ref }), "border_bottom"));
	});

	var __assign$3k = (undefined && undefined.__assign) || function () {
	    __assign$3k = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3k.apply(this, arguments);
	};
	var BorderClearFontIcon = React.forwardRef(function BorderClearFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3k({}, props, { ref: ref }), "border_clear"));
	});

	var __assign$3l = (undefined && undefined.__assign) || function () {
	    __assign$3l = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3l.apply(this, arguments);
	};
	var BorderColorFontIcon = React.forwardRef(function BorderColorFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3l({}, props, { ref: ref }), "border_color"));
	});

	var __assign$3m = (undefined && undefined.__assign) || function () {
	    __assign$3m = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3m.apply(this, arguments);
	};
	var BorderHorizontalFontIcon = React.forwardRef(function BorderHorizontalFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3m({}, props, { ref: ref }), "border_horizontal"));
	});

	var __assign$3n = (undefined && undefined.__assign) || function () {
	    __assign$3n = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3n.apply(this, arguments);
	};
	var BorderInnerFontIcon = React.forwardRef(function BorderInnerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3n({}, props, { ref: ref }), "border_inner"));
	});

	var __assign$3o = (undefined && undefined.__assign) || function () {
	    __assign$3o = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3o.apply(this, arguments);
	};
	var BorderLeftFontIcon = React.forwardRef(function BorderLeftFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3o({}, props, { ref: ref }), "border_left"));
	});

	var __assign$3p = (undefined && undefined.__assign) || function () {
	    __assign$3p = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3p.apply(this, arguments);
	};
	var BorderOuterFontIcon = React.forwardRef(function BorderOuterFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3p({}, props, { ref: ref }), "border_outer"));
	});

	var __assign$3q = (undefined && undefined.__assign) || function () {
	    __assign$3q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3q.apply(this, arguments);
	};
	var BorderRightFontIcon = React.forwardRef(function BorderRightFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3q({}, props, { ref: ref }), "border_right"));
	});

	var __assign$3r = (undefined && undefined.__assign) || function () {
	    __assign$3r = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3r.apply(this, arguments);
	};
	var BorderStyleFontIcon = React.forwardRef(function BorderStyleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3r({}, props, { ref: ref }), "border_style"));
	});

	var __assign$3s = (undefined && undefined.__assign) || function () {
	    __assign$3s = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3s.apply(this, arguments);
	};
	var BorderTopFontIcon = React.forwardRef(function BorderTopFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3s({}, props, { ref: ref }), "border_top"));
	});

	var __assign$3t = (undefined && undefined.__assign) || function () {
	    __assign$3t = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3t.apply(this, arguments);
	};
	var BorderVerticalFontIcon = React.forwardRef(function BorderVerticalFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3t({}, props, { ref: ref }), "border_vertical"));
	});

	var __assign$3u = (undefined && undefined.__assign) || function () {
	    __assign$3u = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3u.apply(this, arguments);
	};
	var BrandingWatermarkFontIcon = React.forwardRef(function BrandingWatermarkFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3u({}, props, { ref: ref }), "branding_watermark"));
	});

	var __assign$3v = (undefined && undefined.__assign) || function () {
	    __assign$3v = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3v.apply(this, arguments);
	};
	var Brightness1FontIcon = React.forwardRef(function Brightness1FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3v({}, props, { ref: ref }), "brightness_1"));
	});

	var __assign$3w = (undefined && undefined.__assign) || function () {
	    __assign$3w = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3w.apply(this, arguments);
	};
	var Brightness2FontIcon = React.forwardRef(function Brightness2FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3w({}, props, { ref: ref }), "brightness_2"));
	});

	var __assign$3x = (undefined && undefined.__assign) || function () {
	    __assign$3x = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3x.apply(this, arguments);
	};
	var Brightness3FontIcon = React.forwardRef(function Brightness3FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3x({}, props, { ref: ref }), "brightness_3"));
	});

	var __assign$3y = (undefined && undefined.__assign) || function () {
	    __assign$3y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3y.apply(this, arguments);
	};
	var Brightness4FontIcon = React.forwardRef(function Brightness4FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3y({}, props, { ref: ref }), "brightness_4"));
	});

	var __assign$3z = (undefined && undefined.__assign) || function () {
	    __assign$3z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3z.apply(this, arguments);
	};
	var Brightness5FontIcon = React.forwardRef(function Brightness5FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3z({}, props, { ref: ref }), "brightness_5"));
	});

	var __assign$3A = (undefined && undefined.__assign) || function () {
	    __assign$3A = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3A.apply(this, arguments);
	};
	var Brightness6FontIcon = React.forwardRef(function Brightness6FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3A({}, props, { ref: ref }), "brightness_6"));
	});

	var __assign$3B = (undefined && undefined.__assign) || function () {
	    __assign$3B = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3B.apply(this, arguments);
	};
	var Brightness7FontIcon = React.forwardRef(function Brightness7FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3B({}, props, { ref: ref }), "brightness_7"));
	});

	var __assign$3C = (undefined && undefined.__assign) || function () {
	    __assign$3C = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3C.apply(this, arguments);
	};
	var BrightnessAutoFontIcon = React.forwardRef(function BrightnessAutoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3C({}, props, { ref: ref }), "brightness_auto"));
	});

	var __assign$3D = (undefined && undefined.__assign) || function () {
	    __assign$3D = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3D.apply(this, arguments);
	};
	var BrightnessHighFontIcon = React.forwardRef(function BrightnessHighFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3D({}, props, { ref: ref }), "brightness_high"));
	});

	var __assign$3E = (undefined && undefined.__assign) || function () {
	    __assign$3E = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3E.apply(this, arguments);
	};
	var BrightnessLowFontIcon = React.forwardRef(function BrightnessLowFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3E({}, props, { ref: ref }), "brightness_low"));
	});

	var __assign$3F = (undefined && undefined.__assign) || function () {
	    __assign$3F = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3F.apply(this, arguments);
	};
	var BrightnessMediumFontIcon = React.forwardRef(function BrightnessMediumFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3F({}, props, { ref: ref }), "brightness_medium"));
	});

	var __assign$3G = (undefined && undefined.__assign) || function () {
	    __assign$3G = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3G.apply(this, arguments);
	};
	var BrokenImageFontIcon = React.forwardRef(function BrokenImageFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3G({}, props, { ref: ref }), "broken_image"));
	});

	var __assign$3H = (undefined && undefined.__assign) || function () {
	    __assign$3H = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3H.apply(this, arguments);
	};
	var BrushFontIcon = React.forwardRef(function BrushFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3H({}, props, { ref: ref }), "brush"));
	});

	var __assign$3I = (undefined && undefined.__assign) || function () {
	    __assign$3I = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3I.apply(this, arguments);
	};
	var BubbleChartFontIcon = React.forwardRef(function BubbleChartFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3I({}, props, { ref: ref }), "bubble_chart"));
	});

	var __assign$3J = (undefined && undefined.__assign) || function () {
	    __assign$3J = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3J.apply(this, arguments);
	};
	var BugReportFontIcon = React.forwardRef(function BugReportFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3J({}, props, { ref: ref }), "bug_report"));
	});

	var __assign$3K = (undefined && undefined.__assign) || function () {
	    __assign$3K = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3K.apply(this, arguments);
	};
	var BuildFontIcon = React.forwardRef(function BuildFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3K({}, props, { ref: ref }), "build"));
	});

	var __assign$3L = (undefined && undefined.__assign) || function () {
	    __assign$3L = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3L.apply(this, arguments);
	};
	var BurstModeFontIcon = React.forwardRef(function BurstModeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3L({}, props, { ref: ref }), "burst_mode"));
	});

	var __assign$3M = (undefined && undefined.__assign) || function () {
	    __assign$3M = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3M.apply(this, arguments);
	};
	var BusinessCenterFontIcon = React.forwardRef(function BusinessCenterFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3M({}, props, { ref: ref }), "business_center"));
	});

	var __assign$3N = (undefined && undefined.__assign) || function () {
	    __assign$3N = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3N.apply(this, arguments);
	};
	var BusinessFontIcon = React.forwardRef(function BusinessFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3N({}, props, { ref: ref }), "business"));
	});

	var __assign$3O = (undefined && undefined.__assign) || function () {
	    __assign$3O = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3O.apply(this, arguments);
	};
	var CachedFontIcon = React.forwardRef(function CachedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3O({}, props, { ref: ref }), "cached"));
	});

	var __assign$3P = (undefined && undefined.__assign) || function () {
	    __assign$3P = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3P.apply(this, arguments);
	};
	var CakeFontIcon = React.forwardRef(function CakeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3P({}, props, { ref: ref }), "cake"));
	});

	var __assign$3Q = (undefined && undefined.__assign) || function () {
	    __assign$3Q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3Q.apply(this, arguments);
	};
	var CallEndFontIcon = React.forwardRef(function CallEndFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3Q({}, props, { ref: ref }), "call_end"));
	});

	var __assign$3R = (undefined && undefined.__assign) || function () {
	    __assign$3R = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3R.apply(this, arguments);
	};
	var CallMadeFontIcon = React.forwardRef(function CallMadeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3R({}, props, { ref: ref }), "call_made"));
	});

	var __assign$3S = (undefined && undefined.__assign) || function () {
	    __assign$3S = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3S.apply(this, arguments);
	};
	var CallMergeFontIcon = React.forwardRef(function CallMergeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3S({}, props, { ref: ref }), "call_merge"));
	});

	var __assign$3T = (undefined && undefined.__assign) || function () {
	    __assign$3T = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3T.apply(this, arguments);
	};
	var CallMissedOutgoingFontIcon = React.forwardRef(function CallMissedOutgoingFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3T({}, props, { ref: ref }), "call_missed_outgoing"));
	});

	var __assign$3U = (undefined && undefined.__assign) || function () {
	    __assign$3U = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3U.apply(this, arguments);
	};
	var CallMissedFontIcon = React.forwardRef(function CallMissedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3U({}, props, { ref: ref }), "call_missed"));
	});

	var __assign$3V = (undefined && undefined.__assign) || function () {
	    __assign$3V = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3V.apply(this, arguments);
	};
	var CallReceivedFontIcon = React.forwardRef(function CallReceivedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3V({}, props, { ref: ref }), "call_received"));
	});

	var __assign$3W = (undefined && undefined.__assign) || function () {
	    __assign$3W = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3W.apply(this, arguments);
	};
	var CallSplitFontIcon = React.forwardRef(function CallSplitFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3W({}, props, { ref: ref }), "call_split"));
	});

	var __assign$3X = (undefined && undefined.__assign) || function () {
	    __assign$3X = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3X.apply(this, arguments);
	};
	var CallToActionFontIcon = React.forwardRef(function CallToActionFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3X({}, props, { ref: ref }), "call_to_action"));
	});

	var __assign$3Y = (undefined && undefined.__assign) || function () {
	    __assign$3Y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3Y.apply(this, arguments);
	};
	var CallFontIcon = React.forwardRef(function CallFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3Y({}, props, { ref: ref }), "call"));
	});

	var __assign$3Z = (undefined && undefined.__assign) || function () {
	    __assign$3Z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3Z.apply(this, arguments);
	};
	var CameraAltFontIcon = React.forwardRef(function CameraAltFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3Z({}, props, { ref: ref }), "camera_alt"));
	});

	var __assign$3_ = (undefined && undefined.__assign) || function () {
	    __assign$3_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3_.apply(this, arguments);
	};
	var CameraEnhanceFontIcon = React.forwardRef(function CameraEnhanceFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3_({}, props, { ref: ref }), "camera_enhance"));
	});

	var __assign$3$ = (undefined && undefined.__assign) || function () {
	    __assign$3$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3$.apply(this, arguments);
	};
	var CameraFrontFontIcon = React.forwardRef(function CameraFrontFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$3$({}, props, { ref: ref }), "camera_front"));
	});

	var __assign$40 = (undefined && undefined.__assign) || function () {
	    __assign$40 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$40.apply(this, arguments);
	};
	var CameraRearFontIcon = React.forwardRef(function CameraRearFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$40({}, props, { ref: ref }), "camera_rear"));
	});

	var __assign$41 = (undefined && undefined.__assign) || function () {
	    __assign$41 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$41.apply(this, arguments);
	};
	var CameraRollFontIcon = React.forwardRef(function CameraRollFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$41({}, props, { ref: ref }), "camera_roll"));
	});

	var __assign$42 = (undefined && undefined.__assign) || function () {
	    __assign$42 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$42.apply(this, arguments);
	};
	var CameraFontIcon = React.forwardRef(function CameraFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$42({}, props, { ref: ref }), "camera"));
	});

	var __assign$43 = (undefined && undefined.__assign) || function () {
	    __assign$43 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$43.apply(this, arguments);
	};
	var CancelFontIcon = React.forwardRef(function CancelFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$43({}, props, { ref: ref }), "cancel"));
	});

	var __assign$44 = (undefined && undefined.__assign) || function () {
	    __assign$44 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$44.apply(this, arguments);
	};
	var CardGiftcardFontIcon = React.forwardRef(function CardGiftcardFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$44({}, props, { ref: ref }), "card_giftcard"));
	});

	var __assign$45 = (undefined && undefined.__assign) || function () {
	    __assign$45 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$45.apply(this, arguments);
	};
	var CardMembershipFontIcon = React.forwardRef(function CardMembershipFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$45({}, props, { ref: ref }), "card_membership"));
	});

	var __assign$46 = (undefined && undefined.__assign) || function () {
	    __assign$46 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$46.apply(this, arguments);
	};
	var CardTravelFontIcon = React.forwardRef(function CardTravelFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$46({}, props, { ref: ref }), "card_travel"));
	});

	var __assign$47 = (undefined && undefined.__assign) || function () {
	    __assign$47 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$47.apply(this, arguments);
	};
	var CasinoFontIcon = React.forwardRef(function CasinoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$47({}, props, { ref: ref }), "casino"));
	});

	var __assign$48 = (undefined && undefined.__assign) || function () {
	    __assign$48 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$48.apply(this, arguments);
	};
	var CastConnectedFontIcon = React.forwardRef(function CastConnectedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$48({}, props, { ref: ref }), "cast_connected"));
	});

	var __assign$49 = (undefined && undefined.__assign) || function () {
	    __assign$49 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$49.apply(this, arguments);
	};
	var CastFontIcon = React.forwardRef(function CastFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$49({}, props, { ref: ref }), "cast"));
	});

	var __assign$4a = (undefined && undefined.__assign) || function () {
	    __assign$4a = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4a.apply(this, arguments);
	};
	var CenterFocusStrongFontIcon = React.forwardRef(function CenterFocusStrongFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4a({}, props, { ref: ref }), "center_focus_strong"));
	});

	var __assign$4b = (undefined && undefined.__assign) || function () {
	    __assign$4b = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4b.apply(this, arguments);
	};
	var CenterFocusWeakFontIcon = React.forwardRef(function CenterFocusWeakFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4b({}, props, { ref: ref }), "center_focus_weak"));
	});

	var __assign$4c = (undefined && undefined.__assign) || function () {
	    __assign$4c = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4c.apply(this, arguments);
	};
	var ChangeHistoryFontIcon = React.forwardRef(function ChangeHistoryFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4c({}, props, { ref: ref }), "change_history"));
	});

	var __assign$4d = (undefined && undefined.__assign) || function () {
	    __assign$4d = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4d.apply(this, arguments);
	};
	var ChatBubbleOutlineFontIcon = React.forwardRef(function ChatBubbleOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4d({}, props, { ref: ref }), "chat_bubble_outline"));
	});

	var __assign$4e = (undefined && undefined.__assign) || function () {
	    __assign$4e = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4e.apply(this, arguments);
	};
	var ChatBubbleFontIcon = React.forwardRef(function ChatBubbleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4e({}, props, { ref: ref }), "chat_bubble"));
	});

	var __assign$4f = (undefined && undefined.__assign) || function () {
	    __assign$4f = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4f.apply(this, arguments);
	};
	var ChatFontIcon = React.forwardRef(function ChatFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4f({}, props, { ref: ref }), "chat"));
	});

	var __assign$4g = (undefined && undefined.__assign) || function () {
	    __assign$4g = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4g.apply(this, arguments);
	};
	var CheckBoxOutlineBlankFontIcon = React.forwardRef(function CheckBoxOutlineBlankFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4g({}, props, { ref: ref }), "check_box_outline_blank"));
	});

	var __assign$4h = (undefined && undefined.__assign) || function () {
	    __assign$4h = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4h.apply(this, arguments);
	};
	var CheckBoxFontIcon = React.forwardRef(function CheckBoxFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4h({}, props, { ref: ref }), "check_box"));
	});

	var __assign$4i = (undefined && undefined.__assign) || function () {
	    __assign$4i = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4i.apply(this, arguments);
	};
	var CheckCircleFontIcon = React.forwardRef(function CheckCircleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4i({}, props, { ref: ref }), "check_circle"));
	});

	var __assign$4j = (undefined && undefined.__assign) || function () {
	    __assign$4j = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4j.apply(this, arguments);
	};
	var CheckFontIcon = React.forwardRef(function CheckFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4j({}, props, { ref: ref }), "check"));
	});

	var __assign$4k = (undefined && undefined.__assign) || function () {
	    __assign$4k = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4k.apply(this, arguments);
	};
	var ChevronLeftFontIcon = React.forwardRef(function ChevronLeftFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4k({}, props, { ref: ref }), "chevron_left"));
	});

	var __assign$4l = (undefined && undefined.__assign) || function () {
	    __assign$4l = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4l.apply(this, arguments);
	};
	var ChevronRightFontIcon = React.forwardRef(function ChevronRightFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4l({}, props, { ref: ref }), "chevron_right"));
	});

	var __assign$4m = (undefined && undefined.__assign) || function () {
	    __assign$4m = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4m.apply(this, arguments);
	};
	var ChildCareFontIcon = React.forwardRef(function ChildCareFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4m({}, props, { ref: ref }), "child_care"));
	});

	var __assign$4n = (undefined && undefined.__assign) || function () {
	    __assign$4n = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4n.apply(this, arguments);
	};
	var ChildFriendlyFontIcon = React.forwardRef(function ChildFriendlyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4n({}, props, { ref: ref }), "child_friendly"));
	});

	var __assign$4o = (undefined && undefined.__assign) || function () {
	    __assign$4o = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4o.apply(this, arguments);
	};
	var ChromeReaderModeFontIcon = React.forwardRef(function ChromeReaderModeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4o({}, props, { ref: ref }), "chrome_reader_mode"));
	});

	var __assign$4p = (undefined && undefined.__assign) || function () {
	    __assign$4p = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4p.apply(this, arguments);
	};
	var ClassFontIcon = React.forwardRef(function ClassFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4p({}, props, { ref: ref }), "class"));
	});

	var __assign$4q = (undefined && undefined.__assign) || function () {
	    __assign$4q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4q.apply(this, arguments);
	};
	var ClearAllFontIcon = React.forwardRef(function ClearAllFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4q({}, props, { ref: ref }), "clear_all"));
	});

	var __assign$4r = (undefined && undefined.__assign) || function () {
	    __assign$4r = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4r.apply(this, arguments);
	};
	var ClearFontIcon = React.forwardRef(function ClearFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4r({}, props, { ref: ref }), "clear"));
	});

	var __assign$4s = (undefined && undefined.__assign) || function () {
	    __assign$4s = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4s.apply(this, arguments);
	};
	var CloseFontIcon = React.forwardRef(function CloseFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4s({}, props, { ref: ref }), "close"));
	});

	var __assign$4t = (undefined && undefined.__assign) || function () {
	    __assign$4t = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4t.apply(this, arguments);
	};
	var ClosedCaptionFontIcon = React.forwardRef(function ClosedCaptionFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4t({}, props, { ref: ref }), "closed_caption"));
	});

	var __assign$4u = (undefined && undefined.__assign) || function () {
	    __assign$4u = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4u.apply(this, arguments);
	};
	var CloudCircleFontIcon = React.forwardRef(function CloudCircleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4u({}, props, { ref: ref }), "cloud_circle"));
	});

	var __assign$4v = (undefined && undefined.__assign) || function () {
	    __assign$4v = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4v.apply(this, arguments);
	};
	var CloudDoneFontIcon = React.forwardRef(function CloudDoneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4v({}, props, { ref: ref }), "cloud_done"));
	});

	var __assign$4w = (undefined && undefined.__assign) || function () {
	    __assign$4w = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4w.apply(this, arguments);
	};
	var CloudDownloadFontIcon = React.forwardRef(function CloudDownloadFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4w({}, props, { ref: ref }), "cloud_download"));
	});

	var __assign$4x = (undefined && undefined.__assign) || function () {
	    __assign$4x = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4x.apply(this, arguments);
	};
	var CloudOffFontIcon = React.forwardRef(function CloudOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4x({}, props, { ref: ref }), "cloud_off"));
	});

	var __assign$4y = (undefined && undefined.__assign) || function () {
	    __assign$4y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4y.apply(this, arguments);
	};
	var CloudQueueFontIcon = React.forwardRef(function CloudQueueFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4y({}, props, { ref: ref }), "cloud_queue"));
	});

	var __assign$4z = (undefined && undefined.__assign) || function () {
	    __assign$4z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4z.apply(this, arguments);
	};
	var CloudUploadFontIcon = React.forwardRef(function CloudUploadFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4z({}, props, { ref: ref }), "cloud_upload"));
	});

	var __assign$4A = (undefined && undefined.__assign) || function () {
	    __assign$4A = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4A.apply(this, arguments);
	};
	var CloudFontIcon = React.forwardRef(function CloudFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4A({}, props, { ref: ref }), "cloud"));
	});

	var __assign$4B = (undefined && undefined.__assign) || function () {
	    __assign$4B = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4B.apply(this, arguments);
	};
	var CodeFontIcon = React.forwardRef(function CodeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4B({}, props, { ref: ref }), "code"));
	});

	var __assign$4C = (undefined && undefined.__assign) || function () {
	    __assign$4C = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4C.apply(this, arguments);
	};
	var CollectionsBookmarkFontIcon = React.forwardRef(function CollectionsBookmarkFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4C({}, props, { ref: ref }), "collections_bookmark"));
	});

	var __assign$4D = (undefined && undefined.__assign) || function () {
	    __assign$4D = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4D.apply(this, arguments);
	};
	var CollectionsFontIcon = React.forwardRef(function CollectionsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4D({}, props, { ref: ref }), "collections"));
	});

	var __assign$4E = (undefined && undefined.__assign) || function () {
	    __assign$4E = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4E.apply(this, arguments);
	};
	var ColorLensFontIcon = React.forwardRef(function ColorLensFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4E({}, props, { ref: ref }), "color_lens"));
	});

	var __assign$4F = (undefined && undefined.__assign) || function () {
	    __assign$4F = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4F.apply(this, arguments);
	};
	var ColorizeFontIcon = React.forwardRef(function ColorizeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4F({}, props, { ref: ref }), "colorize"));
	});

	var __assign$4G = (undefined && undefined.__assign) || function () {
	    __assign$4G = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4G.apply(this, arguments);
	};
	var CommentFontIcon = React.forwardRef(function CommentFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4G({}, props, { ref: ref }), "comment"));
	});

	var __assign$4H = (undefined && undefined.__assign) || function () {
	    __assign$4H = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4H.apply(this, arguments);
	};
	var CompareArrowsFontIcon = React.forwardRef(function CompareArrowsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4H({}, props, { ref: ref }), "compare_arrows"));
	});

	var __assign$4I = (undefined && undefined.__assign) || function () {
	    __assign$4I = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4I.apply(this, arguments);
	};
	var CompareFontIcon = React.forwardRef(function CompareFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4I({}, props, { ref: ref }), "compare"));
	});

	var __assign$4J = (undefined && undefined.__assign) || function () {
	    __assign$4J = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4J.apply(this, arguments);
	};
	var ComputerFontIcon = React.forwardRef(function ComputerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4J({}, props, { ref: ref }), "computer"));
	});

	var __assign$4K = (undefined && undefined.__assign) || function () {
	    __assign$4K = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4K.apply(this, arguments);
	};
	var ConfirmationNumberFontIcon = React.forwardRef(function ConfirmationNumberFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4K({}, props, { ref: ref }), "confirmation_number"));
	});

	var __assign$4L = (undefined && undefined.__assign) || function () {
	    __assign$4L = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4L.apply(this, arguments);
	};
	var ContactMailFontIcon = React.forwardRef(function ContactMailFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4L({}, props, { ref: ref }), "contact_mail"));
	});

	var __assign$4M = (undefined && undefined.__assign) || function () {
	    __assign$4M = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4M.apply(this, arguments);
	};
	var ContactPhoneFontIcon = React.forwardRef(function ContactPhoneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4M({}, props, { ref: ref }), "contact_phone"));
	});

	var __assign$4N = (undefined && undefined.__assign) || function () {
	    __assign$4N = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4N.apply(this, arguments);
	};
	var ContactsFontIcon = React.forwardRef(function ContactsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4N({}, props, { ref: ref }), "contacts"));
	});

	var __assign$4O = (undefined && undefined.__assign) || function () {
	    __assign$4O = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4O.apply(this, arguments);
	};
	var ContentCopyFontIcon = React.forwardRef(function ContentCopyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4O({}, props, { ref: ref }), "content_copy"));
	});

	var __assign$4P = (undefined && undefined.__assign) || function () {
	    __assign$4P = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4P.apply(this, arguments);
	};
	var ContentCutFontIcon = React.forwardRef(function ContentCutFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4P({}, props, { ref: ref }), "content_cut"));
	});

	var __assign$4Q = (undefined && undefined.__assign) || function () {
	    __assign$4Q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4Q.apply(this, arguments);
	};
	var ContentPasteFontIcon = React.forwardRef(function ContentPasteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4Q({}, props, { ref: ref }), "content_paste"));
	});

	var __assign$4R = (undefined && undefined.__assign) || function () {
	    __assign$4R = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4R.apply(this, arguments);
	};
	var ControlPointDuplicateFontIcon = React.forwardRef(function ControlPointDuplicateFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4R({}, props, { ref: ref }), "control_point_duplicate"));
	});

	var __assign$4S = (undefined && undefined.__assign) || function () {
	    __assign$4S = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4S.apply(this, arguments);
	};
	var ControlPointFontIcon = React.forwardRef(function ControlPointFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4S({}, props, { ref: ref }), "control_point"));
	});

	var __assign$4T = (undefined && undefined.__assign) || function () {
	    __assign$4T = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4T.apply(this, arguments);
	};
	var CopyrightFontIcon = React.forwardRef(function CopyrightFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4T({}, props, { ref: ref }), "copyright"));
	});

	var __assign$4U = (undefined && undefined.__assign) || function () {
	    __assign$4U = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4U.apply(this, arguments);
	};
	var CreateNewFolderFontIcon = React.forwardRef(function CreateNewFolderFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4U({}, props, { ref: ref }), "create_new_folder"));
	});

	var __assign$4V = (undefined && undefined.__assign) || function () {
	    __assign$4V = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4V.apply(this, arguments);
	};
	var CreateFontIcon = React.forwardRef(function CreateFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4V({}, props, { ref: ref }), "create"));
	});

	var __assign$4W = (undefined && undefined.__assign) || function () {
	    __assign$4W = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4W.apply(this, arguments);
	};
	var CreditCardFontIcon = React.forwardRef(function CreditCardFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4W({}, props, { ref: ref }), "credit_card"));
	});

	var __assign$4X = (undefined && undefined.__assign) || function () {
	    __assign$4X = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4X.apply(this, arguments);
	};
	var Crop169FontIcon = React.forwardRef(function Crop169FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4X({}, props, { ref: ref }), "crop_16_9"));
	});

	var __assign$4Y = (undefined && undefined.__assign) || function () {
	    __assign$4Y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4Y.apply(this, arguments);
	};
	var Crop32FontIcon = React.forwardRef(function Crop32FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4Y({}, props, { ref: ref }), "crop_3_2"));
	});

	var __assign$4Z = (undefined && undefined.__assign) || function () {
	    __assign$4Z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4Z.apply(this, arguments);
	};
	var Crop54FontIcon = React.forwardRef(function Crop54FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4Z({}, props, { ref: ref }), "crop_5_4"));
	});

	var __assign$4_ = (undefined && undefined.__assign) || function () {
	    __assign$4_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4_.apply(this, arguments);
	};
	var Crop75FontIcon = React.forwardRef(function Crop75FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4_({}, props, { ref: ref }), "crop_7_5"));
	});

	var __assign$4$ = (undefined && undefined.__assign) || function () {
	    __assign$4$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4$.apply(this, arguments);
	};
	var CropDinFontIcon = React.forwardRef(function CropDinFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$4$({}, props, { ref: ref }), "crop_din"));
	});

	var __assign$50 = (undefined && undefined.__assign) || function () {
	    __assign$50 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$50.apply(this, arguments);
	};
	var CropFreeFontIcon = React.forwardRef(function CropFreeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$50({}, props, { ref: ref }), "crop_free"));
	});

	var __assign$51 = (undefined && undefined.__assign) || function () {
	    __assign$51 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$51.apply(this, arguments);
	};
	var CropLandscapeFontIcon = React.forwardRef(function CropLandscapeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$51({}, props, { ref: ref }), "crop_landscape"));
	});

	var __assign$52 = (undefined && undefined.__assign) || function () {
	    __assign$52 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$52.apply(this, arguments);
	};
	var CropOriginalFontIcon = React.forwardRef(function CropOriginalFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$52({}, props, { ref: ref }), "crop_original"));
	});

	var __assign$53 = (undefined && undefined.__assign) || function () {
	    __assign$53 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$53.apply(this, arguments);
	};
	var CropPortraitFontIcon = React.forwardRef(function CropPortraitFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$53({}, props, { ref: ref }), "crop_portrait"));
	});

	var __assign$54 = (undefined && undefined.__assign) || function () {
	    __assign$54 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$54.apply(this, arguments);
	};
	var CropRotateFontIcon = React.forwardRef(function CropRotateFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$54({}, props, { ref: ref }), "crop_rotate"));
	});

	var __assign$55 = (undefined && undefined.__assign) || function () {
	    __assign$55 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$55.apply(this, arguments);
	};
	var CropSquareFontIcon = React.forwardRef(function CropSquareFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$55({}, props, { ref: ref }), "crop_square"));
	});

	var __assign$56 = (undefined && undefined.__assign) || function () {
	    __assign$56 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$56.apply(this, arguments);
	};
	var CropFontIcon = React.forwardRef(function CropFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$56({}, props, { ref: ref }), "crop"));
	});

	var __assign$57 = (undefined && undefined.__assign) || function () {
	    __assign$57 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$57.apply(this, arguments);
	};
	var DashboardFontIcon = React.forwardRef(function DashboardFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$57({}, props, { ref: ref }), "dashboard"));
	});

	var __assign$58 = (undefined && undefined.__assign) || function () {
	    __assign$58 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$58.apply(this, arguments);
	};
	var DataUsageFontIcon = React.forwardRef(function DataUsageFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$58({}, props, { ref: ref }), "data_usage"));
	});

	var __assign$59 = (undefined && undefined.__assign) || function () {
	    __assign$59 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$59.apply(this, arguments);
	};
	var DateRangeFontIcon = React.forwardRef(function DateRangeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$59({}, props, { ref: ref }), "date_range"));
	});

	var __assign$5a = (undefined && undefined.__assign) || function () {
	    __assign$5a = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5a.apply(this, arguments);
	};
	var DehazeFontIcon = React.forwardRef(function DehazeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5a({}, props, { ref: ref }), "dehaze"));
	});

	var __assign$5b = (undefined && undefined.__assign) || function () {
	    __assign$5b = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5b.apply(this, arguments);
	};
	var DeleteForeverFontIcon = React.forwardRef(function DeleteForeverFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5b({}, props, { ref: ref }), "delete_forever"));
	});

	var __assign$5c = (undefined && undefined.__assign) || function () {
	    __assign$5c = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5c.apply(this, arguments);
	};
	var DeleteSweepFontIcon = React.forwardRef(function DeleteSweepFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5c({}, props, { ref: ref }), "delete_sweep"));
	});

	var __assign$5d = (undefined && undefined.__assign) || function () {
	    __assign$5d = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5d.apply(this, arguments);
	};
	var DeleteFontIcon = React.forwardRef(function DeleteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5d({}, props, { ref: ref }), "delete"));
	});

	var __assign$5e = (undefined && undefined.__assign) || function () {
	    __assign$5e = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5e.apply(this, arguments);
	};
	var DescriptionFontIcon = React.forwardRef(function DescriptionFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5e({}, props, { ref: ref }), "description"));
	});

	var __assign$5f = (undefined && undefined.__assign) || function () {
	    __assign$5f = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5f.apply(this, arguments);
	};
	var DesktopMacFontIcon = React.forwardRef(function DesktopMacFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5f({}, props, { ref: ref }), "desktop_mac"));
	});

	var __assign$5g = (undefined && undefined.__assign) || function () {
	    __assign$5g = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5g.apply(this, arguments);
	};
	var DesktopWindowsFontIcon = React.forwardRef(function DesktopWindowsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5g({}, props, { ref: ref }), "desktop_windows"));
	});

	var __assign$5h = (undefined && undefined.__assign) || function () {
	    __assign$5h = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5h.apply(this, arguments);
	};
	var DetailsFontIcon = React.forwardRef(function DetailsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5h({}, props, { ref: ref }), "details"));
	});

	var __assign$5i = (undefined && undefined.__assign) || function () {
	    __assign$5i = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5i.apply(this, arguments);
	};
	var DeveloperBoardFontIcon = React.forwardRef(function DeveloperBoardFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5i({}, props, { ref: ref }), "developer_board"));
	});

	var __assign$5j = (undefined && undefined.__assign) || function () {
	    __assign$5j = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5j.apply(this, arguments);
	};
	var DeveloperModeFontIcon = React.forwardRef(function DeveloperModeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5j({}, props, { ref: ref }), "developer_mode"));
	});

	var __assign$5k = (undefined && undefined.__assign) || function () {
	    __assign$5k = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5k.apply(this, arguments);
	};
	var DeviceHubFontIcon = React.forwardRef(function DeviceHubFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5k({}, props, { ref: ref }), "device_hub"));
	});

	var __assign$5l = (undefined && undefined.__assign) || function () {
	    __assign$5l = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5l.apply(this, arguments);
	};
	var DevicesOtherFontIcon = React.forwardRef(function DevicesOtherFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5l({}, props, { ref: ref }), "devices_other"));
	});

	var __assign$5m = (undefined && undefined.__assign) || function () {
	    __assign$5m = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5m.apply(this, arguments);
	};
	var DevicesFontIcon = React.forwardRef(function DevicesFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5m({}, props, { ref: ref }), "devices"));
	});

	var __assign$5n = (undefined && undefined.__assign) || function () {
	    __assign$5n = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5n.apply(this, arguments);
	};
	var DialerSipFontIcon = React.forwardRef(function DialerSipFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5n({}, props, { ref: ref }), "dialer_sip"));
	});

	var __assign$5o = (undefined && undefined.__assign) || function () {
	    __assign$5o = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5o.apply(this, arguments);
	};
	var DialpadFontIcon = React.forwardRef(function DialpadFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5o({}, props, { ref: ref }), "dialpad"));
	});

	var __assign$5p = (undefined && undefined.__assign) || function () {
	    __assign$5p = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5p.apply(this, arguments);
	};
	var DirectionsBikeFontIcon = React.forwardRef(function DirectionsBikeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5p({}, props, { ref: ref }), "directions_bike"));
	});

	var __assign$5q = (undefined && undefined.__assign) || function () {
	    __assign$5q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5q.apply(this, arguments);
	};
	var DirectionsBoatFontIcon = React.forwardRef(function DirectionsBoatFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5q({}, props, { ref: ref }), "directions_boat"));
	});

	var __assign$5r = (undefined && undefined.__assign) || function () {
	    __assign$5r = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5r.apply(this, arguments);
	};
	var DirectionsBusFontIcon = React.forwardRef(function DirectionsBusFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5r({}, props, { ref: ref }), "directions_bus"));
	});

	var __assign$5s = (undefined && undefined.__assign) || function () {
	    __assign$5s = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5s.apply(this, arguments);
	};
	var DirectionsCarFontIcon = React.forwardRef(function DirectionsCarFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5s({}, props, { ref: ref }), "directions_car"));
	});

	var __assign$5t = (undefined && undefined.__assign) || function () {
	    __assign$5t = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5t.apply(this, arguments);
	};
	var DirectionsRailwayFontIcon = React.forwardRef(function DirectionsRailwayFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5t({}, props, { ref: ref }), "directions_railway"));
	});

	var __assign$5u = (undefined && undefined.__assign) || function () {
	    __assign$5u = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5u.apply(this, arguments);
	};
	var DirectionsRunFontIcon = React.forwardRef(function DirectionsRunFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5u({}, props, { ref: ref }), "directions_run"));
	});

	var __assign$5v = (undefined && undefined.__assign) || function () {
	    __assign$5v = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5v.apply(this, arguments);
	};
	var DirectionsSubwayFontIcon = React.forwardRef(function DirectionsSubwayFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5v({}, props, { ref: ref }), "directions_subway"));
	});

	var __assign$5w = (undefined && undefined.__assign) || function () {
	    __assign$5w = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5w.apply(this, arguments);
	};
	var DirectionsTransitFontIcon = React.forwardRef(function DirectionsTransitFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5w({}, props, { ref: ref }), "directions_transit"));
	});

	var __assign$5x = (undefined && undefined.__assign) || function () {
	    __assign$5x = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5x.apply(this, arguments);
	};
	var DirectionsWalkFontIcon = React.forwardRef(function DirectionsWalkFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5x({}, props, { ref: ref }), "directions_walk"));
	});

	var __assign$5y = (undefined && undefined.__assign) || function () {
	    __assign$5y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5y.apply(this, arguments);
	};
	var DirectionsFontIcon = React.forwardRef(function DirectionsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5y({}, props, { ref: ref }), "directions"));
	});

	var __assign$5z = (undefined && undefined.__assign) || function () {
	    __assign$5z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5z.apply(this, arguments);
	};
	var DiscFullFontIcon = React.forwardRef(function DiscFullFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5z({}, props, { ref: ref }), "disc_full"));
	});

	var __assign$5A = (undefined && undefined.__assign) || function () {
	    __assign$5A = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5A.apply(this, arguments);
	};
	var DnsFontIcon = React.forwardRef(function DnsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5A({}, props, { ref: ref }), "dns"));
	});

	var __assign$5B = (undefined && undefined.__assign) || function () {
	    __assign$5B = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5B.apply(this, arguments);
	};
	var DoNotDisturbAltFontIcon = React.forwardRef(function DoNotDisturbAltFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5B({}, props, { ref: ref }), "do_not_disturb_alt"));
	});

	var __assign$5C = (undefined && undefined.__assign) || function () {
	    __assign$5C = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5C.apply(this, arguments);
	};
	var DoNotDisturbOffFontIcon = React.forwardRef(function DoNotDisturbOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5C({}, props, { ref: ref }), "do_not_disturb_off"));
	});

	var __assign$5D = (undefined && undefined.__assign) || function () {
	    __assign$5D = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5D.apply(this, arguments);
	};
	var DoNotDisturbOnFontIcon = React.forwardRef(function DoNotDisturbOnFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5D({}, props, { ref: ref }), "do_not_disturb_on"));
	});

	var __assign$5E = (undefined && undefined.__assign) || function () {
	    __assign$5E = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5E.apply(this, arguments);
	};
	var DoNotDisturbFontIcon = React.forwardRef(function DoNotDisturbFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5E({}, props, { ref: ref }), "do_not_disturb"));
	});

	var __assign$5F = (undefined && undefined.__assign) || function () {
	    __assign$5F = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5F.apply(this, arguments);
	};
	var DockFontIcon = React.forwardRef(function DockFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5F({}, props, { ref: ref }), "dock"));
	});

	var __assign$5G = (undefined && undefined.__assign) || function () {
	    __assign$5G = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5G.apply(this, arguments);
	};
	var DomainFontIcon = React.forwardRef(function DomainFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5G({}, props, { ref: ref }), "domain"));
	});

	var __assign$5H = (undefined && undefined.__assign) || function () {
	    __assign$5H = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5H.apply(this, arguments);
	};
	var DoneAllFontIcon = React.forwardRef(function DoneAllFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5H({}, props, { ref: ref }), "done_all"));
	});

	var __assign$5I = (undefined && undefined.__assign) || function () {
	    __assign$5I = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5I.apply(this, arguments);
	};
	var DoneFontIcon = React.forwardRef(function DoneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5I({}, props, { ref: ref }), "done"));
	});

	var __assign$5J = (undefined && undefined.__assign) || function () {
	    __assign$5J = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5J.apply(this, arguments);
	};
	var DonutLargeFontIcon = React.forwardRef(function DonutLargeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5J({}, props, { ref: ref }), "donut_large"));
	});

	var __assign$5K = (undefined && undefined.__assign) || function () {
	    __assign$5K = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5K.apply(this, arguments);
	};
	var DonutSmallFontIcon = React.forwardRef(function DonutSmallFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5K({}, props, { ref: ref }), "donut_small"));
	});

	var __assign$5L = (undefined && undefined.__assign) || function () {
	    __assign$5L = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5L.apply(this, arguments);
	};
	var DraftsFontIcon = React.forwardRef(function DraftsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5L({}, props, { ref: ref }), "drafts"));
	});

	var __assign$5M = (undefined && undefined.__assign) || function () {
	    __assign$5M = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5M.apply(this, arguments);
	};
	var DragHandleFontIcon = React.forwardRef(function DragHandleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5M({}, props, { ref: ref }), "drag_handle"));
	});

	var __assign$5N = (undefined && undefined.__assign) || function () {
	    __assign$5N = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5N.apply(this, arguments);
	};
	var DriveEtaFontIcon = React.forwardRef(function DriveEtaFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5N({}, props, { ref: ref }), "drive_eta"));
	});

	var __assign$5O = (undefined && undefined.__assign) || function () {
	    __assign$5O = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5O.apply(this, arguments);
	};
	var DvrFontIcon = React.forwardRef(function DvrFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5O({}, props, { ref: ref }), "dvr"));
	});

	var __assign$5P = (undefined && undefined.__assign) || function () {
	    __assign$5P = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5P.apply(this, arguments);
	};
	var EditLocationFontIcon = React.forwardRef(function EditLocationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5P({}, props, { ref: ref }), "edit_location"));
	});

	var __assign$5Q = (undefined && undefined.__assign) || function () {
	    __assign$5Q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5Q.apply(this, arguments);
	};
	var EditFontIcon = React.forwardRef(function EditFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5Q({}, props, { ref: ref }), "edit"));
	});

	var __assign$5R = (undefined && undefined.__assign) || function () {
	    __assign$5R = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5R.apply(this, arguments);
	};
	var EjectFontIcon = React.forwardRef(function EjectFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5R({}, props, { ref: ref }), "eject"));
	});

	var __assign$5S = (undefined && undefined.__assign) || function () {
	    __assign$5S = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5S.apply(this, arguments);
	};
	var EmailFontIcon = React.forwardRef(function EmailFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5S({}, props, { ref: ref }), "email"));
	});

	var __assign$5T = (undefined && undefined.__assign) || function () {
	    __assign$5T = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5T.apply(this, arguments);
	};
	var EnhancedEncryptionFontIcon = React.forwardRef(function EnhancedEncryptionFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5T({}, props, { ref: ref }), "enhanced_encryption"));
	});

	var __assign$5U = (undefined && undefined.__assign) || function () {
	    __assign$5U = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5U.apply(this, arguments);
	};
	var EqualizerFontIcon = React.forwardRef(function EqualizerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5U({}, props, { ref: ref }), "equalizer"));
	});

	var __assign$5V = (undefined && undefined.__assign) || function () {
	    __assign$5V = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5V.apply(this, arguments);
	};
	var ErrorOutlineFontIcon = React.forwardRef(function ErrorOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5V({}, props, { ref: ref }), "error_outline"));
	});

	var __assign$5W = (undefined && undefined.__assign) || function () {
	    __assign$5W = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5W.apply(this, arguments);
	};
	var ErrorFontIcon = React.forwardRef(function ErrorFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5W({}, props, { ref: ref }), "error"));
	});

	var __assign$5X = (undefined && undefined.__assign) || function () {
	    __assign$5X = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5X.apply(this, arguments);
	};
	var EuroSymbolFontIcon = React.forwardRef(function EuroSymbolFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5X({}, props, { ref: ref }), "euro_symbol"));
	});

	var __assign$5Y = (undefined && undefined.__assign) || function () {
	    __assign$5Y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5Y.apply(this, arguments);
	};
	var EvStationFontIcon = React.forwardRef(function EvStationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5Y({}, props, { ref: ref }), "ev_station"));
	});

	var __assign$5Z = (undefined && undefined.__assign) || function () {
	    __assign$5Z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5Z.apply(this, arguments);
	};
	var EventAvailableFontIcon = React.forwardRef(function EventAvailableFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5Z({}, props, { ref: ref }), "event_available"));
	});

	var __assign$5_ = (undefined && undefined.__assign) || function () {
	    __assign$5_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5_.apply(this, arguments);
	};
	var EventBusyFontIcon = React.forwardRef(function EventBusyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5_({}, props, { ref: ref }), "event_busy"));
	});

	var __assign$5$ = (undefined && undefined.__assign) || function () {
	    __assign$5$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5$.apply(this, arguments);
	};
	var EventNoteFontIcon = React.forwardRef(function EventNoteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$5$({}, props, { ref: ref }), "event_note"));
	});

	var __assign$60 = (undefined && undefined.__assign) || function () {
	    __assign$60 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$60.apply(this, arguments);
	};
	var EventSeatFontIcon = React.forwardRef(function EventSeatFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$60({}, props, { ref: ref }), "event_seat"));
	});

	var __assign$61 = (undefined && undefined.__assign) || function () {
	    __assign$61 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$61.apply(this, arguments);
	};
	var EventFontIcon = React.forwardRef(function EventFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$61({}, props, { ref: ref }), "event"));
	});

	var __assign$62 = (undefined && undefined.__assign) || function () {
	    __assign$62 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$62.apply(this, arguments);
	};
	var ExitToAppFontIcon = React.forwardRef(function ExitToAppFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$62({}, props, { ref: ref }), "exit_to_app"));
	});

	var __assign$63 = (undefined && undefined.__assign) || function () {
	    __assign$63 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$63.apply(this, arguments);
	};
	var ExpandLessFontIcon = React.forwardRef(function ExpandLessFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$63({}, props, { ref: ref }), "expand_less"));
	});

	var __assign$64 = (undefined && undefined.__assign) || function () {
	    __assign$64 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$64.apply(this, arguments);
	};
	var ExpandMoreFontIcon = React.forwardRef(function ExpandMoreFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$64({}, props, { ref: ref }), "expand_more"));
	});

	var __assign$65 = (undefined && undefined.__assign) || function () {
	    __assign$65 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$65.apply(this, arguments);
	};
	var ExplicitFontIcon = React.forwardRef(function ExplicitFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$65({}, props, { ref: ref }), "explicit"));
	});

	var __assign$66 = (undefined && undefined.__assign) || function () {
	    __assign$66 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$66.apply(this, arguments);
	};
	var ExploreFontIcon = React.forwardRef(function ExploreFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$66({}, props, { ref: ref }), "explore"));
	});

	var __assign$67 = (undefined && undefined.__assign) || function () {
	    __assign$67 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$67.apply(this, arguments);
	};
	var ExposureNeg1FontIcon = React.forwardRef(function ExposureNeg1FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$67({}, props, { ref: ref }), "exposure_neg_1"));
	});

	var __assign$68 = (undefined && undefined.__assign) || function () {
	    __assign$68 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$68.apply(this, arguments);
	};
	var ExposureNeg2FontIcon = React.forwardRef(function ExposureNeg2FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$68({}, props, { ref: ref }), "exposure_neg_2"));
	});

	var __assign$69 = (undefined && undefined.__assign) || function () {
	    __assign$69 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$69.apply(this, arguments);
	};
	var ExposurePlus1FontIcon = React.forwardRef(function ExposurePlus1FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$69({}, props, { ref: ref }), "exposure_plus_1"));
	});

	var __assign$6a = (undefined && undefined.__assign) || function () {
	    __assign$6a = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6a.apply(this, arguments);
	};
	var ExposurePlus2FontIcon = React.forwardRef(function ExposurePlus2FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6a({}, props, { ref: ref }), "exposure_plus_2"));
	});

	var __assign$6b = (undefined && undefined.__assign) || function () {
	    __assign$6b = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6b.apply(this, arguments);
	};
	var ExposureZeroFontIcon = React.forwardRef(function ExposureZeroFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6b({}, props, { ref: ref }), "exposure_zero"));
	});

	var __assign$6c = (undefined && undefined.__assign) || function () {
	    __assign$6c = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6c.apply(this, arguments);
	};
	var ExposureFontIcon = React.forwardRef(function ExposureFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6c({}, props, { ref: ref }), "exposure"));
	});

	var __assign$6d = (undefined && undefined.__assign) || function () {
	    __assign$6d = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6d.apply(this, arguments);
	};
	var ExtensionFontIcon = React.forwardRef(function ExtensionFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6d({}, props, { ref: ref }), "extension"));
	});

	var __assign$6e = (undefined && undefined.__assign) || function () {
	    __assign$6e = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6e.apply(this, arguments);
	};
	var FaceFontIcon = React.forwardRef(function FaceFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6e({}, props, { ref: ref }), "face"));
	});

	var __assign$6f = (undefined && undefined.__assign) || function () {
	    __assign$6f = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6f.apply(this, arguments);
	};
	var FastForwardFontIcon = React.forwardRef(function FastForwardFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6f({}, props, { ref: ref }), "fast_forward"));
	});

	var __assign$6g = (undefined && undefined.__assign) || function () {
	    __assign$6g = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6g.apply(this, arguments);
	};
	var FastRewindFontIcon = React.forwardRef(function FastRewindFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6g({}, props, { ref: ref }), "fast_rewind"));
	});

	var __assign$6h = (undefined && undefined.__assign) || function () {
	    __assign$6h = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6h.apply(this, arguments);
	};
	var FavoriteBorderFontIcon = React.forwardRef(function FavoriteBorderFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6h({}, props, { ref: ref }), "favorite_border"));
	});

	var __assign$6i = (undefined && undefined.__assign) || function () {
	    __assign$6i = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6i.apply(this, arguments);
	};
	var FavoriteFontIcon = React.forwardRef(function FavoriteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6i({}, props, { ref: ref }), "favorite"));
	});

	var __assign$6j = (undefined && undefined.__assign) || function () {
	    __assign$6j = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6j.apply(this, arguments);
	};
	var FeaturedPlayListFontIcon = React.forwardRef(function FeaturedPlayListFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6j({}, props, { ref: ref }), "featured_play_list"));
	});

	var __assign$6k = (undefined && undefined.__assign) || function () {
	    __assign$6k = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6k.apply(this, arguments);
	};
	var FeaturedVideoFontIcon = React.forwardRef(function FeaturedVideoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6k({}, props, { ref: ref }), "featured_video"));
	});

	var __assign$6l = (undefined && undefined.__assign) || function () {
	    __assign$6l = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6l.apply(this, arguments);
	};
	var FeedbackFontIcon = React.forwardRef(function FeedbackFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6l({}, props, { ref: ref }), "feedback"));
	});

	var __assign$6m = (undefined && undefined.__assign) || function () {
	    __assign$6m = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6m.apply(this, arguments);
	};
	var FiberDvrFontIcon = React.forwardRef(function FiberDvrFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6m({}, props, { ref: ref }), "fiber_dvr"));
	});

	var __assign$6n = (undefined && undefined.__assign) || function () {
	    __assign$6n = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6n.apply(this, arguments);
	};
	var FiberManualRecordFontIcon = React.forwardRef(function FiberManualRecordFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6n({}, props, { ref: ref }), "fiber_manual_record"));
	});

	var __assign$6o = (undefined && undefined.__assign) || function () {
	    __assign$6o = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6o.apply(this, arguments);
	};
	var FiberNewFontIcon = React.forwardRef(function FiberNewFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6o({}, props, { ref: ref }), "fiber_new"));
	});

	var __assign$6p = (undefined && undefined.__assign) || function () {
	    __assign$6p = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6p.apply(this, arguments);
	};
	var FiberPinFontIcon = React.forwardRef(function FiberPinFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6p({}, props, { ref: ref }), "fiber_pin"));
	});

	var __assign$6q = (undefined && undefined.__assign) || function () {
	    __assign$6q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6q.apply(this, arguments);
	};
	var FiberSmartRecordFontIcon = React.forwardRef(function FiberSmartRecordFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6q({}, props, { ref: ref }), "fiber_smart_record"));
	});

	var __assign$6r = (undefined && undefined.__assign) || function () {
	    __assign$6r = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6r.apply(this, arguments);
	};
	var FileDownloadFontIcon = React.forwardRef(function FileDownloadFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6r({}, props, { ref: ref }), "file_download"));
	});

	var __assign$6s = (undefined && undefined.__assign) || function () {
	    __assign$6s = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6s.apply(this, arguments);
	};
	var FileUploadFontIcon = React.forwardRef(function FileUploadFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6s({}, props, { ref: ref }), "file_upload"));
	});

	var __assign$6t = (undefined && undefined.__assign) || function () {
	    __assign$6t = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6t.apply(this, arguments);
	};
	var Filter1FontIcon = React.forwardRef(function Filter1FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6t({}, props, { ref: ref }), "filter_1"));
	});

	var __assign$6u = (undefined && undefined.__assign) || function () {
	    __assign$6u = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6u.apply(this, arguments);
	};
	var Filter2FontIcon = React.forwardRef(function Filter2FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6u({}, props, { ref: ref }), "filter_2"));
	});

	var __assign$6v = (undefined && undefined.__assign) || function () {
	    __assign$6v = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6v.apply(this, arguments);
	};
	var Filter3FontIcon = React.forwardRef(function Filter3FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6v({}, props, { ref: ref }), "filter_3"));
	});

	var __assign$6w = (undefined && undefined.__assign) || function () {
	    __assign$6w = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6w.apply(this, arguments);
	};
	var Filter4FontIcon = React.forwardRef(function Filter4FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6w({}, props, { ref: ref }), "filter_4"));
	});

	var __assign$6x = (undefined && undefined.__assign) || function () {
	    __assign$6x = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6x.apply(this, arguments);
	};
	var Filter5FontIcon = React.forwardRef(function Filter5FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6x({}, props, { ref: ref }), "filter_5"));
	});

	var __assign$6y = (undefined && undefined.__assign) || function () {
	    __assign$6y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6y.apply(this, arguments);
	};
	var Filter6FontIcon = React.forwardRef(function Filter6FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6y({}, props, { ref: ref }), "filter_6"));
	});

	var __assign$6z = (undefined && undefined.__assign) || function () {
	    __assign$6z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6z.apply(this, arguments);
	};
	var Filter7FontIcon = React.forwardRef(function Filter7FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6z({}, props, { ref: ref }), "filter_7"));
	});

	var __assign$6A = (undefined && undefined.__assign) || function () {
	    __assign$6A = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6A.apply(this, arguments);
	};
	var Filter8FontIcon = React.forwardRef(function Filter8FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6A({}, props, { ref: ref }), "filter_8"));
	});

	var __assign$6B = (undefined && undefined.__assign) || function () {
	    __assign$6B = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6B.apply(this, arguments);
	};
	var Filter9PlusFontIcon = React.forwardRef(function Filter9PlusFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6B({}, props, { ref: ref }), "filter_9_plus"));
	});

	var __assign$6C = (undefined && undefined.__assign) || function () {
	    __assign$6C = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6C.apply(this, arguments);
	};
	var Filter9FontIcon = React.forwardRef(function Filter9FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6C({}, props, { ref: ref }), "filter_9"));
	});

	var __assign$6D = (undefined && undefined.__assign) || function () {
	    __assign$6D = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6D.apply(this, arguments);
	};
	var FilterBAndWFontIcon = React.forwardRef(function FilterBAndWFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6D({}, props, { ref: ref }), "filter_b_and_w"));
	});

	var __assign$6E = (undefined && undefined.__assign) || function () {
	    __assign$6E = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6E.apply(this, arguments);
	};
	var FilterCenterFocusFontIcon = React.forwardRef(function FilterCenterFocusFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6E({}, props, { ref: ref }), "filter_center_focus"));
	});

	var __assign$6F = (undefined && undefined.__assign) || function () {
	    __assign$6F = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6F.apply(this, arguments);
	};
	var FilterDramaFontIcon = React.forwardRef(function FilterDramaFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6F({}, props, { ref: ref }), "filter_drama"));
	});

	var __assign$6G = (undefined && undefined.__assign) || function () {
	    __assign$6G = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6G.apply(this, arguments);
	};
	var FilterFramesFontIcon = React.forwardRef(function FilterFramesFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6G({}, props, { ref: ref }), "filter_frames"));
	});

	var __assign$6H = (undefined && undefined.__assign) || function () {
	    __assign$6H = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6H.apply(this, arguments);
	};
	var FilterHdrFontIcon = React.forwardRef(function FilterHdrFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6H({}, props, { ref: ref }), "filter_hdr"));
	});

	var __assign$6I = (undefined && undefined.__assign) || function () {
	    __assign$6I = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6I.apply(this, arguments);
	};
	var FilterListFontIcon = React.forwardRef(function FilterListFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6I({}, props, { ref: ref }), "filter_list"));
	});

	var __assign$6J = (undefined && undefined.__assign) || function () {
	    __assign$6J = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6J.apply(this, arguments);
	};
	var FilterNoneFontIcon = React.forwardRef(function FilterNoneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6J({}, props, { ref: ref }), "filter_none"));
	});

	var __assign$6K = (undefined && undefined.__assign) || function () {
	    __assign$6K = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6K.apply(this, arguments);
	};
	var FilterTiltShiftFontIcon = React.forwardRef(function FilterTiltShiftFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6K({}, props, { ref: ref }), "filter_tilt_shift"));
	});

	var __assign$6L = (undefined && undefined.__assign) || function () {
	    __assign$6L = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6L.apply(this, arguments);
	};
	var FilterVintageFontIcon = React.forwardRef(function FilterVintageFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6L({}, props, { ref: ref }), "filter_vintage"));
	});

	var __assign$6M = (undefined && undefined.__assign) || function () {
	    __assign$6M = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6M.apply(this, arguments);
	};
	var FilterFontIcon = React.forwardRef(function FilterFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6M({}, props, { ref: ref }), "filter"));
	});

	var __assign$6N = (undefined && undefined.__assign) || function () {
	    __assign$6N = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6N.apply(this, arguments);
	};
	var FindInPageFontIcon = React.forwardRef(function FindInPageFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6N({}, props, { ref: ref }), "find_in_page"));
	});

	var __assign$6O = (undefined && undefined.__assign) || function () {
	    __assign$6O = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6O.apply(this, arguments);
	};
	var FindReplaceFontIcon = React.forwardRef(function FindReplaceFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6O({}, props, { ref: ref }), "find_replace"));
	});

	var __assign$6P = (undefined && undefined.__assign) || function () {
	    __assign$6P = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6P.apply(this, arguments);
	};
	var FingerprintFontIcon = React.forwardRef(function FingerprintFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6P({}, props, { ref: ref }), "fingerprint"));
	});

	var __assign$6Q = (undefined && undefined.__assign) || function () {
	    __assign$6Q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6Q.apply(this, arguments);
	};
	var FirstPageFontIcon = React.forwardRef(function FirstPageFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6Q({}, props, { ref: ref }), "first_page"));
	});

	var __assign$6R = (undefined && undefined.__assign) || function () {
	    __assign$6R = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6R.apply(this, arguments);
	};
	var FitnessCenterFontIcon = React.forwardRef(function FitnessCenterFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6R({}, props, { ref: ref }), "fitness_center"));
	});

	var __assign$6S = (undefined && undefined.__assign) || function () {
	    __assign$6S = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6S.apply(this, arguments);
	};
	var FlagFontIcon = React.forwardRef(function FlagFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6S({}, props, { ref: ref }), "flag"));
	});

	var __assign$6T = (undefined && undefined.__assign) || function () {
	    __assign$6T = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6T.apply(this, arguments);
	};
	var FlareFontIcon = React.forwardRef(function FlareFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6T({}, props, { ref: ref }), "flare"));
	});

	var __assign$6U = (undefined && undefined.__assign) || function () {
	    __assign$6U = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6U.apply(this, arguments);
	};
	var FlashAutoFontIcon = React.forwardRef(function FlashAutoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6U({}, props, { ref: ref }), "flash_auto"));
	});

	var __assign$6V = (undefined && undefined.__assign) || function () {
	    __assign$6V = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6V.apply(this, arguments);
	};
	var FlashOffFontIcon = React.forwardRef(function FlashOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6V({}, props, { ref: ref }), "flash_off"));
	});

	var __assign$6W = (undefined && undefined.__assign) || function () {
	    __assign$6W = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6W.apply(this, arguments);
	};
	var FlashOnFontIcon = React.forwardRef(function FlashOnFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6W({}, props, { ref: ref }), "flash_on"));
	});

	var __assign$6X = (undefined && undefined.__assign) || function () {
	    __assign$6X = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6X.apply(this, arguments);
	};
	var FlightLandFontIcon = React.forwardRef(function FlightLandFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6X({}, props, { ref: ref }), "flight_land"));
	});

	var __assign$6Y = (undefined && undefined.__assign) || function () {
	    __assign$6Y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6Y.apply(this, arguments);
	};
	var FlightTakeoffFontIcon = React.forwardRef(function FlightTakeoffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6Y({}, props, { ref: ref }), "flight_takeoff"));
	});

	var __assign$6Z = (undefined && undefined.__assign) || function () {
	    __assign$6Z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6Z.apply(this, arguments);
	};
	var FlightFontIcon = React.forwardRef(function FlightFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6Z({}, props, { ref: ref }), "flight"));
	});

	var __assign$6_ = (undefined && undefined.__assign) || function () {
	    __assign$6_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6_.apply(this, arguments);
	};
	var FlipToBackFontIcon = React.forwardRef(function FlipToBackFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6_({}, props, { ref: ref }), "flip_to_back"));
	});

	var __assign$6$ = (undefined && undefined.__assign) || function () {
	    __assign$6$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6$.apply(this, arguments);
	};
	var FlipToFrontFontIcon = React.forwardRef(function FlipToFrontFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$6$({}, props, { ref: ref }), "flip_to_front"));
	});

	var __assign$70 = (undefined && undefined.__assign) || function () {
	    __assign$70 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$70.apply(this, arguments);
	};
	var FlipFontIcon = React.forwardRef(function FlipFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$70({}, props, { ref: ref }), "flip"));
	});

	var __assign$71 = (undefined && undefined.__assign) || function () {
	    __assign$71 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$71.apply(this, arguments);
	};
	var FolderOpenFontIcon = React.forwardRef(function FolderOpenFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$71({}, props, { ref: ref }), "folder_open"));
	});

	var __assign$72 = (undefined && undefined.__assign) || function () {
	    __assign$72 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$72.apply(this, arguments);
	};
	var FolderSharedFontIcon = React.forwardRef(function FolderSharedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$72({}, props, { ref: ref }), "folder_shared"));
	});

	var __assign$73 = (undefined && undefined.__assign) || function () {
	    __assign$73 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$73.apply(this, arguments);
	};
	var FolderSpecialFontIcon = React.forwardRef(function FolderSpecialFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$73({}, props, { ref: ref }), "folder_special"));
	});

	var __assign$74 = (undefined && undefined.__assign) || function () {
	    __assign$74 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$74.apply(this, arguments);
	};
	var FolderFontIcon = React.forwardRef(function FolderFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$74({}, props, { ref: ref }), "folder"));
	});

	var __assign$75 = (undefined && undefined.__assign) || function () {
	    __assign$75 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$75.apply(this, arguments);
	};
	var FontDownloadFontIcon = React.forwardRef(function FontDownloadFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$75({}, props, { ref: ref }), "font_download"));
	});

	var __assign$76 = (undefined && undefined.__assign) || function () {
	    __assign$76 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$76.apply(this, arguments);
	};
	var FormatAlignCenterFontIcon = React.forwardRef(function FormatAlignCenterFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$76({}, props, { ref: ref }), "format_align_center"));
	});

	var __assign$77 = (undefined && undefined.__assign) || function () {
	    __assign$77 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$77.apply(this, arguments);
	};
	var FormatAlignJustifyFontIcon = React.forwardRef(function FormatAlignJustifyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$77({}, props, { ref: ref }), "format_align_justify"));
	});

	var __assign$78 = (undefined && undefined.__assign) || function () {
	    __assign$78 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$78.apply(this, arguments);
	};
	var FormatAlignLeftFontIcon = React.forwardRef(function FormatAlignLeftFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$78({}, props, { ref: ref }), "format_align_left"));
	});

	var __assign$79 = (undefined && undefined.__assign) || function () {
	    __assign$79 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$79.apply(this, arguments);
	};
	var FormatAlignRightFontIcon = React.forwardRef(function FormatAlignRightFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$79({}, props, { ref: ref }), "format_align_right"));
	});

	var __assign$7a = (undefined && undefined.__assign) || function () {
	    __assign$7a = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7a.apply(this, arguments);
	};
	var FormatBoldFontIcon = React.forwardRef(function FormatBoldFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7a({}, props, { ref: ref }), "format_bold"));
	});

	var __assign$7b = (undefined && undefined.__assign) || function () {
	    __assign$7b = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7b.apply(this, arguments);
	};
	var FormatClearFontIcon = React.forwardRef(function FormatClearFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7b({}, props, { ref: ref }), "format_clear"));
	});

	var __assign$7c = (undefined && undefined.__assign) || function () {
	    __assign$7c = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7c.apply(this, arguments);
	};
	var FormatColorFillFontIcon = React.forwardRef(function FormatColorFillFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7c({}, props, { ref: ref }), "format_color_fill"));
	});

	var __assign$7d = (undefined && undefined.__assign) || function () {
	    __assign$7d = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7d.apply(this, arguments);
	};
	var FormatColorResetFontIcon = React.forwardRef(function FormatColorResetFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7d({}, props, { ref: ref }), "format_color_reset"));
	});

	var __assign$7e = (undefined && undefined.__assign) || function () {
	    __assign$7e = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7e.apply(this, arguments);
	};
	var FormatColorTextFontIcon = React.forwardRef(function FormatColorTextFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7e({}, props, { ref: ref }), "format_color_text"));
	});

	var __assign$7f = (undefined && undefined.__assign) || function () {
	    __assign$7f = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7f.apply(this, arguments);
	};
	var FormatIndentDecreaseFontIcon = React.forwardRef(function FormatIndentDecreaseFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7f({}, props, { ref: ref }), "format_indent_decrease"));
	});

	var __assign$7g = (undefined && undefined.__assign) || function () {
	    __assign$7g = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7g.apply(this, arguments);
	};
	var FormatIndentIncreaseFontIcon = React.forwardRef(function FormatIndentIncreaseFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7g({}, props, { ref: ref }), "format_indent_increase"));
	});

	var __assign$7h = (undefined && undefined.__assign) || function () {
	    __assign$7h = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7h.apply(this, arguments);
	};
	var FormatItalicFontIcon = React.forwardRef(function FormatItalicFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7h({}, props, { ref: ref }), "format_italic"));
	});

	var __assign$7i = (undefined && undefined.__assign) || function () {
	    __assign$7i = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7i.apply(this, arguments);
	};
	var FormatLineSpacingFontIcon = React.forwardRef(function FormatLineSpacingFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7i({}, props, { ref: ref }), "format_line_spacing"));
	});

	var __assign$7j = (undefined && undefined.__assign) || function () {
	    __assign$7j = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7j.apply(this, arguments);
	};
	var FormatListBulletedFontIcon = React.forwardRef(function FormatListBulletedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7j({}, props, { ref: ref }), "format_list_bulleted"));
	});

	var __assign$7k = (undefined && undefined.__assign) || function () {
	    __assign$7k = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7k.apply(this, arguments);
	};
	var FormatListNumberedFontIcon = React.forwardRef(function FormatListNumberedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7k({}, props, { ref: ref }), "format_list_numbered"));
	});

	var __assign$7l = (undefined && undefined.__assign) || function () {
	    __assign$7l = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7l.apply(this, arguments);
	};
	var FormatPaintFontIcon = React.forwardRef(function FormatPaintFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7l({}, props, { ref: ref }), "format_paint"));
	});

	var __assign$7m = (undefined && undefined.__assign) || function () {
	    __assign$7m = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7m.apply(this, arguments);
	};
	var FormatQuoteFontIcon = React.forwardRef(function FormatQuoteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7m({}, props, { ref: ref }), "format_quote"));
	});

	var __assign$7n = (undefined && undefined.__assign) || function () {
	    __assign$7n = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7n.apply(this, arguments);
	};
	var FormatShapesFontIcon = React.forwardRef(function FormatShapesFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7n({}, props, { ref: ref }), "format_shapes"));
	});

	var __assign$7o = (undefined && undefined.__assign) || function () {
	    __assign$7o = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7o.apply(this, arguments);
	};
	var FormatSizeFontIcon = React.forwardRef(function FormatSizeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7o({}, props, { ref: ref }), "format_size"));
	});

	var __assign$7p = (undefined && undefined.__assign) || function () {
	    __assign$7p = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7p.apply(this, arguments);
	};
	var FormatStrikethroughFontIcon = React.forwardRef(function FormatStrikethroughFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7p({}, props, { ref: ref }), "format_strikethrough"));
	});

	var __assign$7q = (undefined && undefined.__assign) || function () {
	    __assign$7q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7q.apply(this, arguments);
	};
	var FormatTextdirectionLToRFontIcon = React.forwardRef(function FormatTextdirectionLToRFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7q({}, props, { ref: ref }), "format_textdirection_l_to_r"));
	});

	var __assign$7r = (undefined && undefined.__assign) || function () {
	    __assign$7r = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7r.apply(this, arguments);
	};
	var FormatTextdirectionRToLFontIcon = React.forwardRef(function FormatTextdirectionRToLFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7r({}, props, { ref: ref }), "format_textdirection_r_to_l"));
	});

	var __assign$7s = (undefined && undefined.__assign) || function () {
	    __assign$7s = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7s.apply(this, arguments);
	};
	var FormatUnderlinedFontIcon = React.forwardRef(function FormatUnderlinedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7s({}, props, { ref: ref }), "format_underlined"));
	});

	var __assign$7t = (undefined && undefined.__assign) || function () {
	    __assign$7t = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7t.apply(this, arguments);
	};
	var ForumFontIcon = React.forwardRef(function ForumFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7t({}, props, { ref: ref }), "forum"));
	});

	var __assign$7u = (undefined && undefined.__assign) || function () {
	    __assign$7u = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7u.apply(this, arguments);
	};
	var Forward10FontIcon = React.forwardRef(function Forward10FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7u({}, props, { ref: ref }), "forward_10"));
	});

	var __assign$7v = (undefined && undefined.__assign) || function () {
	    __assign$7v = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7v.apply(this, arguments);
	};
	var Forward30FontIcon = React.forwardRef(function Forward30FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7v({}, props, { ref: ref }), "forward_30"));
	});

	var __assign$7w = (undefined && undefined.__assign) || function () {
	    __assign$7w = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7w.apply(this, arguments);
	};
	var Forward5FontIcon = React.forwardRef(function Forward5FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7w({}, props, { ref: ref }), "forward_5"));
	});

	var __assign$7x = (undefined && undefined.__assign) || function () {
	    __assign$7x = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7x.apply(this, arguments);
	};
	var ForwardFontIcon = React.forwardRef(function ForwardFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7x({}, props, { ref: ref }), "forward"));
	});

	var __assign$7y = (undefined && undefined.__assign) || function () {
	    __assign$7y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7y.apply(this, arguments);
	};
	var FreeBreakfastFontIcon = React.forwardRef(function FreeBreakfastFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7y({}, props, { ref: ref }), "free_breakfast"));
	});

	var __assign$7z = (undefined && undefined.__assign) || function () {
	    __assign$7z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7z.apply(this, arguments);
	};
	var FullscreenExitFontIcon = React.forwardRef(function FullscreenExitFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7z({}, props, { ref: ref }), "fullscreen_exit"));
	});

	var __assign$7A = (undefined && undefined.__assign) || function () {
	    __assign$7A = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7A.apply(this, arguments);
	};
	var FullscreenFontIcon = React.forwardRef(function FullscreenFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7A({}, props, { ref: ref }), "fullscreen"));
	});

	var __assign$7B = (undefined && undefined.__assign) || function () {
	    __assign$7B = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7B.apply(this, arguments);
	};
	var FunctionsFontIcon = React.forwardRef(function FunctionsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7B({}, props, { ref: ref }), "functions"));
	});

	var __assign$7C = (undefined && undefined.__assign) || function () {
	    __assign$7C = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7C.apply(this, arguments);
	};
	var GTranslateFontIcon = React.forwardRef(function GTranslateFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7C({}, props, { ref: ref }), "g_translate"));
	});

	var __assign$7D = (undefined && undefined.__assign) || function () {
	    __assign$7D = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7D.apply(this, arguments);
	};
	var GamepadFontIcon = React.forwardRef(function GamepadFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7D({}, props, { ref: ref }), "gamepad"));
	});

	var __assign$7E = (undefined && undefined.__assign) || function () {
	    __assign$7E = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7E.apply(this, arguments);
	};
	var GamesFontIcon = React.forwardRef(function GamesFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7E({}, props, { ref: ref }), "games"));
	});

	var __assign$7F = (undefined && undefined.__assign) || function () {
	    __assign$7F = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7F.apply(this, arguments);
	};
	var GavelFontIcon = React.forwardRef(function GavelFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7F({}, props, { ref: ref }), "gavel"));
	});

	var __assign$7G = (undefined && undefined.__assign) || function () {
	    __assign$7G = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7G.apply(this, arguments);
	};
	var GestureFontIcon = React.forwardRef(function GestureFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7G({}, props, { ref: ref }), "gesture"));
	});

	var __assign$7H = (undefined && undefined.__assign) || function () {
	    __assign$7H = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7H.apply(this, arguments);
	};
	var GetAppFontIcon = React.forwardRef(function GetAppFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7H({}, props, { ref: ref }), "get_app"));
	});

	var __assign$7I = (undefined && undefined.__assign) || function () {
	    __assign$7I = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7I.apply(this, arguments);
	};
	var GifFontIcon = React.forwardRef(function GifFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7I({}, props, { ref: ref }), "gif"));
	});

	var __assign$7J = (undefined && undefined.__assign) || function () {
	    __assign$7J = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7J.apply(this, arguments);
	};
	var GolfCourseFontIcon = React.forwardRef(function GolfCourseFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7J({}, props, { ref: ref }), "golf_course"));
	});

	var __assign$7K = (undefined && undefined.__assign) || function () {
	    __assign$7K = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7K.apply(this, arguments);
	};
	var GpsFixedFontIcon = React.forwardRef(function GpsFixedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7K({}, props, { ref: ref }), "gps_fixed"));
	});

	var __assign$7L = (undefined && undefined.__assign) || function () {
	    __assign$7L = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7L.apply(this, arguments);
	};
	var GpsNotFixedFontIcon = React.forwardRef(function GpsNotFixedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7L({}, props, { ref: ref }), "gps_not_fixed"));
	});

	var __assign$7M = (undefined && undefined.__assign) || function () {
	    __assign$7M = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7M.apply(this, arguments);
	};
	var GpsOffFontIcon = React.forwardRef(function GpsOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7M({}, props, { ref: ref }), "gps_off"));
	});

	var __assign$7N = (undefined && undefined.__assign) || function () {
	    __assign$7N = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7N.apply(this, arguments);
	};
	var GradeFontIcon = React.forwardRef(function GradeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7N({}, props, { ref: ref }), "grade"));
	});

	var __assign$7O = (undefined && undefined.__assign) || function () {
	    __assign$7O = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7O.apply(this, arguments);
	};
	var GradientFontIcon = React.forwardRef(function GradientFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7O({}, props, { ref: ref }), "gradient"));
	});

	var __assign$7P = (undefined && undefined.__assign) || function () {
	    __assign$7P = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7P.apply(this, arguments);
	};
	var GrainFontIcon = React.forwardRef(function GrainFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7P({}, props, { ref: ref }), "grain"));
	});

	var __assign$7Q = (undefined && undefined.__assign) || function () {
	    __assign$7Q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7Q.apply(this, arguments);
	};
	var GraphicEqFontIcon = React.forwardRef(function GraphicEqFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7Q({}, props, { ref: ref }), "graphic_eq"));
	});

	var __assign$7R = (undefined && undefined.__assign) || function () {
	    __assign$7R = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7R.apply(this, arguments);
	};
	var GridOffFontIcon = React.forwardRef(function GridOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7R({}, props, { ref: ref }), "grid_off"));
	});

	var __assign$7S = (undefined && undefined.__assign) || function () {
	    __assign$7S = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7S.apply(this, arguments);
	};
	var GridOnFontIcon = React.forwardRef(function GridOnFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7S({}, props, { ref: ref }), "grid_on"));
	});

	var __assign$7T = (undefined && undefined.__assign) || function () {
	    __assign$7T = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7T.apply(this, arguments);
	};
	var GroupAddFontIcon = React.forwardRef(function GroupAddFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7T({}, props, { ref: ref }), "group_add"));
	});

	var __assign$7U = (undefined && undefined.__assign) || function () {
	    __assign$7U = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7U.apply(this, arguments);
	};
	var GroupWorkFontIcon = React.forwardRef(function GroupWorkFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7U({}, props, { ref: ref }), "group_work"));
	});

	var __assign$7V = (undefined && undefined.__assign) || function () {
	    __assign$7V = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7V.apply(this, arguments);
	};
	var GroupFontIcon = React.forwardRef(function GroupFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7V({}, props, { ref: ref }), "group"));
	});

	var __assign$7W = (undefined && undefined.__assign) || function () {
	    __assign$7W = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7W.apply(this, arguments);
	};
	var HdFontIcon = React.forwardRef(function HdFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7W({}, props, { ref: ref }), "hd"));
	});

	var __assign$7X = (undefined && undefined.__assign) || function () {
	    __assign$7X = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7X.apply(this, arguments);
	};
	var HdrOffFontIcon = React.forwardRef(function HdrOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7X({}, props, { ref: ref }), "hdr_off"));
	});

	var __assign$7Y = (undefined && undefined.__assign) || function () {
	    __assign$7Y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7Y.apply(this, arguments);
	};
	var HdrOnFontIcon = React.forwardRef(function HdrOnFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7Y({}, props, { ref: ref }), "hdr_on"));
	});

	var __assign$7Z = (undefined && undefined.__assign) || function () {
	    __assign$7Z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7Z.apply(this, arguments);
	};
	var HdrStrongFontIcon = React.forwardRef(function HdrStrongFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7Z({}, props, { ref: ref }), "hdr_strong"));
	});

	var __assign$7_ = (undefined && undefined.__assign) || function () {
	    __assign$7_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7_.apply(this, arguments);
	};
	var HdrWeakFontIcon = React.forwardRef(function HdrWeakFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7_({}, props, { ref: ref }), "hdr_weak"));
	});

	var __assign$7$ = (undefined && undefined.__assign) || function () {
	    __assign$7$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7$.apply(this, arguments);
	};
	var HeadsetMicFontIcon = React.forwardRef(function HeadsetMicFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$7$({}, props, { ref: ref }), "headset_mic"));
	});

	var __assign$80 = (undefined && undefined.__assign) || function () {
	    __assign$80 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$80.apply(this, arguments);
	};
	var HeadsetFontIcon = React.forwardRef(function HeadsetFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$80({}, props, { ref: ref }), "headset"));
	});

	var __assign$81 = (undefined && undefined.__assign) || function () {
	    __assign$81 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$81.apply(this, arguments);
	};
	var HealingFontIcon = React.forwardRef(function HealingFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$81({}, props, { ref: ref }), "healing"));
	});

	var __assign$82 = (undefined && undefined.__assign) || function () {
	    __assign$82 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$82.apply(this, arguments);
	};
	var HearingFontIcon = React.forwardRef(function HearingFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$82({}, props, { ref: ref }), "hearing"));
	});

	var __assign$83 = (undefined && undefined.__assign) || function () {
	    __assign$83 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$83.apply(this, arguments);
	};
	var HelpOutlineFontIcon = React.forwardRef(function HelpOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$83({}, props, { ref: ref }), "help_outline"));
	});

	var __assign$84 = (undefined && undefined.__assign) || function () {
	    __assign$84 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$84.apply(this, arguments);
	};
	var HelpFontIcon = React.forwardRef(function HelpFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$84({}, props, { ref: ref }), "help"));
	});

	var __assign$85 = (undefined && undefined.__assign) || function () {
	    __assign$85 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$85.apply(this, arguments);
	};
	var HighQualityFontIcon = React.forwardRef(function HighQualityFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$85({}, props, { ref: ref }), "high_quality"));
	});

	var __assign$86 = (undefined && undefined.__assign) || function () {
	    __assign$86 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$86.apply(this, arguments);
	};
	var HighlightOffFontIcon = React.forwardRef(function HighlightOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$86({}, props, { ref: ref }), "highlight_off"));
	});

	var __assign$87 = (undefined && undefined.__assign) || function () {
	    __assign$87 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$87.apply(this, arguments);
	};
	var HighlightFontIcon = React.forwardRef(function HighlightFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$87({}, props, { ref: ref }), "highlight"));
	});

	var __assign$88 = (undefined && undefined.__assign) || function () {
	    __assign$88 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$88.apply(this, arguments);
	};
	var HistoryFontIcon = React.forwardRef(function HistoryFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$88({}, props, { ref: ref }), "history"));
	});

	var __assign$89 = (undefined && undefined.__assign) || function () {
	    __assign$89 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$89.apply(this, arguments);
	};
	var HomeFontIcon = React.forwardRef(function HomeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$89({}, props, { ref: ref }), "home"));
	});

	var __assign$8a = (undefined && undefined.__assign) || function () {
	    __assign$8a = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8a.apply(this, arguments);
	};
	var HotTubFontIcon = React.forwardRef(function HotTubFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8a({}, props, { ref: ref }), "hot_tub"));
	});

	var __assign$8b = (undefined && undefined.__assign) || function () {
	    __assign$8b = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8b.apply(this, arguments);
	};
	var HotelFontIcon = React.forwardRef(function HotelFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8b({}, props, { ref: ref }), "hotel"));
	});

	var __assign$8c = (undefined && undefined.__assign) || function () {
	    __assign$8c = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8c.apply(this, arguments);
	};
	var HourglassEmptyFontIcon = React.forwardRef(function HourglassEmptyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8c({}, props, { ref: ref }), "hourglass_empty"));
	});

	var __assign$8d = (undefined && undefined.__assign) || function () {
	    __assign$8d = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8d.apply(this, arguments);
	};
	var HourglassFullFontIcon = React.forwardRef(function HourglassFullFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8d({}, props, { ref: ref }), "hourglass_full"));
	});

	var __assign$8e = (undefined && undefined.__assign) || function () {
	    __assign$8e = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8e.apply(this, arguments);
	};
	var HttpFontIcon = React.forwardRef(function HttpFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8e({}, props, { ref: ref }), "http"));
	});

	var __assign$8f = (undefined && undefined.__assign) || function () {
	    __assign$8f = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8f.apply(this, arguments);
	};
	var HttpsFontIcon = React.forwardRef(function HttpsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8f({}, props, { ref: ref }), "https"));
	});

	var __assign$8g = (undefined && undefined.__assign) || function () {
	    __assign$8g = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8g.apply(this, arguments);
	};
	var ImageAspectRatioFontIcon = React.forwardRef(function ImageAspectRatioFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8g({}, props, { ref: ref }), "image_aspect_ratio"));
	});

	var __assign$8h = (undefined && undefined.__assign) || function () {
	    __assign$8h = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8h.apply(this, arguments);
	};
	var ImageFontIcon = React.forwardRef(function ImageFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8h({}, props, { ref: ref }), "image"));
	});

	var __assign$8i = (undefined && undefined.__assign) || function () {
	    __assign$8i = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8i.apply(this, arguments);
	};
	var ImportContactsFontIcon = React.forwardRef(function ImportContactsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8i({}, props, { ref: ref }), "import_contacts"));
	});

	var __assign$8j = (undefined && undefined.__assign) || function () {
	    __assign$8j = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8j.apply(this, arguments);
	};
	var ImportExportFontIcon = React.forwardRef(function ImportExportFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8j({}, props, { ref: ref }), "import_export"));
	});

	var __assign$8k = (undefined && undefined.__assign) || function () {
	    __assign$8k = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8k.apply(this, arguments);
	};
	var ImportantDevicesFontIcon = React.forwardRef(function ImportantDevicesFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8k({}, props, { ref: ref }), "important_devices"));
	});

	var __assign$8l = (undefined && undefined.__assign) || function () {
	    __assign$8l = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8l.apply(this, arguments);
	};
	var InboxFontIcon = React.forwardRef(function InboxFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8l({}, props, { ref: ref }), "inbox"));
	});

	var __assign$8m = (undefined && undefined.__assign) || function () {
	    __assign$8m = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8m.apply(this, arguments);
	};
	var IndeterminateCheckBoxFontIcon = React.forwardRef(function IndeterminateCheckBoxFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8m({}, props, { ref: ref }), "indeterminate_check_box"));
	});

	var __assign$8n = (undefined && undefined.__assign) || function () {
	    __assign$8n = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8n.apply(this, arguments);
	};
	var InfoOutlineFontIcon = React.forwardRef(function InfoOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8n({}, props, { ref: ref }), "info_outline"));
	});

	var __assign$8o = (undefined && undefined.__assign) || function () {
	    __assign$8o = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8o.apply(this, arguments);
	};
	var InfoFontIcon = React.forwardRef(function InfoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8o({}, props, { ref: ref }), "info"));
	});

	var __assign$8p = (undefined && undefined.__assign) || function () {
	    __assign$8p = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8p.apply(this, arguments);
	};
	var InputFontIcon = React.forwardRef(function InputFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8p({}, props, { ref: ref }), "input"));
	});

	var __assign$8q = (undefined && undefined.__assign) || function () {
	    __assign$8q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8q.apply(this, arguments);
	};
	var InsertChartFontIcon = React.forwardRef(function InsertChartFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8q({}, props, { ref: ref }), "insert_chart"));
	});

	var __assign$8r = (undefined && undefined.__assign) || function () {
	    __assign$8r = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8r.apply(this, arguments);
	};
	var InsertCommentFontIcon = React.forwardRef(function InsertCommentFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8r({}, props, { ref: ref }), "insert_comment"));
	});

	var __assign$8s = (undefined && undefined.__assign) || function () {
	    __assign$8s = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8s.apply(this, arguments);
	};
	var InsertDriveFileFontIcon = React.forwardRef(function InsertDriveFileFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8s({}, props, { ref: ref }), "insert_drive_file"));
	});

	var __assign$8t = (undefined && undefined.__assign) || function () {
	    __assign$8t = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8t.apply(this, arguments);
	};
	var InsertEmoticonFontIcon = React.forwardRef(function InsertEmoticonFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8t({}, props, { ref: ref }), "insert_emoticon"));
	});

	var __assign$8u = (undefined && undefined.__assign) || function () {
	    __assign$8u = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8u.apply(this, arguments);
	};
	var InsertInvitationFontIcon = React.forwardRef(function InsertInvitationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8u({}, props, { ref: ref }), "insert_invitation"));
	});

	var __assign$8v = (undefined && undefined.__assign) || function () {
	    __assign$8v = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8v.apply(this, arguments);
	};
	var InsertLinkFontIcon = React.forwardRef(function InsertLinkFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8v({}, props, { ref: ref }), "insert_link"));
	});

	var __assign$8w = (undefined && undefined.__assign) || function () {
	    __assign$8w = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8w.apply(this, arguments);
	};
	var InsertPhotoFontIcon = React.forwardRef(function InsertPhotoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8w({}, props, { ref: ref }), "insert_photo"));
	});

	var __assign$8x = (undefined && undefined.__assign) || function () {
	    __assign$8x = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8x.apply(this, arguments);
	};
	var InvertColorsOffFontIcon = React.forwardRef(function InvertColorsOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8x({}, props, { ref: ref }), "invert_colors_off"));
	});

	var __assign$8y = (undefined && undefined.__assign) || function () {
	    __assign$8y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8y.apply(this, arguments);
	};
	var InvertColorsFontIcon = React.forwardRef(function InvertColorsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8y({}, props, { ref: ref }), "invert_colors"));
	});

	var __assign$8z = (undefined && undefined.__assign) || function () {
	    __assign$8z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8z.apply(this, arguments);
	};
	var IsoFontIcon = React.forwardRef(function IsoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8z({}, props, { ref: ref }), "iso"));
	});

	var __assign$8A = (undefined && undefined.__assign) || function () {
	    __assign$8A = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8A.apply(this, arguments);
	};
	var KeyboardArrowDownFontIcon = React.forwardRef(function KeyboardArrowDownFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8A({}, props, { ref: ref }), "keyboard_arrow_down"));
	});

	var __assign$8B = (undefined && undefined.__assign) || function () {
	    __assign$8B = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8B.apply(this, arguments);
	};
	var KeyboardArrowLeftFontIcon = React.forwardRef(function KeyboardArrowLeftFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8B({}, props, { ref: ref }), "keyboard_arrow_left"));
	});

	var __assign$8C = (undefined && undefined.__assign) || function () {
	    __assign$8C = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8C.apply(this, arguments);
	};
	var KeyboardArrowRightFontIcon = React.forwardRef(function KeyboardArrowRightFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8C({}, props, { ref: ref }), "keyboard_arrow_right"));
	});

	var __assign$8D = (undefined && undefined.__assign) || function () {
	    __assign$8D = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8D.apply(this, arguments);
	};
	var KeyboardArrowUpFontIcon = React.forwardRef(function KeyboardArrowUpFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8D({}, props, { ref: ref }), "keyboard_arrow_up"));
	});

	var __assign$8E = (undefined && undefined.__assign) || function () {
	    __assign$8E = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8E.apply(this, arguments);
	};
	var KeyboardBackspaceFontIcon = React.forwardRef(function KeyboardBackspaceFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8E({}, props, { ref: ref }), "keyboard_backspace"));
	});

	var __assign$8F = (undefined && undefined.__assign) || function () {
	    __assign$8F = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8F.apply(this, arguments);
	};
	var KeyboardCapslockFontIcon = React.forwardRef(function KeyboardCapslockFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8F({}, props, { ref: ref }), "keyboard_capslock"));
	});

	var __assign$8G = (undefined && undefined.__assign) || function () {
	    __assign$8G = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8G.apply(this, arguments);
	};
	var KeyboardHideFontIcon = React.forwardRef(function KeyboardHideFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8G({}, props, { ref: ref }), "keyboard_hide"));
	});

	var __assign$8H = (undefined && undefined.__assign) || function () {
	    __assign$8H = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8H.apply(this, arguments);
	};
	var KeyboardReturnFontIcon = React.forwardRef(function KeyboardReturnFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8H({}, props, { ref: ref }), "keyboard_return"));
	});

	var __assign$8I = (undefined && undefined.__assign) || function () {
	    __assign$8I = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8I.apply(this, arguments);
	};
	var KeyboardTabFontIcon = React.forwardRef(function KeyboardTabFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8I({}, props, { ref: ref }), "keyboard_tab"));
	});

	var __assign$8J = (undefined && undefined.__assign) || function () {
	    __assign$8J = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8J.apply(this, arguments);
	};
	var KeyboardVoiceFontIcon = React.forwardRef(function KeyboardVoiceFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8J({}, props, { ref: ref }), "keyboard_voice"));
	});

	var __assign$8K = (undefined && undefined.__assign) || function () {
	    __assign$8K = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8K.apply(this, arguments);
	};
	var KeyboardFontIcon = React.forwardRef(function KeyboardFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8K({}, props, { ref: ref }), "keyboard"));
	});

	var __assign$8L = (undefined && undefined.__assign) || function () {
	    __assign$8L = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8L.apply(this, arguments);
	};
	var KitchenFontIcon = React.forwardRef(function KitchenFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8L({}, props, { ref: ref }), "kitchen"));
	});

	var __assign$8M = (undefined && undefined.__assign) || function () {
	    __assign$8M = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8M.apply(this, arguments);
	};
	var LabelOutlineFontIcon = React.forwardRef(function LabelOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8M({}, props, { ref: ref }), "label_outline"));
	});

	var __assign$8N = (undefined && undefined.__assign) || function () {
	    __assign$8N = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8N.apply(this, arguments);
	};
	var LabelFontIcon = React.forwardRef(function LabelFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8N({}, props, { ref: ref }), "label"));
	});

	var __assign$8O = (undefined && undefined.__assign) || function () {
	    __assign$8O = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8O.apply(this, arguments);
	};
	var LandscapeFontIcon = React.forwardRef(function LandscapeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8O({}, props, { ref: ref }), "landscape"));
	});

	var __assign$8P = (undefined && undefined.__assign) || function () {
	    __assign$8P = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8P.apply(this, arguments);
	};
	var LanguageFontIcon = React.forwardRef(function LanguageFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8P({}, props, { ref: ref }), "language"));
	});

	var __assign$8Q = (undefined && undefined.__assign) || function () {
	    __assign$8Q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8Q.apply(this, arguments);
	};
	var LaptopChromebookFontIcon = React.forwardRef(function LaptopChromebookFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8Q({}, props, { ref: ref }), "laptop_chromebook"));
	});

	var __assign$8R = (undefined && undefined.__assign) || function () {
	    __assign$8R = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8R.apply(this, arguments);
	};
	var LaptopMacFontIcon = React.forwardRef(function LaptopMacFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8R({}, props, { ref: ref }), "laptop_mac"));
	});

	var __assign$8S = (undefined && undefined.__assign) || function () {
	    __assign$8S = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8S.apply(this, arguments);
	};
	var LaptopWindowsFontIcon = React.forwardRef(function LaptopWindowsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8S({}, props, { ref: ref }), "laptop_windows"));
	});

	var __assign$8T = (undefined && undefined.__assign) || function () {
	    __assign$8T = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8T.apply(this, arguments);
	};
	var LaptopFontIcon = React.forwardRef(function LaptopFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8T({}, props, { ref: ref }), "laptop"));
	});

	var __assign$8U = (undefined && undefined.__assign) || function () {
	    __assign$8U = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8U.apply(this, arguments);
	};
	var LastPageFontIcon = React.forwardRef(function LastPageFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8U({}, props, { ref: ref }), "last_page"));
	});

	var __assign$8V = (undefined && undefined.__assign) || function () {
	    __assign$8V = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8V.apply(this, arguments);
	};
	var LaunchFontIcon = React.forwardRef(function LaunchFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8V({}, props, { ref: ref }), "launch"));
	});

	var __assign$8W = (undefined && undefined.__assign) || function () {
	    __assign$8W = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8W.apply(this, arguments);
	};
	var LayersClearFontIcon = React.forwardRef(function LayersClearFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8W({}, props, { ref: ref }), "layers_clear"));
	});

	var __assign$8X = (undefined && undefined.__assign) || function () {
	    __assign$8X = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8X.apply(this, arguments);
	};
	var LayersFontIcon = React.forwardRef(function LayersFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8X({}, props, { ref: ref }), "layers"));
	});

	var __assign$8Y = (undefined && undefined.__assign) || function () {
	    __assign$8Y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8Y.apply(this, arguments);
	};
	var LeakAddFontIcon = React.forwardRef(function LeakAddFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8Y({}, props, { ref: ref }), "leak_add"));
	});

	var __assign$8Z = (undefined && undefined.__assign) || function () {
	    __assign$8Z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8Z.apply(this, arguments);
	};
	var LeakRemoveFontIcon = React.forwardRef(function LeakRemoveFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8Z({}, props, { ref: ref }), "leak_remove"));
	});

	var __assign$8_ = (undefined && undefined.__assign) || function () {
	    __assign$8_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8_.apply(this, arguments);
	};
	var LensFontIcon = React.forwardRef(function LensFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8_({}, props, { ref: ref }), "lens"));
	});

	var __assign$8$ = (undefined && undefined.__assign) || function () {
	    __assign$8$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$8$.apply(this, arguments);
	};
	var LibraryAddFontIcon = React.forwardRef(function LibraryAddFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$8$({}, props, { ref: ref }), "library_add"));
	});

	var __assign$90 = (undefined && undefined.__assign) || function () {
	    __assign$90 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$90.apply(this, arguments);
	};
	var LibraryBooksFontIcon = React.forwardRef(function LibraryBooksFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$90({}, props, { ref: ref }), "library_books"));
	});

	var __assign$91 = (undefined && undefined.__assign) || function () {
	    __assign$91 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$91.apply(this, arguments);
	};
	var LibraryMusicFontIcon = React.forwardRef(function LibraryMusicFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$91({}, props, { ref: ref }), "library_music"));
	});

	var __assign$92 = (undefined && undefined.__assign) || function () {
	    __assign$92 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$92.apply(this, arguments);
	};
	var LightbulbOutlineFontIcon = React.forwardRef(function LightbulbOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$92({}, props, { ref: ref }), "lightbulb_outline"));
	});

	var __assign$93 = (undefined && undefined.__assign) || function () {
	    __assign$93 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$93.apply(this, arguments);
	};
	var LineStyleFontIcon = React.forwardRef(function LineStyleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$93({}, props, { ref: ref }), "line_style"));
	});

	var __assign$94 = (undefined && undefined.__assign) || function () {
	    __assign$94 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$94.apply(this, arguments);
	};
	var LineWeightFontIcon = React.forwardRef(function LineWeightFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$94({}, props, { ref: ref }), "line_weight"));
	});

	var __assign$95 = (undefined && undefined.__assign) || function () {
	    __assign$95 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$95.apply(this, arguments);
	};
	var LinearScaleFontIcon = React.forwardRef(function LinearScaleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$95({}, props, { ref: ref }), "linear_scale"));
	});

	var __assign$96 = (undefined && undefined.__assign) || function () {
	    __assign$96 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$96.apply(this, arguments);
	};
	var LinkFontIcon = React.forwardRef(function LinkFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$96({}, props, { ref: ref }), "link"));
	});

	var __assign$97 = (undefined && undefined.__assign) || function () {
	    __assign$97 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$97.apply(this, arguments);
	};
	var LinkedCameraFontIcon = React.forwardRef(function LinkedCameraFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$97({}, props, { ref: ref }), "linked_camera"));
	});

	var __assign$98 = (undefined && undefined.__assign) || function () {
	    __assign$98 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$98.apply(this, arguments);
	};
	var ListFontIcon = React.forwardRef(function ListFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$98({}, props, { ref: ref }), "list"));
	});

	var __assign$99 = (undefined && undefined.__assign) || function () {
	    __assign$99 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$99.apply(this, arguments);
	};
	var LiveHelpFontIcon = React.forwardRef(function LiveHelpFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$99({}, props, { ref: ref }), "live_help"));
	});

	var __assign$9a = (undefined && undefined.__assign) || function () {
	    __assign$9a = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9a.apply(this, arguments);
	};
	var LiveTvFontIcon = React.forwardRef(function LiveTvFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9a({}, props, { ref: ref }), "live_tv"));
	});

	var __assign$9b = (undefined && undefined.__assign) || function () {
	    __assign$9b = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9b.apply(this, arguments);
	};
	var LocalActivityFontIcon = React.forwardRef(function LocalActivityFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9b({}, props, { ref: ref }), "local_activity"));
	});

	var __assign$9c = (undefined && undefined.__assign) || function () {
	    __assign$9c = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9c.apply(this, arguments);
	};
	var LocalAirportFontIcon = React.forwardRef(function LocalAirportFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9c({}, props, { ref: ref }), "local_airport"));
	});

	var __assign$9d = (undefined && undefined.__assign) || function () {
	    __assign$9d = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9d.apply(this, arguments);
	};
	var LocalAtmFontIcon = React.forwardRef(function LocalAtmFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9d({}, props, { ref: ref }), "local_atm"));
	});

	var __assign$9e = (undefined && undefined.__assign) || function () {
	    __assign$9e = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9e.apply(this, arguments);
	};
	var LocalBarFontIcon = React.forwardRef(function LocalBarFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9e({}, props, { ref: ref }), "local_bar"));
	});

	var __assign$9f = (undefined && undefined.__assign) || function () {
	    __assign$9f = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9f.apply(this, arguments);
	};
	var LocalCafeFontIcon = React.forwardRef(function LocalCafeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9f({}, props, { ref: ref }), "local_cafe"));
	});

	var __assign$9g = (undefined && undefined.__assign) || function () {
	    __assign$9g = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9g.apply(this, arguments);
	};
	var LocalCarWashFontIcon = React.forwardRef(function LocalCarWashFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9g({}, props, { ref: ref }), "local_car_wash"));
	});

	var __assign$9h = (undefined && undefined.__assign) || function () {
	    __assign$9h = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9h.apply(this, arguments);
	};
	var LocalConvenienceStoreFontIcon = React.forwardRef(function LocalConvenienceStoreFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9h({}, props, { ref: ref }), "local_convenience_store"));
	});

	var __assign$9i = (undefined && undefined.__assign) || function () {
	    __assign$9i = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9i.apply(this, arguments);
	};
	var LocalDiningFontIcon = React.forwardRef(function LocalDiningFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9i({}, props, { ref: ref }), "local_dining"));
	});

	var __assign$9j = (undefined && undefined.__assign) || function () {
	    __assign$9j = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9j.apply(this, arguments);
	};
	var LocalDrinkFontIcon = React.forwardRef(function LocalDrinkFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9j({}, props, { ref: ref }), "local_drink"));
	});

	var __assign$9k = (undefined && undefined.__assign) || function () {
	    __assign$9k = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9k.apply(this, arguments);
	};
	var LocalFloristFontIcon = React.forwardRef(function LocalFloristFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9k({}, props, { ref: ref }), "local_florist"));
	});

	var __assign$9l = (undefined && undefined.__assign) || function () {
	    __assign$9l = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9l.apply(this, arguments);
	};
	var LocalGasStationFontIcon = React.forwardRef(function LocalGasStationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9l({}, props, { ref: ref }), "local_gas_station"));
	});

	var __assign$9m = (undefined && undefined.__assign) || function () {
	    __assign$9m = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9m.apply(this, arguments);
	};
	var LocalGroceryStoreFontIcon = React.forwardRef(function LocalGroceryStoreFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9m({}, props, { ref: ref }), "local_grocery_store"));
	});

	var __assign$9n = (undefined && undefined.__assign) || function () {
	    __assign$9n = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9n.apply(this, arguments);
	};
	var LocalHospitalFontIcon = React.forwardRef(function LocalHospitalFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9n({}, props, { ref: ref }), "local_hospital"));
	});

	var __assign$9o = (undefined && undefined.__assign) || function () {
	    __assign$9o = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9o.apply(this, arguments);
	};
	var LocalHotelFontIcon = React.forwardRef(function LocalHotelFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9o({}, props, { ref: ref }), "local_hotel"));
	});

	var __assign$9p = (undefined && undefined.__assign) || function () {
	    __assign$9p = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9p.apply(this, arguments);
	};
	var LocalLaundryServiceFontIcon = React.forwardRef(function LocalLaundryServiceFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9p({}, props, { ref: ref }), "local_laundry_service"));
	});

	var __assign$9q = (undefined && undefined.__assign) || function () {
	    __assign$9q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9q.apply(this, arguments);
	};
	var LocalLibraryFontIcon = React.forwardRef(function LocalLibraryFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9q({}, props, { ref: ref }), "local_library"));
	});

	var __assign$9r = (undefined && undefined.__assign) || function () {
	    __assign$9r = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9r.apply(this, arguments);
	};
	var LocalMallFontIcon = React.forwardRef(function LocalMallFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9r({}, props, { ref: ref }), "local_mall"));
	});

	var __assign$9s = (undefined && undefined.__assign) || function () {
	    __assign$9s = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9s.apply(this, arguments);
	};
	var LocalMoviesFontIcon = React.forwardRef(function LocalMoviesFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9s({}, props, { ref: ref }), "local_movies"));
	});

	var __assign$9t = (undefined && undefined.__assign) || function () {
	    __assign$9t = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9t.apply(this, arguments);
	};
	var LocalOfferFontIcon = React.forwardRef(function LocalOfferFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9t({}, props, { ref: ref }), "local_offer"));
	});

	var __assign$9u = (undefined && undefined.__assign) || function () {
	    __assign$9u = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9u.apply(this, arguments);
	};
	var LocalParkingFontIcon = React.forwardRef(function LocalParkingFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9u({}, props, { ref: ref }), "local_parking"));
	});

	var __assign$9v = (undefined && undefined.__assign) || function () {
	    __assign$9v = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9v.apply(this, arguments);
	};
	var LocalPharmacyFontIcon = React.forwardRef(function LocalPharmacyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9v({}, props, { ref: ref }), "local_pharmacy"));
	});

	var __assign$9w = (undefined && undefined.__assign) || function () {
	    __assign$9w = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9w.apply(this, arguments);
	};
	var LocalPhoneFontIcon = React.forwardRef(function LocalPhoneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9w({}, props, { ref: ref }), "local_phone"));
	});

	var __assign$9x = (undefined && undefined.__assign) || function () {
	    __assign$9x = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9x.apply(this, arguments);
	};
	var LocalPizzaFontIcon = React.forwardRef(function LocalPizzaFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9x({}, props, { ref: ref }), "local_pizza"));
	});

	var __assign$9y = (undefined && undefined.__assign) || function () {
	    __assign$9y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9y.apply(this, arguments);
	};
	var LocalPlayFontIcon = React.forwardRef(function LocalPlayFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9y({}, props, { ref: ref }), "local_play"));
	});

	var __assign$9z = (undefined && undefined.__assign) || function () {
	    __assign$9z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9z.apply(this, arguments);
	};
	var LocalPostOfficeFontIcon = React.forwardRef(function LocalPostOfficeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9z({}, props, { ref: ref }), "local_post_office"));
	});

	var __assign$9A = (undefined && undefined.__assign) || function () {
	    __assign$9A = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9A.apply(this, arguments);
	};
	var LocalPrintshopFontIcon = React.forwardRef(function LocalPrintshopFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9A({}, props, { ref: ref }), "local_printshop"));
	});

	var __assign$9B = (undefined && undefined.__assign) || function () {
	    __assign$9B = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9B.apply(this, arguments);
	};
	var LocalSeeFontIcon = React.forwardRef(function LocalSeeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9B({}, props, { ref: ref }), "local_see"));
	});

	var __assign$9C = (undefined && undefined.__assign) || function () {
	    __assign$9C = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9C.apply(this, arguments);
	};
	var LocalShippingFontIcon = React.forwardRef(function LocalShippingFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9C({}, props, { ref: ref }), "local_shipping"));
	});

	var __assign$9D = (undefined && undefined.__assign) || function () {
	    __assign$9D = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9D.apply(this, arguments);
	};
	var LocalTaxiFontIcon = React.forwardRef(function LocalTaxiFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9D({}, props, { ref: ref }), "local_taxi"));
	});

	var __assign$9E = (undefined && undefined.__assign) || function () {
	    __assign$9E = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9E.apply(this, arguments);
	};
	var LocationCityFontIcon = React.forwardRef(function LocationCityFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9E({}, props, { ref: ref }), "location_city"));
	});

	var __assign$9F = (undefined && undefined.__assign) || function () {
	    __assign$9F = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9F.apply(this, arguments);
	};
	var LocationDisabledFontIcon = React.forwardRef(function LocationDisabledFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9F({}, props, { ref: ref }), "location_disabled"));
	});

	var __assign$9G = (undefined && undefined.__assign) || function () {
	    __assign$9G = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9G.apply(this, arguments);
	};
	var LocationOffFontIcon = React.forwardRef(function LocationOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9G({}, props, { ref: ref }), "location_off"));
	});

	var __assign$9H = (undefined && undefined.__assign) || function () {
	    __assign$9H = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9H.apply(this, arguments);
	};
	var LocationOnFontIcon = React.forwardRef(function LocationOnFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9H({}, props, { ref: ref }), "location_on"));
	});

	var __assign$9I = (undefined && undefined.__assign) || function () {
	    __assign$9I = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9I.apply(this, arguments);
	};
	var LocationSearchingFontIcon = React.forwardRef(function LocationSearchingFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9I({}, props, { ref: ref }), "location_searching"));
	});

	var __assign$9J = (undefined && undefined.__assign) || function () {
	    __assign$9J = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9J.apply(this, arguments);
	};
	var LockOpenFontIcon = React.forwardRef(function LockOpenFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9J({}, props, { ref: ref }), "lock_open"));
	});

	var __assign$9K = (undefined && undefined.__assign) || function () {
	    __assign$9K = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9K.apply(this, arguments);
	};
	var LockOutlineFontIcon = React.forwardRef(function LockOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9K({}, props, { ref: ref }), "lock_outline"));
	});

	var __assign$9L = (undefined && undefined.__assign) || function () {
	    __assign$9L = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9L.apply(this, arguments);
	};
	var LockFontIcon = React.forwardRef(function LockFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9L({}, props, { ref: ref }), "lock"));
	});

	var __assign$9M = (undefined && undefined.__assign) || function () {
	    __assign$9M = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9M.apply(this, arguments);
	};
	var Looks3FontIcon = React.forwardRef(function Looks3FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9M({}, props, { ref: ref }), "looks_3"));
	});

	var __assign$9N = (undefined && undefined.__assign) || function () {
	    __assign$9N = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9N.apply(this, arguments);
	};
	var Looks4FontIcon = React.forwardRef(function Looks4FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9N({}, props, { ref: ref }), "looks_4"));
	});

	var __assign$9O = (undefined && undefined.__assign) || function () {
	    __assign$9O = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9O.apply(this, arguments);
	};
	var Looks5FontIcon = React.forwardRef(function Looks5FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9O({}, props, { ref: ref }), "looks_5"));
	});

	var __assign$9P = (undefined && undefined.__assign) || function () {
	    __assign$9P = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9P.apply(this, arguments);
	};
	var Looks6FontIcon = React.forwardRef(function Looks6FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9P({}, props, { ref: ref }), "looks_6"));
	});

	var __assign$9Q = (undefined && undefined.__assign) || function () {
	    __assign$9Q = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9Q.apply(this, arguments);
	};
	var LooksOneFontIcon = React.forwardRef(function LooksOneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9Q({}, props, { ref: ref }), "looks_one"));
	});

	var __assign$9R = (undefined && undefined.__assign) || function () {
	    __assign$9R = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9R.apply(this, arguments);
	};
	var LooksTwoFontIcon = React.forwardRef(function LooksTwoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9R({}, props, { ref: ref }), "looks_two"));
	});

	var __assign$9S = (undefined && undefined.__assign) || function () {
	    __assign$9S = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9S.apply(this, arguments);
	};
	var LooksFontIcon = React.forwardRef(function LooksFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9S({}, props, { ref: ref }), "looks"));
	});

	var __assign$9T = (undefined && undefined.__assign) || function () {
	    __assign$9T = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9T.apply(this, arguments);
	};
	var LoopFontIcon = React.forwardRef(function LoopFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9T({}, props, { ref: ref }), "loop"));
	});

	var __assign$9U = (undefined && undefined.__assign) || function () {
	    __assign$9U = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9U.apply(this, arguments);
	};
	var LoupeFontIcon = React.forwardRef(function LoupeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9U({}, props, { ref: ref }), "loupe"));
	});

	var __assign$9V = (undefined && undefined.__assign) || function () {
	    __assign$9V = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9V.apply(this, arguments);
	};
	var LowPriorityFontIcon = React.forwardRef(function LowPriorityFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9V({}, props, { ref: ref }), "low_priority"));
	});

	var __assign$9W = (undefined && undefined.__assign) || function () {
	    __assign$9W = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9W.apply(this, arguments);
	};
	var LoyaltyFontIcon = React.forwardRef(function LoyaltyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9W({}, props, { ref: ref }), "loyalty"));
	});

	var __assign$9X = (undefined && undefined.__assign) || function () {
	    __assign$9X = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9X.apply(this, arguments);
	};
	var MailOutlineFontIcon = React.forwardRef(function MailOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9X({}, props, { ref: ref }), "mail_outline"));
	});

	var __assign$9Y = (undefined && undefined.__assign) || function () {
	    __assign$9Y = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9Y.apply(this, arguments);
	};
	var MailFontIcon = React.forwardRef(function MailFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9Y({}, props, { ref: ref }), "mail"));
	});

	var __assign$9Z = (undefined && undefined.__assign) || function () {
	    __assign$9Z = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9Z.apply(this, arguments);
	};
	var MapFontIcon = React.forwardRef(function MapFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9Z({}, props, { ref: ref }), "map"));
	});

	var __assign$9_ = (undefined && undefined.__assign) || function () {
	    __assign$9_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9_.apply(this, arguments);
	};
	var MarkunreadMailboxFontIcon = React.forwardRef(function MarkunreadMailboxFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9_({}, props, { ref: ref }), "markunread_mailbox"));
	});

	var __assign$9$ = (undefined && undefined.__assign) || function () {
	    __assign$9$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$9$.apply(this, arguments);
	};
	var MarkunreadFontIcon = React.forwardRef(function MarkunreadFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$9$({}, props, { ref: ref }), "markunread"));
	});

	var __assign$a0 = (undefined && undefined.__assign) || function () {
	    __assign$a0 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a0.apply(this, arguments);
	};
	var MemoryFontIcon = React.forwardRef(function MemoryFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$a0({}, props, { ref: ref }), "memory"));
	});

	var __assign$a1 = (undefined && undefined.__assign) || function () {
	    __assign$a1 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a1.apply(this, arguments);
	};
	var MenuFontIcon = React.forwardRef(function MenuFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$a1({}, props, { ref: ref }), "menu"));
	});

	var __assign$a2 = (undefined && undefined.__assign) || function () {
	    __assign$a2 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a2.apply(this, arguments);
	};
	var MergeTypeFontIcon = React.forwardRef(function MergeTypeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$a2({}, props, { ref: ref }), "merge_type"));
	});

	var __assign$a3 = (undefined && undefined.__assign) || function () {
	    __assign$a3 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a3.apply(this, arguments);
	};
	var MessageFontIcon = React.forwardRef(function MessageFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$a3({}, props, { ref: ref }), "message"));
	});

	var __assign$a4 = (undefined && undefined.__assign) || function () {
	    __assign$a4 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a4.apply(this, arguments);
	};
	var MicNoneFontIcon = React.forwardRef(function MicNoneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$a4({}, props, { ref: ref }), "mic_none"));
	});

	var __assign$a5 = (undefined && undefined.__assign) || function () {
	    __assign$a5 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a5.apply(this, arguments);
	};
	var MicOffFontIcon = React.forwardRef(function MicOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$a5({}, props, { ref: ref }), "mic_off"));
	});

	var __assign$a6 = (undefined && undefined.__assign) || function () {
	    __assign$a6 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a6.apply(this, arguments);
	};
	var MicFontIcon = React.forwardRef(function MicFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$a6({}, props, { ref: ref }), "mic"));
	});

	var __assign$a7 = (undefined && undefined.__assign) || function () {
	    __assign$a7 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a7.apply(this, arguments);
	};
	var MmsFontIcon = React.forwardRef(function MmsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$a7({}, props, { ref: ref }), "mms"));
	});

	var __assign$a8 = (undefined && undefined.__assign) || function () {
	    __assign$a8 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a8.apply(this, arguments);
	};
	var ModeCommentFontIcon = React.forwardRef(function ModeCommentFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$a8({}, props, { ref: ref }), "mode_comment"));
	});

	var __assign$a9 = (undefined && undefined.__assign) || function () {
	    __assign$a9 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a9.apply(this, arguments);
	};
	var ModeEditFontIcon = React.forwardRef(function ModeEditFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$a9({}, props, { ref: ref }), "mode_edit"));
	});

	var __assign$aa = (undefined && undefined.__assign) || function () {
	    __assign$aa = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aa.apply(this, arguments);
	};
	var MonetizationOnFontIcon = React.forwardRef(function MonetizationOnFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aa({}, props, { ref: ref }), "monetization_on"));
	});

	var __assign$ab = (undefined && undefined.__assign) || function () {
	    __assign$ab = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ab.apply(this, arguments);
	};
	var MoneyOffFontIcon = React.forwardRef(function MoneyOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ab({}, props, { ref: ref }), "money_off"));
	});

	var __assign$ac = (undefined && undefined.__assign) || function () {
	    __assign$ac = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ac.apply(this, arguments);
	};
	var MonochromePhotosFontIcon = React.forwardRef(function MonochromePhotosFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ac({}, props, { ref: ref }), "monochrome_photos"));
	});

	var __assign$ad = (undefined && undefined.__assign) || function () {
	    __assign$ad = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ad.apply(this, arguments);
	};
	var MoodBadFontIcon = React.forwardRef(function MoodBadFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ad({}, props, { ref: ref }), "mood_bad"));
	});

	var __assign$ae = (undefined && undefined.__assign) || function () {
	    __assign$ae = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ae.apply(this, arguments);
	};
	var MoodFontIcon = React.forwardRef(function MoodFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ae({}, props, { ref: ref }), "mood"));
	});

	var __assign$af = (undefined && undefined.__assign) || function () {
	    __assign$af = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$af.apply(this, arguments);
	};
	var MoreHorizFontIcon = React.forwardRef(function MoreHorizFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$af({}, props, { ref: ref }), "more_horiz"));
	});

	var __assign$ag = (undefined && undefined.__assign) || function () {
	    __assign$ag = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ag.apply(this, arguments);
	};
	var MoreVertFontIcon = React.forwardRef(function MoreVertFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ag({}, props, { ref: ref }), "more_vert"));
	});

	var __assign$ah = (undefined && undefined.__assign) || function () {
	    __assign$ah = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ah.apply(this, arguments);
	};
	var MoreFontIcon = React.forwardRef(function MoreFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ah({}, props, { ref: ref }), "more"));
	});

	var __assign$ai = (undefined && undefined.__assign) || function () {
	    __assign$ai = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ai.apply(this, arguments);
	};
	var MotorcycleFontIcon = React.forwardRef(function MotorcycleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ai({}, props, { ref: ref }), "motorcycle"));
	});

	var __assign$aj = (undefined && undefined.__assign) || function () {
	    __assign$aj = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aj.apply(this, arguments);
	};
	var MouseFontIcon = React.forwardRef(function MouseFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aj({}, props, { ref: ref }), "mouse"));
	});

	var __assign$ak = (undefined && undefined.__assign) || function () {
	    __assign$ak = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ak.apply(this, arguments);
	};
	var MoveToInboxFontIcon = React.forwardRef(function MoveToInboxFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ak({}, props, { ref: ref }), "move_to_inbox"));
	});

	var __assign$al = (undefined && undefined.__assign) || function () {
	    __assign$al = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$al.apply(this, arguments);
	};
	var MovieCreationFontIcon = React.forwardRef(function MovieCreationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$al({}, props, { ref: ref }), "movie_creation"));
	});

	var __assign$am = (undefined && undefined.__assign) || function () {
	    __assign$am = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$am.apply(this, arguments);
	};
	var MovieFilterFontIcon = React.forwardRef(function MovieFilterFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$am({}, props, { ref: ref }), "movie_filter"));
	});

	var __assign$an = (undefined && undefined.__assign) || function () {
	    __assign$an = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$an.apply(this, arguments);
	};
	var MovieFontIcon = React.forwardRef(function MovieFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$an({}, props, { ref: ref }), "movie"));
	});

	var __assign$ao = (undefined && undefined.__assign) || function () {
	    __assign$ao = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ao.apply(this, arguments);
	};
	var MultilineChartFontIcon = React.forwardRef(function MultilineChartFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ao({}, props, { ref: ref }), "multiline_chart"));
	});

	var __assign$ap = (undefined && undefined.__assign) || function () {
	    __assign$ap = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ap.apply(this, arguments);
	};
	var MusicNoteFontIcon = React.forwardRef(function MusicNoteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ap({}, props, { ref: ref }), "music_note"));
	});

	var __assign$aq = (undefined && undefined.__assign) || function () {
	    __assign$aq = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aq.apply(this, arguments);
	};
	var MusicVideoFontIcon = React.forwardRef(function MusicVideoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aq({}, props, { ref: ref }), "music_video"));
	});

	var __assign$ar = (undefined && undefined.__assign) || function () {
	    __assign$ar = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ar.apply(this, arguments);
	};
	var MyLocationFontIcon = React.forwardRef(function MyLocationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ar({}, props, { ref: ref }), "my_location"));
	});

	var __assign$as = (undefined && undefined.__assign) || function () {
	    __assign$as = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$as.apply(this, arguments);
	};
	var NaturePeopleFontIcon = React.forwardRef(function NaturePeopleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$as({}, props, { ref: ref }), "nature_people"));
	});

	var __assign$at = (undefined && undefined.__assign) || function () {
	    __assign$at = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$at.apply(this, arguments);
	};
	var NatureFontIcon = React.forwardRef(function NatureFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$at({}, props, { ref: ref }), "nature"));
	});

	var __assign$au = (undefined && undefined.__assign) || function () {
	    __assign$au = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$au.apply(this, arguments);
	};
	var NavigateBeforeFontIcon = React.forwardRef(function NavigateBeforeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$au({}, props, { ref: ref }), "navigate_before"));
	});

	var __assign$av = (undefined && undefined.__assign) || function () {
	    __assign$av = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$av.apply(this, arguments);
	};
	var NavigateNextFontIcon = React.forwardRef(function NavigateNextFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$av({}, props, { ref: ref }), "navigate_next"));
	});

	var __assign$aw = (undefined && undefined.__assign) || function () {
	    __assign$aw = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aw.apply(this, arguments);
	};
	var NavigationFontIcon = React.forwardRef(function NavigationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aw({}, props, { ref: ref }), "navigation"));
	});

	var __assign$ax = (undefined && undefined.__assign) || function () {
	    __assign$ax = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ax.apply(this, arguments);
	};
	var NearMeFontIcon = React.forwardRef(function NearMeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ax({}, props, { ref: ref }), "near_me"));
	});

	var __assign$ay = (undefined && undefined.__assign) || function () {
	    __assign$ay = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ay.apply(this, arguments);
	};
	var NetworkCellFontIcon = React.forwardRef(function NetworkCellFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ay({}, props, { ref: ref }), "network_cell"));
	});

	var __assign$az = (undefined && undefined.__assign) || function () {
	    __assign$az = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$az.apply(this, arguments);
	};
	var NetworkCheckFontIcon = React.forwardRef(function NetworkCheckFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$az({}, props, { ref: ref }), "network_check"));
	});

	var __assign$aA = (undefined && undefined.__assign) || function () {
	    __assign$aA = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aA.apply(this, arguments);
	};
	var NetworkLockedFontIcon = React.forwardRef(function NetworkLockedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aA({}, props, { ref: ref }), "network_locked"));
	});

	var __assign$aB = (undefined && undefined.__assign) || function () {
	    __assign$aB = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aB.apply(this, arguments);
	};
	var NetworkWifiFontIcon = React.forwardRef(function NetworkWifiFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aB({}, props, { ref: ref }), "network_wifi"));
	});

	var __assign$aC = (undefined && undefined.__assign) || function () {
	    __assign$aC = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aC.apply(this, arguments);
	};
	var NewReleasesFontIcon = React.forwardRef(function NewReleasesFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aC({}, props, { ref: ref }), "new_releases"));
	});

	var __assign$aD = (undefined && undefined.__assign) || function () {
	    __assign$aD = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aD.apply(this, arguments);
	};
	var NextWeekFontIcon = React.forwardRef(function NextWeekFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aD({}, props, { ref: ref }), "next_week"));
	});

	var __assign$aE = (undefined && undefined.__assign) || function () {
	    __assign$aE = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aE.apply(this, arguments);
	};
	var NfcFontIcon = React.forwardRef(function NfcFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aE({}, props, { ref: ref }), "nfc"));
	});

	var __assign$aF = (undefined && undefined.__assign) || function () {
	    __assign$aF = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aF.apply(this, arguments);
	};
	var NoEncryptionFontIcon = React.forwardRef(function NoEncryptionFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aF({}, props, { ref: ref }), "no_encryption"));
	});

	var __assign$aG = (undefined && undefined.__assign) || function () {
	    __assign$aG = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aG.apply(this, arguments);
	};
	var NoSimFontIcon = React.forwardRef(function NoSimFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aG({}, props, { ref: ref }), "no_sim"));
	});

	var __assign$aH = (undefined && undefined.__assign) || function () {
	    __assign$aH = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aH.apply(this, arguments);
	};
	var NotInterestedFontIcon = React.forwardRef(function NotInterestedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aH({}, props, { ref: ref }), "not_interested"));
	});

	var __assign$aI = (undefined && undefined.__assign) || function () {
	    __assign$aI = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aI.apply(this, arguments);
	};
	var NoteAddFontIcon = React.forwardRef(function NoteAddFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aI({}, props, { ref: ref }), "note_add"));
	});

	var __assign$aJ = (undefined && undefined.__assign) || function () {
	    __assign$aJ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aJ.apply(this, arguments);
	};
	var NoteFontIcon = React.forwardRef(function NoteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aJ({}, props, { ref: ref }), "note"));
	});

	var __assign$aK = (undefined && undefined.__assign) || function () {
	    __assign$aK = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aK.apply(this, arguments);
	};
	var NotificationsActiveFontIcon = React.forwardRef(function NotificationsActiveFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aK({}, props, { ref: ref }), "notifications_active"));
	});

	var __assign$aL = (undefined && undefined.__assign) || function () {
	    __assign$aL = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aL.apply(this, arguments);
	};
	var NotificationsNoneFontIcon = React.forwardRef(function NotificationsNoneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aL({}, props, { ref: ref }), "notifications_none"));
	});

	var __assign$aM = (undefined && undefined.__assign) || function () {
	    __assign$aM = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aM.apply(this, arguments);
	};
	var NotificationsOffFontIcon = React.forwardRef(function NotificationsOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aM({}, props, { ref: ref }), "notifications_off"));
	});

	var __assign$aN = (undefined && undefined.__assign) || function () {
	    __assign$aN = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aN.apply(this, arguments);
	};
	var NotificationsPausedFontIcon = React.forwardRef(function NotificationsPausedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aN({}, props, { ref: ref }), "notifications_paused"));
	});

	var __assign$aO = (undefined && undefined.__assign) || function () {
	    __assign$aO = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aO.apply(this, arguments);
	};
	var NotificationsFontIcon = React.forwardRef(function NotificationsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aO({}, props, { ref: ref }), "notifications"));
	});

	var __assign$aP = (undefined && undefined.__assign) || function () {
	    __assign$aP = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aP.apply(this, arguments);
	};
	var OfflinePinFontIcon = React.forwardRef(function OfflinePinFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aP({}, props, { ref: ref }), "offline_pin"));
	});

	var __assign$aQ = (undefined && undefined.__assign) || function () {
	    __assign$aQ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aQ.apply(this, arguments);
	};
	var OndemandVideoFontIcon = React.forwardRef(function OndemandVideoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aQ({}, props, { ref: ref }), "ondemand_video"));
	});

	var __assign$aR = (undefined && undefined.__assign) || function () {
	    __assign$aR = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aR.apply(this, arguments);
	};
	var OpacityFontIcon = React.forwardRef(function OpacityFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aR({}, props, { ref: ref }), "opacity"));
	});

	var __assign$aS = (undefined && undefined.__assign) || function () {
	    __assign$aS = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aS.apply(this, arguments);
	};
	var OpenInBrowserFontIcon = React.forwardRef(function OpenInBrowserFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aS({}, props, { ref: ref }), "open_in_browser"));
	});

	var __assign$aT = (undefined && undefined.__assign) || function () {
	    __assign$aT = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aT.apply(this, arguments);
	};
	var OpenInNewFontIcon = React.forwardRef(function OpenInNewFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aT({}, props, { ref: ref }), "open_in_new"));
	});

	var __assign$aU = (undefined && undefined.__assign) || function () {
	    __assign$aU = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aU.apply(this, arguments);
	};
	var OpenWithFontIcon = React.forwardRef(function OpenWithFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aU({}, props, { ref: ref }), "open_with"));
	});

	var __assign$aV = (undefined && undefined.__assign) || function () {
	    __assign$aV = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aV.apply(this, arguments);
	};
	var PagesFontIcon = React.forwardRef(function PagesFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aV({}, props, { ref: ref }), "pages"));
	});

	var __assign$aW = (undefined && undefined.__assign) || function () {
	    __assign$aW = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aW.apply(this, arguments);
	};
	var PageviewFontIcon = React.forwardRef(function PageviewFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aW({}, props, { ref: ref }), "pageview"));
	});

	var __assign$aX = (undefined && undefined.__assign) || function () {
	    __assign$aX = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aX.apply(this, arguments);
	};
	var PaletteFontIcon = React.forwardRef(function PaletteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aX({}, props, { ref: ref }), "palette"));
	});

	var __assign$aY = (undefined && undefined.__assign) || function () {
	    __assign$aY = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aY.apply(this, arguments);
	};
	var PanToolFontIcon = React.forwardRef(function PanToolFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aY({}, props, { ref: ref }), "pan_tool"));
	});

	var __assign$aZ = (undefined && undefined.__assign) || function () {
	    __assign$aZ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$aZ.apply(this, arguments);
	};
	var PanoramaFishEyeFontIcon = React.forwardRef(function PanoramaFishEyeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$aZ({}, props, { ref: ref }), "panorama_fish_eye"));
	});

	var __assign$a_ = (undefined && undefined.__assign) || function () {
	    __assign$a_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a_.apply(this, arguments);
	};
	var PanoramaHorizontalFontIcon = React.forwardRef(function PanoramaHorizontalFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$a_({}, props, { ref: ref }), "panorama_horizontal"));
	});

	var __assign$a$ = (undefined && undefined.__assign) || function () {
	    __assign$a$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$a$.apply(this, arguments);
	};
	var PanoramaVerticalFontIcon = React.forwardRef(function PanoramaVerticalFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$a$({}, props, { ref: ref }), "panorama_vertical"));
	});

	var __assign$b0 = (undefined && undefined.__assign) || function () {
	    __assign$b0 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b0.apply(this, arguments);
	};
	var PanoramaWideAngleFontIcon = React.forwardRef(function PanoramaWideAngleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$b0({}, props, { ref: ref }), "panorama_wide_angle"));
	});

	var __assign$b1 = (undefined && undefined.__assign) || function () {
	    __assign$b1 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b1.apply(this, arguments);
	};
	var PanoramaFontIcon = React.forwardRef(function PanoramaFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$b1({}, props, { ref: ref }), "panorama"));
	});

	var __assign$b2 = (undefined && undefined.__assign) || function () {
	    __assign$b2 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b2.apply(this, arguments);
	};
	var PartyModeFontIcon = React.forwardRef(function PartyModeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$b2({}, props, { ref: ref }), "party_mode"));
	});

	var __assign$b3 = (undefined && undefined.__assign) || function () {
	    __assign$b3 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b3.apply(this, arguments);
	};
	var PauseCircleFilledFontIcon = React.forwardRef(function PauseCircleFilledFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$b3({}, props, { ref: ref }), "pause_circle_filled"));
	});

	var __assign$b4 = (undefined && undefined.__assign) || function () {
	    __assign$b4 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b4.apply(this, arguments);
	};
	var PauseCircleOutlineFontIcon = React.forwardRef(function PauseCircleOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$b4({}, props, { ref: ref }), "pause_circle_outline"));
	});

	var __assign$b5 = (undefined && undefined.__assign) || function () {
	    __assign$b5 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b5.apply(this, arguments);
	};
	var PauseFontIcon = React.forwardRef(function PauseFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$b5({}, props, { ref: ref }), "pause"));
	});

	var __assign$b6 = (undefined && undefined.__assign) || function () {
	    __assign$b6 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b6.apply(this, arguments);
	};
	var PaymentFontIcon = React.forwardRef(function PaymentFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$b6({}, props, { ref: ref }), "payment"));
	});

	var __assign$b7 = (undefined && undefined.__assign) || function () {
	    __assign$b7 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b7.apply(this, arguments);
	};
	var PeopleOutlineFontIcon = React.forwardRef(function PeopleOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$b7({}, props, { ref: ref }), "people_outline"));
	});

	var __assign$b8 = (undefined && undefined.__assign) || function () {
	    __assign$b8 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b8.apply(this, arguments);
	};
	var PeopleFontIcon = React.forwardRef(function PeopleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$b8({}, props, { ref: ref }), "people"));
	});

	var __assign$b9 = (undefined && undefined.__assign) || function () {
	    __assign$b9 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b9.apply(this, arguments);
	};
	var PermCameraMicFontIcon = React.forwardRef(function PermCameraMicFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$b9({}, props, { ref: ref }), "perm_camera_mic"));
	});

	var __assign$ba = (undefined && undefined.__assign) || function () {
	    __assign$ba = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ba.apply(this, arguments);
	};
	var PermContactCalendarFontIcon = React.forwardRef(function PermContactCalendarFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ba({}, props, { ref: ref }), "perm_contact_calendar"));
	});

	var __assign$bb = (undefined && undefined.__assign) || function () {
	    __assign$bb = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bb.apply(this, arguments);
	};
	var PermDataSettingFontIcon = React.forwardRef(function PermDataSettingFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bb({}, props, { ref: ref }), "perm_data_setting"));
	});

	var __assign$bc = (undefined && undefined.__assign) || function () {
	    __assign$bc = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bc.apply(this, arguments);
	};
	var PermDeviceInformationFontIcon = React.forwardRef(function PermDeviceInformationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bc({}, props, { ref: ref }), "perm_device_information"));
	});

	var __assign$bd = (undefined && undefined.__assign) || function () {
	    __assign$bd = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bd.apply(this, arguments);
	};
	var PermIdentityFontIcon = React.forwardRef(function PermIdentityFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bd({}, props, { ref: ref }), "perm_identity"));
	});

	var __assign$be = (undefined && undefined.__assign) || function () {
	    __assign$be = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$be.apply(this, arguments);
	};
	var PermMediaFontIcon = React.forwardRef(function PermMediaFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$be({}, props, { ref: ref }), "perm_media"));
	});

	var __assign$bf = (undefined && undefined.__assign) || function () {
	    __assign$bf = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bf.apply(this, arguments);
	};
	var PermPhoneMsgFontIcon = React.forwardRef(function PermPhoneMsgFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bf({}, props, { ref: ref }), "perm_phone_msg"));
	});

	var __assign$bg = (undefined && undefined.__assign) || function () {
	    __assign$bg = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bg.apply(this, arguments);
	};
	var PermScanWifiFontIcon = React.forwardRef(function PermScanWifiFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bg({}, props, { ref: ref }), "perm_scan_wifi"));
	});

	var __assign$bh = (undefined && undefined.__assign) || function () {
	    __assign$bh = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bh.apply(this, arguments);
	};
	var PersonAddFontIcon = React.forwardRef(function PersonAddFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bh({}, props, { ref: ref }), "person_add"));
	});

	var __assign$bi = (undefined && undefined.__assign) || function () {
	    __assign$bi = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bi.apply(this, arguments);
	};
	var PersonOutlineFontIcon = React.forwardRef(function PersonOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bi({}, props, { ref: ref }), "person_outline"));
	});

	var __assign$bj = (undefined && undefined.__assign) || function () {
	    __assign$bj = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bj.apply(this, arguments);
	};
	var PersonPinCircleFontIcon = React.forwardRef(function PersonPinCircleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bj({}, props, { ref: ref }), "person_pin_circle"));
	});

	var __assign$bk = (undefined && undefined.__assign) || function () {
	    __assign$bk = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bk.apply(this, arguments);
	};
	var PersonPinFontIcon = React.forwardRef(function PersonPinFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bk({}, props, { ref: ref }), "person_pin"));
	});

	var __assign$bl = (undefined && undefined.__assign) || function () {
	    __assign$bl = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bl.apply(this, arguments);
	};
	var PersonFontIcon = React.forwardRef(function PersonFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bl({}, props, { ref: ref }), "person"));
	});

	var __assign$bm = (undefined && undefined.__assign) || function () {
	    __assign$bm = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bm.apply(this, arguments);
	};
	var PersonalVideoFontIcon = React.forwardRef(function PersonalVideoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bm({}, props, { ref: ref }), "personal_video"));
	});

	var __assign$bn = (undefined && undefined.__assign) || function () {
	    __assign$bn = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bn.apply(this, arguments);
	};
	var PetsFontIcon = React.forwardRef(function PetsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bn({}, props, { ref: ref }), "pets"));
	});

	var __assign$bo = (undefined && undefined.__assign) || function () {
	    __assign$bo = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bo.apply(this, arguments);
	};
	var PhoneAndroidFontIcon = React.forwardRef(function PhoneAndroidFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bo({}, props, { ref: ref }), "phone_android"));
	});

	var __assign$bp = (undefined && undefined.__assign) || function () {
	    __assign$bp = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bp.apply(this, arguments);
	};
	var PhoneBluetoothSpeakerFontIcon = React.forwardRef(function PhoneBluetoothSpeakerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bp({}, props, { ref: ref }), "phone_bluetooth_speaker"));
	});

	var __assign$bq = (undefined && undefined.__assign) || function () {
	    __assign$bq = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bq.apply(this, arguments);
	};
	var PhoneForwardedFontIcon = React.forwardRef(function PhoneForwardedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bq({}, props, { ref: ref }), "phone_forwarded"));
	});

	var __assign$br = (undefined && undefined.__assign) || function () {
	    __assign$br = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$br.apply(this, arguments);
	};
	var PhoneInTalkFontIcon = React.forwardRef(function PhoneInTalkFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$br({}, props, { ref: ref }), "phone_in_talk"));
	});

	var __assign$bs = (undefined && undefined.__assign) || function () {
	    __assign$bs = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bs.apply(this, arguments);
	};
	var PhoneIphoneFontIcon = React.forwardRef(function PhoneIphoneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bs({}, props, { ref: ref }), "phone_iphone"));
	});

	var __assign$bt = (undefined && undefined.__assign) || function () {
	    __assign$bt = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bt.apply(this, arguments);
	};
	var PhoneLockedFontIcon = React.forwardRef(function PhoneLockedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bt({}, props, { ref: ref }), "phone_locked"));
	});

	var __assign$bu = (undefined && undefined.__assign) || function () {
	    __assign$bu = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bu.apply(this, arguments);
	};
	var PhoneMissedFontIcon = React.forwardRef(function PhoneMissedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bu({}, props, { ref: ref }), "phone_missed"));
	});

	var __assign$bv = (undefined && undefined.__assign) || function () {
	    __assign$bv = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bv.apply(this, arguments);
	};
	var PhonePausedFontIcon = React.forwardRef(function PhonePausedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bv({}, props, { ref: ref }), "phone_paused"));
	});

	var __assign$bw = (undefined && undefined.__assign) || function () {
	    __assign$bw = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bw.apply(this, arguments);
	};
	var PhoneFontIcon = React.forwardRef(function PhoneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bw({}, props, { ref: ref }), "phone"));
	});

	var __assign$bx = (undefined && undefined.__assign) || function () {
	    __assign$bx = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bx.apply(this, arguments);
	};
	var PhonelinkEraseFontIcon = React.forwardRef(function PhonelinkEraseFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bx({}, props, { ref: ref }), "phonelink_erase"));
	});

	var __assign$by = (undefined && undefined.__assign) || function () {
	    __assign$by = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$by.apply(this, arguments);
	};
	var PhonelinkLockFontIcon = React.forwardRef(function PhonelinkLockFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$by({}, props, { ref: ref }), "phonelink_lock"));
	});

	var __assign$bz = (undefined && undefined.__assign) || function () {
	    __assign$bz = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bz.apply(this, arguments);
	};
	var PhonelinkOffFontIcon = React.forwardRef(function PhonelinkOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bz({}, props, { ref: ref }), "phonelink_off"));
	});

	var __assign$bA = (undefined && undefined.__assign) || function () {
	    __assign$bA = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bA.apply(this, arguments);
	};
	var PhonelinkRingFontIcon = React.forwardRef(function PhonelinkRingFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bA({}, props, { ref: ref }), "phonelink_ring"));
	});

	var __assign$bB = (undefined && undefined.__assign) || function () {
	    __assign$bB = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bB.apply(this, arguments);
	};
	var PhonelinkSetupFontIcon = React.forwardRef(function PhonelinkSetupFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bB({}, props, { ref: ref }), "phonelink_setup"));
	});

	var __assign$bC = (undefined && undefined.__assign) || function () {
	    __assign$bC = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bC.apply(this, arguments);
	};
	var PhonelinkFontIcon = React.forwardRef(function PhonelinkFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bC({}, props, { ref: ref }), "phonelink"));
	});

	var __assign$bD = (undefined && undefined.__assign) || function () {
	    __assign$bD = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bD.apply(this, arguments);
	};
	var PhotoAlbumFontIcon = React.forwardRef(function PhotoAlbumFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bD({}, props, { ref: ref }), "photo_album"));
	});

	var __assign$bE = (undefined && undefined.__assign) || function () {
	    __assign$bE = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bE.apply(this, arguments);
	};
	var PhotoCameraFontIcon = React.forwardRef(function PhotoCameraFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bE({}, props, { ref: ref }), "photo_camera"));
	});

	var __assign$bF = (undefined && undefined.__assign) || function () {
	    __assign$bF = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bF.apply(this, arguments);
	};
	var PhotoFilterFontIcon = React.forwardRef(function PhotoFilterFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bF({}, props, { ref: ref }), "photo_filter"));
	});

	var __assign$bG = (undefined && undefined.__assign) || function () {
	    __assign$bG = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bG.apply(this, arguments);
	};
	var PhotoLibraryFontIcon = React.forwardRef(function PhotoLibraryFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bG({}, props, { ref: ref }), "photo_library"));
	});

	var __assign$bH = (undefined && undefined.__assign) || function () {
	    __assign$bH = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bH.apply(this, arguments);
	};
	var PhotoSizeSelectActualFontIcon = React.forwardRef(function PhotoSizeSelectActualFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bH({}, props, { ref: ref }), "photo_size_select_actual"));
	});

	var __assign$bI = (undefined && undefined.__assign) || function () {
	    __assign$bI = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bI.apply(this, arguments);
	};
	var PhotoSizeSelectLargeFontIcon = React.forwardRef(function PhotoSizeSelectLargeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bI({}, props, { ref: ref }), "photo_size_select_large"));
	});

	var __assign$bJ = (undefined && undefined.__assign) || function () {
	    __assign$bJ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bJ.apply(this, arguments);
	};
	var PhotoSizeSelectSmallFontIcon = React.forwardRef(function PhotoSizeSelectSmallFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bJ({}, props, { ref: ref }), "photo_size_select_small"));
	});

	var __assign$bK = (undefined && undefined.__assign) || function () {
	    __assign$bK = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bK.apply(this, arguments);
	};
	var PhotoFontIcon = React.forwardRef(function PhotoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bK({}, props, { ref: ref }), "photo"));
	});

	var __assign$bL = (undefined && undefined.__assign) || function () {
	    __assign$bL = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bL.apply(this, arguments);
	};
	var PictureAsPdfFontIcon = React.forwardRef(function PictureAsPdfFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bL({}, props, { ref: ref }), "picture_as_pdf"));
	});

	var __assign$bM = (undefined && undefined.__assign) || function () {
	    __assign$bM = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bM.apply(this, arguments);
	};
	var PictureInPictureAltFontIcon = React.forwardRef(function PictureInPictureAltFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bM({}, props, { ref: ref }), "picture_in_picture_alt"));
	});

	var __assign$bN = (undefined && undefined.__assign) || function () {
	    __assign$bN = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bN.apply(this, arguments);
	};
	var PictureInPictureFontIcon = React.forwardRef(function PictureInPictureFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bN({}, props, { ref: ref }), "picture_in_picture"));
	});

	var __assign$bO = (undefined && undefined.__assign) || function () {
	    __assign$bO = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bO.apply(this, arguments);
	};
	var PieChartOutlinedFontIcon = React.forwardRef(function PieChartOutlinedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bO({}, props, { ref: ref }), "pie_chart_outlined"));
	});

	var __assign$bP = (undefined && undefined.__assign) || function () {
	    __assign$bP = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bP.apply(this, arguments);
	};
	var PieChartFontIcon = React.forwardRef(function PieChartFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bP({}, props, { ref: ref }), "pie_chart"));
	});

	var __assign$bQ = (undefined && undefined.__assign) || function () {
	    __assign$bQ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bQ.apply(this, arguments);
	};
	var PinDropFontIcon = React.forwardRef(function PinDropFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bQ({}, props, { ref: ref }), "pin_drop"));
	});

	var __assign$bR = (undefined && undefined.__assign) || function () {
	    __assign$bR = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bR.apply(this, arguments);
	};
	var PlaceFontIcon = React.forwardRef(function PlaceFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bR({}, props, { ref: ref }), "place"));
	});

	var __assign$bS = (undefined && undefined.__assign) || function () {
	    __assign$bS = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bS.apply(this, arguments);
	};
	var PlayArrowFontIcon = React.forwardRef(function PlayArrowFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bS({}, props, { ref: ref }), "play_arrow"));
	});

	var __assign$bT = (undefined && undefined.__assign) || function () {
	    __assign$bT = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bT.apply(this, arguments);
	};
	var PlayCircleFilledFontIcon = React.forwardRef(function PlayCircleFilledFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bT({}, props, { ref: ref }), "play_circle_filled"));
	});

	var __assign$bU = (undefined && undefined.__assign) || function () {
	    __assign$bU = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bU.apply(this, arguments);
	};
	var PlayCircleOutlineFontIcon = React.forwardRef(function PlayCircleOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bU({}, props, { ref: ref }), "play_circle_outline"));
	});

	var __assign$bV = (undefined && undefined.__assign) || function () {
	    __assign$bV = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bV.apply(this, arguments);
	};
	var PlayForWorkFontIcon = React.forwardRef(function PlayForWorkFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bV({}, props, { ref: ref }), "play_for_work"));
	});

	var __assign$bW = (undefined && undefined.__assign) || function () {
	    __assign$bW = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bW.apply(this, arguments);
	};
	var PlaylistAddCheckFontIcon = React.forwardRef(function PlaylistAddCheckFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bW({}, props, { ref: ref }), "playlist_add_check"));
	});

	var __assign$bX = (undefined && undefined.__assign) || function () {
	    __assign$bX = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bX.apply(this, arguments);
	};
	var PlaylistAddFontIcon = React.forwardRef(function PlaylistAddFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bX({}, props, { ref: ref }), "playlist_add"));
	});

	var __assign$bY = (undefined && undefined.__assign) || function () {
	    __assign$bY = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bY.apply(this, arguments);
	};
	var PlaylistPlayFontIcon = React.forwardRef(function PlaylistPlayFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bY({}, props, { ref: ref }), "playlist_play"));
	});

	var __assign$bZ = (undefined && undefined.__assign) || function () {
	    __assign$bZ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$bZ.apply(this, arguments);
	};
	var PlusOneFontIcon = React.forwardRef(function PlusOneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$bZ({}, props, { ref: ref }), "plus_one"));
	});

	var __assign$b_ = (undefined && undefined.__assign) || function () {
	    __assign$b_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b_.apply(this, arguments);
	};
	var PollFontIcon = React.forwardRef(function PollFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$b_({}, props, { ref: ref }), "poll"));
	});

	var __assign$b$ = (undefined && undefined.__assign) || function () {
	    __assign$b$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$b$.apply(this, arguments);
	};
	var PolymerFontIcon = React.forwardRef(function PolymerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$b$({}, props, { ref: ref }), "polymer"));
	});

	var __assign$c0 = (undefined && undefined.__assign) || function () {
	    __assign$c0 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c0.apply(this, arguments);
	};
	var PoolFontIcon = React.forwardRef(function PoolFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$c0({}, props, { ref: ref }), "pool"));
	});

	var __assign$c1 = (undefined && undefined.__assign) || function () {
	    __assign$c1 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c1.apply(this, arguments);
	};
	var PortableWifiOffFontIcon = React.forwardRef(function PortableWifiOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$c1({}, props, { ref: ref }), "portable_wifi_off"));
	});

	var __assign$c2 = (undefined && undefined.__assign) || function () {
	    __assign$c2 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c2.apply(this, arguments);
	};
	var PortraitFontIcon = React.forwardRef(function PortraitFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$c2({}, props, { ref: ref }), "portrait"));
	});

	var __assign$c3 = (undefined && undefined.__assign) || function () {
	    __assign$c3 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c3.apply(this, arguments);
	};
	var PowerInputFontIcon = React.forwardRef(function PowerInputFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$c3({}, props, { ref: ref }), "power_input"));
	});

	var __assign$c4 = (undefined && undefined.__assign) || function () {
	    __assign$c4 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c4.apply(this, arguments);
	};
	var PowerSettingsNewFontIcon = React.forwardRef(function PowerSettingsNewFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$c4({}, props, { ref: ref }), "power_settings_new"));
	});

	var __assign$c5 = (undefined && undefined.__assign) || function () {
	    __assign$c5 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c5.apply(this, arguments);
	};
	var PowerFontIcon = React.forwardRef(function PowerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$c5({}, props, { ref: ref }), "power"));
	});

	var __assign$c6 = (undefined && undefined.__assign) || function () {
	    __assign$c6 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c6.apply(this, arguments);
	};
	var PregnantWomanFontIcon = React.forwardRef(function PregnantWomanFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$c6({}, props, { ref: ref }), "pregnant_woman"));
	});

	var __assign$c7 = (undefined && undefined.__assign) || function () {
	    __assign$c7 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c7.apply(this, arguments);
	};
	var PresentToAllFontIcon = React.forwardRef(function PresentToAllFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$c7({}, props, { ref: ref }), "present_to_all"));
	});

	var __assign$c8 = (undefined && undefined.__assign) || function () {
	    __assign$c8 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c8.apply(this, arguments);
	};
	var PrintFontIcon = React.forwardRef(function PrintFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$c8({}, props, { ref: ref }), "print"));
	});

	var __assign$c9 = (undefined && undefined.__assign) || function () {
	    __assign$c9 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c9.apply(this, arguments);
	};
	var PriorityHighFontIcon = React.forwardRef(function PriorityHighFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$c9({}, props, { ref: ref }), "priority_high"));
	});

	var __assign$ca = (undefined && undefined.__assign) || function () {
	    __assign$ca = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ca.apply(this, arguments);
	};
	var PublicFontIcon = React.forwardRef(function PublicFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ca({}, props, { ref: ref }), "public"));
	});

	var __assign$cb = (undefined && undefined.__assign) || function () {
	    __assign$cb = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cb.apply(this, arguments);
	};
	var PublishFontIcon = React.forwardRef(function PublishFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cb({}, props, { ref: ref }), "publish"));
	});

	var __assign$cc = (undefined && undefined.__assign) || function () {
	    __assign$cc = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cc.apply(this, arguments);
	};
	var QueryBuilderFontIcon = React.forwardRef(function QueryBuilderFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cc({}, props, { ref: ref }), "query_builder"));
	});

	var __assign$cd = (undefined && undefined.__assign) || function () {
	    __assign$cd = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cd.apply(this, arguments);
	};
	var QuestionAnswerFontIcon = React.forwardRef(function QuestionAnswerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cd({}, props, { ref: ref }), "question_answer"));
	});

	var __assign$ce = (undefined && undefined.__assign) || function () {
	    __assign$ce = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ce.apply(this, arguments);
	};
	var QueueMusicFontIcon = React.forwardRef(function QueueMusicFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ce({}, props, { ref: ref }), "queue_music"));
	});

	var __assign$cf = (undefined && undefined.__assign) || function () {
	    __assign$cf = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cf.apply(this, arguments);
	};
	var QueuePlayNextFontIcon = React.forwardRef(function QueuePlayNextFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cf({}, props, { ref: ref }), "queue_play_next"));
	});

	var __assign$cg = (undefined && undefined.__assign) || function () {
	    __assign$cg = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cg.apply(this, arguments);
	};
	var QueueFontIcon = React.forwardRef(function QueueFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cg({}, props, { ref: ref }), "queue"));
	});

	var __assign$ch = (undefined && undefined.__assign) || function () {
	    __assign$ch = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ch.apply(this, arguments);
	};
	var RadioButtonCheckedFontIcon = React.forwardRef(function RadioButtonCheckedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ch({}, props, { ref: ref }), "radio_button_checked"));
	});

	var __assign$ci = (undefined && undefined.__assign) || function () {
	    __assign$ci = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ci.apply(this, arguments);
	};
	var RadioButtonUncheckedFontIcon = React.forwardRef(function RadioButtonUncheckedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ci({}, props, { ref: ref }), "radio_button_unchecked"));
	});

	var __assign$cj = (undefined && undefined.__assign) || function () {
	    __assign$cj = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cj.apply(this, arguments);
	};
	var RadioFontIcon = React.forwardRef(function RadioFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cj({}, props, { ref: ref }), "radio"));
	});

	var __assign$ck = (undefined && undefined.__assign) || function () {
	    __assign$ck = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ck.apply(this, arguments);
	};
	var RateReviewFontIcon = React.forwardRef(function RateReviewFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ck({}, props, { ref: ref }), "rate_review"));
	});

	var __assign$cl = (undefined && undefined.__assign) || function () {
	    __assign$cl = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cl.apply(this, arguments);
	};
	var ReceiptFontIcon = React.forwardRef(function ReceiptFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cl({}, props, { ref: ref }), "receipt"));
	});

	var __assign$cm = (undefined && undefined.__assign) || function () {
	    __assign$cm = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cm.apply(this, arguments);
	};
	var RecentActorsFontIcon = React.forwardRef(function RecentActorsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cm({}, props, { ref: ref }), "recent_actors"));
	});

	var __assign$cn = (undefined && undefined.__assign) || function () {
	    __assign$cn = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cn.apply(this, arguments);
	};
	var RecordVoiceOverFontIcon = React.forwardRef(function RecordVoiceOverFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cn({}, props, { ref: ref }), "record_voice_over"));
	});

	var __assign$co = (undefined && undefined.__assign) || function () {
	    __assign$co = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$co.apply(this, arguments);
	};
	var RedeemFontIcon = React.forwardRef(function RedeemFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$co({}, props, { ref: ref }), "redeem"));
	});

	var __assign$cp = (undefined && undefined.__assign) || function () {
	    __assign$cp = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cp.apply(this, arguments);
	};
	var RedoFontIcon = React.forwardRef(function RedoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cp({}, props, { ref: ref }), "redo"));
	});

	var __assign$cq = (undefined && undefined.__assign) || function () {
	    __assign$cq = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cq.apply(this, arguments);
	};
	var RefreshFontIcon = React.forwardRef(function RefreshFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cq({}, props, { ref: ref }), "refresh"));
	});

	var __assign$cr = (undefined && undefined.__assign) || function () {
	    __assign$cr = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cr.apply(this, arguments);
	};
	var RemoveCircleOutlineFontIcon = React.forwardRef(function RemoveCircleOutlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cr({}, props, { ref: ref }), "remove_circle_outline"));
	});

	var __assign$cs = (undefined && undefined.__assign) || function () {
	    __assign$cs = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cs.apply(this, arguments);
	};
	var RemoveCircleFontIcon = React.forwardRef(function RemoveCircleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cs({}, props, { ref: ref }), "remove_circle"));
	});

	var __assign$ct = (undefined && undefined.__assign) || function () {
	    __assign$ct = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ct.apply(this, arguments);
	};
	var RemoveFromQueueFontIcon = React.forwardRef(function RemoveFromQueueFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ct({}, props, { ref: ref }), "remove_from_queue"));
	});

	var __assign$cu = (undefined && undefined.__assign) || function () {
	    __assign$cu = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cu.apply(this, arguments);
	};
	var RemoveRedEyeFontIcon = React.forwardRef(function RemoveRedEyeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cu({}, props, { ref: ref }), "remove_red_eye"));
	});

	var __assign$cv = (undefined && undefined.__assign) || function () {
	    __assign$cv = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cv.apply(this, arguments);
	};
	var RemoveShoppingCartFontIcon = React.forwardRef(function RemoveShoppingCartFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cv({}, props, { ref: ref }), "remove_shopping_cart"));
	});

	var __assign$cw = (undefined && undefined.__assign) || function () {
	    __assign$cw = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cw.apply(this, arguments);
	};
	var RemoveFontIcon = React.forwardRef(function RemoveFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cw({}, props, { ref: ref }), "remove"));
	});

	var __assign$cx = (undefined && undefined.__assign) || function () {
	    __assign$cx = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cx.apply(this, arguments);
	};
	var ReorderFontIcon = React.forwardRef(function ReorderFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cx({}, props, { ref: ref }), "reorder"));
	});

	var __assign$cy = (undefined && undefined.__assign) || function () {
	    __assign$cy = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cy.apply(this, arguments);
	};
	var RepeatOneFontIcon = React.forwardRef(function RepeatOneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cy({}, props, { ref: ref }), "repeat_one"));
	});

	var __assign$cz = (undefined && undefined.__assign) || function () {
	    __assign$cz = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cz.apply(this, arguments);
	};
	var RepeatFontIcon = React.forwardRef(function RepeatFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cz({}, props, { ref: ref }), "repeat"));
	});

	var __assign$cA = (undefined && undefined.__assign) || function () {
	    __assign$cA = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cA.apply(this, arguments);
	};
	var Replay10FontIcon = React.forwardRef(function Replay10FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cA({}, props, { ref: ref }), "replay_10"));
	});

	var __assign$cB = (undefined && undefined.__assign) || function () {
	    __assign$cB = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cB.apply(this, arguments);
	};
	var Replay30FontIcon = React.forwardRef(function Replay30FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cB({}, props, { ref: ref }), "replay_30"));
	});

	var __assign$cC = (undefined && undefined.__assign) || function () {
	    __assign$cC = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cC.apply(this, arguments);
	};
	var Replay5FontIcon = React.forwardRef(function Replay5FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cC({}, props, { ref: ref }), "replay_5"));
	});

	var __assign$cD = (undefined && undefined.__assign) || function () {
	    __assign$cD = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cD.apply(this, arguments);
	};
	var ReplayFontIcon = React.forwardRef(function ReplayFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cD({}, props, { ref: ref }), "replay"));
	});

	var __assign$cE = (undefined && undefined.__assign) || function () {
	    __assign$cE = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cE.apply(this, arguments);
	};
	var ReplyAllFontIcon = React.forwardRef(function ReplyAllFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cE({}, props, { ref: ref }), "reply_all"));
	});

	var __assign$cF = (undefined && undefined.__assign) || function () {
	    __assign$cF = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cF.apply(this, arguments);
	};
	var ReplyFontIcon = React.forwardRef(function ReplyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cF({}, props, { ref: ref }), "reply"));
	});

	var __assign$cG = (undefined && undefined.__assign) || function () {
	    __assign$cG = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cG.apply(this, arguments);
	};
	var ReportProblemFontIcon = React.forwardRef(function ReportProblemFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cG({}, props, { ref: ref }), "report_problem"));
	});

	var __assign$cH = (undefined && undefined.__assign) || function () {
	    __assign$cH = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cH.apply(this, arguments);
	};
	var ReportFontIcon = React.forwardRef(function ReportFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cH({}, props, { ref: ref }), "report"));
	});

	var __assign$cI = (undefined && undefined.__assign) || function () {
	    __assign$cI = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cI.apply(this, arguments);
	};
	var RestaurantMenuFontIcon = React.forwardRef(function RestaurantMenuFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cI({}, props, { ref: ref }), "restaurant_menu"));
	});

	var __assign$cJ = (undefined && undefined.__assign) || function () {
	    __assign$cJ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cJ.apply(this, arguments);
	};
	var RestaurantFontIcon = React.forwardRef(function RestaurantFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cJ({}, props, { ref: ref }), "restaurant"));
	});

	var __assign$cK = (undefined && undefined.__assign) || function () {
	    __assign$cK = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cK.apply(this, arguments);
	};
	var RestorePageFontIcon = React.forwardRef(function RestorePageFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cK({}, props, { ref: ref }), "restore_page"));
	});

	var __assign$cL = (undefined && undefined.__assign) || function () {
	    __assign$cL = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cL.apply(this, arguments);
	};
	var RestoreFontIcon = React.forwardRef(function RestoreFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cL({}, props, { ref: ref }), "restore"));
	});

	var __assign$cM = (undefined && undefined.__assign) || function () {
	    __assign$cM = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cM.apply(this, arguments);
	};
	var RingVolumeFontIcon = React.forwardRef(function RingVolumeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cM({}, props, { ref: ref }), "ring_volume"));
	});

	var __assign$cN = (undefined && undefined.__assign) || function () {
	    __assign$cN = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cN.apply(this, arguments);
	};
	var RoomServiceFontIcon = React.forwardRef(function RoomServiceFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cN({}, props, { ref: ref }), "room_service"));
	});

	var __assign$cO = (undefined && undefined.__assign) || function () {
	    __assign$cO = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cO.apply(this, arguments);
	};
	var RoomFontIcon = React.forwardRef(function RoomFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cO({}, props, { ref: ref }), "room"));
	});

	var __assign$cP = (undefined && undefined.__assign) || function () {
	    __assign$cP = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cP.apply(this, arguments);
	};
	var Rotate90DegreesCcwFontIcon = React.forwardRef(function Rotate90DegreesCcwFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cP({}, props, { ref: ref }), "rotate_90_degrees_ccw"));
	});

	var __assign$cQ = (undefined && undefined.__assign) || function () {
	    __assign$cQ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cQ.apply(this, arguments);
	};
	var RotateLeftFontIcon = React.forwardRef(function RotateLeftFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cQ({}, props, { ref: ref }), "rotate_left"));
	});

	var __assign$cR = (undefined && undefined.__assign) || function () {
	    __assign$cR = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cR.apply(this, arguments);
	};
	var RotateRightFontIcon = React.forwardRef(function RotateRightFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cR({}, props, { ref: ref }), "rotate_right"));
	});

	var __assign$cS = (undefined && undefined.__assign) || function () {
	    __assign$cS = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cS.apply(this, arguments);
	};
	var RoundedCornerFontIcon = React.forwardRef(function RoundedCornerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cS({}, props, { ref: ref }), "rounded_corner"));
	});

	var __assign$cT = (undefined && undefined.__assign) || function () {
	    __assign$cT = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cT.apply(this, arguments);
	};
	var RouterFontIcon = React.forwardRef(function RouterFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cT({}, props, { ref: ref }), "router"));
	});

	var __assign$cU = (undefined && undefined.__assign) || function () {
	    __assign$cU = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cU.apply(this, arguments);
	};
	var RowingFontIcon = React.forwardRef(function RowingFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cU({}, props, { ref: ref }), "rowing"));
	});

	var __assign$cV = (undefined && undefined.__assign) || function () {
	    __assign$cV = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cV.apply(this, arguments);
	};
	var RssFeedFontIcon = React.forwardRef(function RssFeedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cV({}, props, { ref: ref }), "rss_feed"));
	});

	var __assign$cW = (undefined && undefined.__assign) || function () {
	    __assign$cW = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cW.apply(this, arguments);
	};
	var RvHookupFontIcon = React.forwardRef(function RvHookupFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cW({}, props, { ref: ref }), "rv_hookup"));
	});

	var __assign$cX = (undefined && undefined.__assign) || function () {
	    __assign$cX = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cX.apply(this, arguments);
	};
	var SatelliteFontIcon = React.forwardRef(function SatelliteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cX({}, props, { ref: ref }), "satellite"));
	});

	var __assign$cY = (undefined && undefined.__assign) || function () {
	    __assign$cY = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cY.apply(this, arguments);
	};
	var SaveFontIcon = React.forwardRef(function SaveFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cY({}, props, { ref: ref }), "save"));
	});

	var __assign$cZ = (undefined && undefined.__assign) || function () {
	    __assign$cZ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$cZ.apply(this, arguments);
	};
	var ScannerFontIcon = React.forwardRef(function ScannerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$cZ({}, props, { ref: ref }), "scanner"));
	});

	var __assign$c_ = (undefined && undefined.__assign) || function () {
	    __assign$c_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c_.apply(this, arguments);
	};
	var ScheduleFontIcon = React.forwardRef(function ScheduleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$c_({}, props, { ref: ref }), "schedule"));
	});

	var __assign$c$ = (undefined && undefined.__assign) || function () {
	    __assign$c$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$c$.apply(this, arguments);
	};
	var SchoolFontIcon = React.forwardRef(function SchoolFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$c$({}, props, { ref: ref }), "school"));
	});

	var __assign$d0 = (undefined && undefined.__assign) || function () {
	    __assign$d0 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d0.apply(this, arguments);
	};
	var ScreenLockLandscapeFontIcon = React.forwardRef(function ScreenLockLandscapeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$d0({}, props, { ref: ref }), "screen_lock_landscape"));
	});

	var __assign$d1 = (undefined && undefined.__assign) || function () {
	    __assign$d1 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d1.apply(this, arguments);
	};
	var ScreenLockPortraitFontIcon = React.forwardRef(function ScreenLockPortraitFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$d1({}, props, { ref: ref }), "screen_lock_portrait"));
	});

	var __assign$d2 = (undefined && undefined.__assign) || function () {
	    __assign$d2 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d2.apply(this, arguments);
	};
	var ScreenLockRotationFontIcon = React.forwardRef(function ScreenLockRotationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$d2({}, props, { ref: ref }), "screen_lock_rotation"));
	});

	var __assign$d3 = (undefined && undefined.__assign) || function () {
	    __assign$d3 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d3.apply(this, arguments);
	};
	var ScreenRotationFontIcon = React.forwardRef(function ScreenRotationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$d3({}, props, { ref: ref }), "screen_rotation"));
	});

	var __assign$d4 = (undefined && undefined.__assign) || function () {
	    __assign$d4 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d4.apply(this, arguments);
	};
	var ScreenShareFontIcon = React.forwardRef(function ScreenShareFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$d4({}, props, { ref: ref }), "screen_share"));
	});

	var __assign$d5 = (undefined && undefined.__assign) || function () {
	    __assign$d5 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d5.apply(this, arguments);
	};
	var SdCardFontIcon = React.forwardRef(function SdCardFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$d5({}, props, { ref: ref }), "sd_card"));
	});

	var __assign$d6 = (undefined && undefined.__assign) || function () {
	    __assign$d6 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d6.apply(this, arguments);
	};
	var SdStorageFontIcon = React.forwardRef(function SdStorageFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$d6({}, props, { ref: ref }), "sd_storage"));
	});

	var __assign$d7 = (undefined && undefined.__assign) || function () {
	    __assign$d7 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d7.apply(this, arguments);
	};
	var SearchFontIcon = React.forwardRef(function SearchFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$d7({}, props, { ref: ref }), "search"));
	});

	var __assign$d8 = (undefined && undefined.__assign) || function () {
	    __assign$d8 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d8.apply(this, arguments);
	};
	var SecurityFontIcon = React.forwardRef(function SecurityFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$d8({}, props, { ref: ref }), "security"));
	});

	var __assign$d9 = (undefined && undefined.__assign) || function () {
	    __assign$d9 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d9.apply(this, arguments);
	};
	var SelectAllFontIcon = React.forwardRef(function SelectAllFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$d9({}, props, { ref: ref }), "select_all"));
	});

	var __assign$da = (undefined && undefined.__assign) || function () {
	    __assign$da = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$da.apply(this, arguments);
	};
	var SendFontIcon = React.forwardRef(function SendFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$da({}, props, { ref: ref }), "send"));
	});

	var __assign$db = (undefined && undefined.__assign) || function () {
	    __assign$db = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$db.apply(this, arguments);
	};
	var SentimentDissatisfiedFontIcon = React.forwardRef(function SentimentDissatisfiedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$db({}, props, { ref: ref }), "sentiment_dissatisfied"));
	});

	var __assign$dc = (undefined && undefined.__assign) || function () {
	    __assign$dc = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dc.apply(this, arguments);
	};
	var SentimentNeutralFontIcon = React.forwardRef(function SentimentNeutralFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dc({}, props, { ref: ref }), "sentiment_neutral"));
	});

	var __assign$dd = (undefined && undefined.__assign) || function () {
	    __assign$dd = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dd.apply(this, arguments);
	};
	var SentimentSatisfiedFontIcon = React.forwardRef(function SentimentSatisfiedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dd({}, props, { ref: ref }), "sentiment_satisfied"));
	});

	var __assign$de = (undefined && undefined.__assign) || function () {
	    __assign$de = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$de.apply(this, arguments);
	};
	var SentimentVeryDissatisfiedFontIcon = React.forwardRef(function SentimentVeryDissatisfiedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$de({}, props, { ref: ref }), "sentiment_very_dissatisfied"));
	});

	var __assign$df = (undefined && undefined.__assign) || function () {
	    __assign$df = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$df.apply(this, arguments);
	};
	var SentimentVerySatisfiedFontIcon = React.forwardRef(function SentimentVerySatisfiedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$df({}, props, { ref: ref }), "sentiment_very_satisfied"));
	});

	var __assign$dg = (undefined && undefined.__assign) || function () {
	    __assign$dg = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dg.apply(this, arguments);
	};
	var SettingsApplicationsFontIcon = React.forwardRef(function SettingsApplicationsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dg({}, props, { ref: ref }), "settings_applications"));
	});

	var __assign$dh = (undefined && undefined.__assign) || function () {
	    __assign$dh = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dh.apply(this, arguments);
	};
	var SettingsBackupRestoreFontIcon = React.forwardRef(function SettingsBackupRestoreFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dh({}, props, { ref: ref }), "settings_backup_restore"));
	});

	var __assign$di = (undefined && undefined.__assign) || function () {
	    __assign$di = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$di.apply(this, arguments);
	};
	var SettingsBluetoothFontIcon = React.forwardRef(function SettingsBluetoothFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$di({}, props, { ref: ref }), "settings_bluetooth"));
	});

	var __assign$dj = (undefined && undefined.__assign) || function () {
	    __assign$dj = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dj.apply(this, arguments);
	};
	var SettingsBrightnessFontIcon = React.forwardRef(function SettingsBrightnessFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dj({}, props, { ref: ref }), "settings_brightness"));
	});

	var __assign$dk = (undefined && undefined.__assign) || function () {
	    __assign$dk = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dk.apply(this, arguments);
	};
	var SettingsCellFontIcon = React.forwardRef(function SettingsCellFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dk({}, props, { ref: ref }), "settings_cell"));
	});

	var __assign$dl = (undefined && undefined.__assign) || function () {
	    __assign$dl = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dl.apply(this, arguments);
	};
	var SettingsEthernetFontIcon = React.forwardRef(function SettingsEthernetFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dl({}, props, { ref: ref }), "settings_ethernet"));
	});

	var __assign$dm = (undefined && undefined.__assign) || function () {
	    __assign$dm = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dm.apply(this, arguments);
	};
	var SettingsInputAntennaFontIcon = React.forwardRef(function SettingsInputAntennaFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dm({}, props, { ref: ref }), "settings_input_antenna"));
	});

	var __assign$dn = (undefined && undefined.__assign) || function () {
	    __assign$dn = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dn.apply(this, arguments);
	};
	var SettingsInputComponentFontIcon = React.forwardRef(function SettingsInputComponentFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dn({}, props, { ref: ref }), "settings_input_component"));
	});

	var __assign$do = (undefined && undefined.__assign) || function () {
	    __assign$do = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$do.apply(this, arguments);
	};
	var SettingsInputCompositeFontIcon = React.forwardRef(function SettingsInputCompositeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$do({}, props, { ref: ref }), "settings_input_composite"));
	});

	var __assign$dp = (undefined && undefined.__assign) || function () {
	    __assign$dp = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dp.apply(this, arguments);
	};
	var SettingsInputHdmiFontIcon = React.forwardRef(function SettingsInputHdmiFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dp({}, props, { ref: ref }), "settings_input_hdmi"));
	});

	var __assign$dq = (undefined && undefined.__assign) || function () {
	    __assign$dq = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dq.apply(this, arguments);
	};
	var SettingsInputSvideoFontIcon = React.forwardRef(function SettingsInputSvideoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dq({}, props, { ref: ref }), "settings_input_svideo"));
	});

	var __assign$dr = (undefined && undefined.__assign) || function () {
	    __assign$dr = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dr.apply(this, arguments);
	};
	var SettingsOverscanFontIcon = React.forwardRef(function SettingsOverscanFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dr({}, props, { ref: ref }), "settings_overscan"));
	});

	var __assign$ds = (undefined && undefined.__assign) || function () {
	    __assign$ds = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ds.apply(this, arguments);
	};
	var SettingsPhoneFontIcon = React.forwardRef(function SettingsPhoneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ds({}, props, { ref: ref }), "settings_phone"));
	});

	var __assign$dt = (undefined && undefined.__assign) || function () {
	    __assign$dt = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dt.apply(this, arguments);
	};
	var SettingsPowerFontIcon = React.forwardRef(function SettingsPowerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dt({}, props, { ref: ref }), "settings_power"));
	});

	var __assign$du = (undefined && undefined.__assign) || function () {
	    __assign$du = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$du.apply(this, arguments);
	};
	var SettingsRemoteFontIcon = React.forwardRef(function SettingsRemoteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$du({}, props, { ref: ref }), "settings_remote"));
	});

	var __assign$dv = (undefined && undefined.__assign) || function () {
	    __assign$dv = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dv.apply(this, arguments);
	};
	var SettingsSystemDaydreamFontIcon = React.forwardRef(function SettingsSystemDaydreamFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dv({}, props, { ref: ref }), "settings_system_daydream"));
	});

	var __assign$dw = (undefined && undefined.__assign) || function () {
	    __assign$dw = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dw.apply(this, arguments);
	};
	var SettingsVoiceFontIcon = React.forwardRef(function SettingsVoiceFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dw({}, props, { ref: ref }), "settings_voice"));
	});

	var __assign$dx = (undefined && undefined.__assign) || function () {
	    __assign$dx = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dx.apply(this, arguments);
	};
	var SettingsFontIcon = React.forwardRef(function SettingsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dx({}, props, { ref: ref }), "settings"));
	});

	var __assign$dy = (undefined && undefined.__assign) || function () {
	    __assign$dy = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dy.apply(this, arguments);
	};
	var ShareFontIcon = React.forwardRef(function ShareFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dy({}, props, { ref: ref }), "share"));
	});

	var __assign$dz = (undefined && undefined.__assign) || function () {
	    __assign$dz = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dz.apply(this, arguments);
	};
	var ShopTwoFontIcon = React.forwardRef(function ShopTwoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dz({}, props, { ref: ref }), "shop_two"));
	});

	var __assign$dA = (undefined && undefined.__assign) || function () {
	    __assign$dA = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dA.apply(this, arguments);
	};
	var ShopFontIcon = React.forwardRef(function ShopFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dA({}, props, { ref: ref }), "shop"));
	});

	var __assign$dB = (undefined && undefined.__assign) || function () {
	    __assign$dB = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dB.apply(this, arguments);
	};
	var ShoppingBasketFontIcon = React.forwardRef(function ShoppingBasketFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dB({}, props, { ref: ref }), "shopping_basket"));
	});

	var __assign$dC = (undefined && undefined.__assign) || function () {
	    __assign$dC = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dC.apply(this, arguments);
	};
	var ShoppingCartFontIcon = React.forwardRef(function ShoppingCartFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dC({}, props, { ref: ref }), "shopping_cart"));
	});

	var __assign$dD = (undefined && undefined.__assign) || function () {
	    __assign$dD = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dD.apply(this, arguments);
	};
	var ShortTextFontIcon = React.forwardRef(function ShortTextFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dD({}, props, { ref: ref }), "short_text"));
	});

	var __assign$dE = (undefined && undefined.__assign) || function () {
	    __assign$dE = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dE.apply(this, arguments);
	};
	var ShowChartFontIcon = React.forwardRef(function ShowChartFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dE({}, props, { ref: ref }), "show_chart"));
	});

	var __assign$dF = (undefined && undefined.__assign) || function () {
	    __assign$dF = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dF.apply(this, arguments);
	};
	var ShuffleFontIcon = React.forwardRef(function ShuffleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dF({}, props, { ref: ref }), "shuffle"));
	});

	var __assign$dG = (undefined && undefined.__assign) || function () {
	    __assign$dG = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dG.apply(this, arguments);
	};
	var SignalCellular4BarFontIcon = React.forwardRef(function SignalCellular4BarFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dG({}, props, { ref: ref }), "signal_cellular_4_bar"));
	});

	var __assign$dH = (undefined && undefined.__assign) || function () {
	    __assign$dH = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dH.apply(this, arguments);
	};
	var SignalCellularConnectedNoInternet4BarFontIcon = React.forwardRef(function SignalCellularConnectedNoInternet4BarFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dH({}, props, { ref: ref }), "signal_cellular_connected_no_internet_4_bar"));
	});

	var __assign$dI = (undefined && undefined.__assign) || function () {
	    __assign$dI = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dI.apply(this, arguments);
	};
	var SignalCellularNoSimFontIcon = React.forwardRef(function SignalCellularNoSimFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dI({}, props, { ref: ref }), "signal_cellular_no_sim"));
	});

	var __assign$dJ = (undefined && undefined.__assign) || function () {
	    __assign$dJ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dJ.apply(this, arguments);
	};
	var SignalCellularNullFontIcon = React.forwardRef(function SignalCellularNullFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dJ({}, props, { ref: ref }), "signal_cellular_null"));
	});

	var __assign$dK = (undefined && undefined.__assign) || function () {
	    __assign$dK = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dK.apply(this, arguments);
	};
	var SignalCellularOffFontIcon = React.forwardRef(function SignalCellularOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dK({}, props, { ref: ref }), "signal_cellular_off"));
	});

	var __assign$dL = (undefined && undefined.__assign) || function () {
	    __assign$dL = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dL.apply(this, arguments);
	};
	var SignalWifi4BarLockFontIcon = React.forwardRef(function SignalWifi4BarLockFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dL({}, props, { ref: ref }), "signal_wifi_4_bar_lock"));
	});

	var __assign$dM = (undefined && undefined.__assign) || function () {
	    __assign$dM = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dM.apply(this, arguments);
	};
	var SignalWifi4BarFontIcon = React.forwardRef(function SignalWifi4BarFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dM({}, props, { ref: ref }), "signal_wifi_4_bar"));
	});

	var __assign$dN = (undefined && undefined.__assign) || function () {
	    __assign$dN = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dN.apply(this, arguments);
	};
	var SignalWifiOffFontIcon = React.forwardRef(function SignalWifiOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dN({}, props, { ref: ref }), "signal_wifi_off"));
	});

	var __assign$dO = (undefined && undefined.__assign) || function () {
	    __assign$dO = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dO.apply(this, arguments);
	};
	var SimCardAlertFontIcon = React.forwardRef(function SimCardAlertFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dO({}, props, { ref: ref }), "sim_card_alert"));
	});

	var __assign$dP = (undefined && undefined.__assign) || function () {
	    __assign$dP = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dP.apply(this, arguments);
	};
	var SimCardFontIcon = React.forwardRef(function SimCardFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dP({}, props, { ref: ref }), "sim_card"));
	});

	var __assign$dQ = (undefined && undefined.__assign) || function () {
	    __assign$dQ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dQ.apply(this, arguments);
	};
	var SkipNextFontIcon = React.forwardRef(function SkipNextFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dQ({}, props, { ref: ref }), "skip_next"));
	});

	var __assign$dR = (undefined && undefined.__assign) || function () {
	    __assign$dR = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dR.apply(this, arguments);
	};
	var SkipPreviousFontIcon = React.forwardRef(function SkipPreviousFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dR({}, props, { ref: ref }), "skip_previous"));
	});

	var __assign$dS = (undefined && undefined.__assign) || function () {
	    __assign$dS = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dS.apply(this, arguments);
	};
	var SlideshowFontIcon = React.forwardRef(function SlideshowFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dS({}, props, { ref: ref }), "slideshow"));
	});

	var __assign$dT = (undefined && undefined.__assign) || function () {
	    __assign$dT = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dT.apply(this, arguments);
	};
	var SlowMotionVideoFontIcon = React.forwardRef(function SlowMotionVideoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dT({}, props, { ref: ref }), "slow_motion_video"));
	});

	var __assign$dU = (undefined && undefined.__assign) || function () {
	    __assign$dU = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dU.apply(this, arguments);
	};
	var SmartphoneFontIcon = React.forwardRef(function SmartphoneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dU({}, props, { ref: ref }), "smartphone"));
	});

	var __assign$dV = (undefined && undefined.__assign) || function () {
	    __assign$dV = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dV.apply(this, arguments);
	};
	var SmokeFreeFontIcon = React.forwardRef(function SmokeFreeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dV({}, props, { ref: ref }), "smoke_free"));
	});

	var __assign$dW = (undefined && undefined.__assign) || function () {
	    __assign$dW = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dW.apply(this, arguments);
	};
	var SmokingRoomsFontIcon = React.forwardRef(function SmokingRoomsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dW({}, props, { ref: ref }), "smoking_rooms"));
	});

	var __assign$dX = (undefined && undefined.__assign) || function () {
	    __assign$dX = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dX.apply(this, arguments);
	};
	var SmsFailedFontIcon = React.forwardRef(function SmsFailedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dX({}, props, { ref: ref }), "sms_failed"));
	});

	var __assign$dY = (undefined && undefined.__assign) || function () {
	    __assign$dY = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dY.apply(this, arguments);
	};
	var SmsFontIcon = React.forwardRef(function SmsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dY({}, props, { ref: ref }), "sms"));
	});

	var __assign$dZ = (undefined && undefined.__assign) || function () {
	    __assign$dZ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$dZ.apply(this, arguments);
	};
	var SnoozeFontIcon = React.forwardRef(function SnoozeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$dZ({}, props, { ref: ref }), "snooze"));
	});

	var __assign$d_ = (undefined && undefined.__assign) || function () {
	    __assign$d_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d_.apply(this, arguments);
	};
	var SortByAlphaFontIcon = React.forwardRef(function SortByAlphaFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$d_({}, props, { ref: ref }), "sort_by_alpha"));
	});

	var __assign$d$ = (undefined && undefined.__assign) || function () {
	    __assign$d$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$d$.apply(this, arguments);
	};
	var SortFontIcon = React.forwardRef(function SortFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$d$({}, props, { ref: ref }), "sort"));
	});

	var __assign$e0 = (undefined && undefined.__assign) || function () {
	    __assign$e0 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e0.apply(this, arguments);
	};
	var SpaFontIcon = React.forwardRef(function SpaFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$e0({}, props, { ref: ref }), "spa"));
	});

	var __assign$e1 = (undefined && undefined.__assign) || function () {
	    __assign$e1 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e1.apply(this, arguments);
	};
	var SpaceBarFontIcon = React.forwardRef(function SpaceBarFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$e1({}, props, { ref: ref }), "space_bar"));
	});

	var __assign$e2 = (undefined && undefined.__assign) || function () {
	    __assign$e2 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e2.apply(this, arguments);
	};
	var SpeakerGroupFontIcon = React.forwardRef(function SpeakerGroupFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$e2({}, props, { ref: ref }), "speaker_group"));
	});

	var __assign$e3 = (undefined && undefined.__assign) || function () {
	    __assign$e3 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e3.apply(this, arguments);
	};
	var SpeakerNotesOffFontIcon = React.forwardRef(function SpeakerNotesOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$e3({}, props, { ref: ref }), "speaker_notes_off"));
	});

	var __assign$e4 = (undefined && undefined.__assign) || function () {
	    __assign$e4 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e4.apply(this, arguments);
	};
	var SpeakerNotesFontIcon = React.forwardRef(function SpeakerNotesFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$e4({}, props, { ref: ref }), "speaker_notes"));
	});

	var __assign$e5 = (undefined && undefined.__assign) || function () {
	    __assign$e5 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e5.apply(this, arguments);
	};
	var SpeakerPhoneFontIcon = React.forwardRef(function SpeakerPhoneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$e5({}, props, { ref: ref }), "speaker_phone"));
	});

	var __assign$e6 = (undefined && undefined.__assign) || function () {
	    __assign$e6 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e6.apply(this, arguments);
	};
	var SpeakerFontIcon = React.forwardRef(function SpeakerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$e6({}, props, { ref: ref }), "speaker"));
	});

	var __assign$e7 = (undefined && undefined.__assign) || function () {
	    __assign$e7 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e7.apply(this, arguments);
	};
	var SpellcheckFontIcon = React.forwardRef(function SpellcheckFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$e7({}, props, { ref: ref }), "spellcheck"));
	});

	var __assign$e8 = (undefined && undefined.__assign) || function () {
	    __assign$e8 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e8.apply(this, arguments);
	};
	var StarBorderFontIcon = React.forwardRef(function StarBorderFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$e8({}, props, { ref: ref }), "star_border"));
	});

	var __assign$e9 = (undefined && undefined.__assign) || function () {
	    __assign$e9 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e9.apply(this, arguments);
	};
	var StarHalfFontIcon = React.forwardRef(function StarHalfFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$e9({}, props, { ref: ref }), "star_half"));
	});

	var __assign$ea = (undefined && undefined.__assign) || function () {
	    __assign$ea = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ea.apply(this, arguments);
	};
	var StarFontIcon = React.forwardRef(function StarFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ea({}, props, { ref: ref }), "star"));
	});

	var __assign$eb = (undefined && undefined.__assign) || function () {
	    __assign$eb = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eb.apply(this, arguments);
	};
	var StarsFontIcon = React.forwardRef(function StarsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eb({}, props, { ref: ref }), "stars"));
	});

	var __assign$ec = (undefined && undefined.__assign) || function () {
	    __assign$ec = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ec.apply(this, arguments);
	};
	var StayCurrentLandscapeFontIcon = React.forwardRef(function StayCurrentLandscapeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ec({}, props, { ref: ref }), "stay_current_landscape"));
	});

	var __assign$ed = (undefined && undefined.__assign) || function () {
	    __assign$ed = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ed.apply(this, arguments);
	};
	var StayCurrentPortraitFontIcon = React.forwardRef(function StayCurrentPortraitFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ed({}, props, { ref: ref }), "stay_current_portrait"));
	});

	var __assign$ee = (undefined && undefined.__assign) || function () {
	    __assign$ee = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ee.apply(this, arguments);
	};
	var StayPrimaryLandscapeFontIcon = React.forwardRef(function StayPrimaryLandscapeFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ee({}, props, { ref: ref }), "stay_primary_landscape"));
	});

	var __assign$ef = (undefined && undefined.__assign) || function () {
	    __assign$ef = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ef.apply(this, arguments);
	};
	var StayPrimaryPortraitFontIcon = React.forwardRef(function StayPrimaryPortraitFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ef({}, props, { ref: ref }), "stay_primary_portrait"));
	});

	var __assign$eg = (undefined && undefined.__assign) || function () {
	    __assign$eg = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eg.apply(this, arguments);
	};
	var StopScreenShareFontIcon = React.forwardRef(function StopScreenShareFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eg({}, props, { ref: ref }), "stop_screen_share"));
	});

	var __assign$eh = (undefined && undefined.__assign) || function () {
	    __assign$eh = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eh.apply(this, arguments);
	};
	var StopFontIcon = React.forwardRef(function StopFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eh({}, props, { ref: ref }), "stop"));
	});

	var __assign$ei = (undefined && undefined.__assign) || function () {
	    __assign$ei = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ei.apply(this, arguments);
	};
	var StorageFontIcon = React.forwardRef(function StorageFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ei({}, props, { ref: ref }), "storage"));
	});

	var __assign$ej = (undefined && undefined.__assign) || function () {
	    __assign$ej = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ej.apply(this, arguments);
	};
	var StoreMallDirectoryFontIcon = React.forwardRef(function StoreMallDirectoryFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ej({}, props, { ref: ref }), "store_mall_directory"));
	});

	var __assign$ek = (undefined && undefined.__assign) || function () {
	    __assign$ek = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ek.apply(this, arguments);
	};
	var StoreFontIcon = React.forwardRef(function StoreFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ek({}, props, { ref: ref }), "store"));
	});

	var __assign$el = (undefined && undefined.__assign) || function () {
	    __assign$el = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$el.apply(this, arguments);
	};
	var StraightenFontIcon = React.forwardRef(function StraightenFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$el({}, props, { ref: ref }), "straighten"));
	});

	var __assign$em = (undefined && undefined.__assign) || function () {
	    __assign$em = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$em.apply(this, arguments);
	};
	var StreetviewFontIcon = React.forwardRef(function StreetviewFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$em({}, props, { ref: ref }), "streetview"));
	});

	var __assign$en = (undefined && undefined.__assign) || function () {
	    __assign$en = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$en.apply(this, arguments);
	};
	var StrikethroughSFontIcon = React.forwardRef(function StrikethroughSFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$en({}, props, { ref: ref }), "strikethrough_s"));
	});

	var __assign$eo = (undefined && undefined.__assign) || function () {
	    __assign$eo = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eo.apply(this, arguments);
	};
	var StyleFontIcon = React.forwardRef(function StyleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eo({}, props, { ref: ref }), "style"));
	});

	var __assign$ep = (undefined && undefined.__assign) || function () {
	    __assign$ep = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ep.apply(this, arguments);
	};
	var SubdirectoryArrowLeftFontIcon = React.forwardRef(function SubdirectoryArrowLeftFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ep({}, props, { ref: ref }), "subdirectory_arrow_left"));
	});

	var __assign$eq = (undefined && undefined.__assign) || function () {
	    __assign$eq = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eq.apply(this, arguments);
	};
	var SubdirectoryArrowRightFontIcon = React.forwardRef(function SubdirectoryArrowRightFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eq({}, props, { ref: ref }), "subdirectory_arrow_right"));
	});

	var __assign$er = (undefined && undefined.__assign) || function () {
	    __assign$er = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$er.apply(this, arguments);
	};
	var SubjectFontIcon = React.forwardRef(function SubjectFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$er({}, props, { ref: ref }), "subject"));
	});

	var __assign$es = (undefined && undefined.__assign) || function () {
	    __assign$es = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$es.apply(this, arguments);
	};
	var SubscriptionsFontIcon = React.forwardRef(function SubscriptionsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$es({}, props, { ref: ref }), "subscriptions"));
	});

	var __assign$et = (undefined && undefined.__assign) || function () {
	    __assign$et = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$et.apply(this, arguments);
	};
	var SubtitlesFontIcon = React.forwardRef(function SubtitlesFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$et({}, props, { ref: ref }), "subtitles"));
	});

	var __assign$eu = (undefined && undefined.__assign) || function () {
	    __assign$eu = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eu.apply(this, arguments);
	};
	var SubwayFontIcon = React.forwardRef(function SubwayFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eu({}, props, { ref: ref }), "subway"));
	});

	var __assign$ev = (undefined && undefined.__assign) || function () {
	    __assign$ev = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ev.apply(this, arguments);
	};
	var SupervisorAccountFontIcon = React.forwardRef(function SupervisorAccountFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ev({}, props, { ref: ref }), "supervisor_account"));
	});

	var __assign$ew = (undefined && undefined.__assign) || function () {
	    __assign$ew = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ew.apply(this, arguments);
	};
	var SurroundSoundFontIcon = React.forwardRef(function SurroundSoundFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ew({}, props, { ref: ref }), "surround_sound"));
	});

	var __assign$ex = (undefined && undefined.__assign) || function () {
	    __assign$ex = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ex.apply(this, arguments);
	};
	var SwapCallsFontIcon = React.forwardRef(function SwapCallsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ex({}, props, { ref: ref }), "swap_calls"));
	});

	var __assign$ey = (undefined && undefined.__assign) || function () {
	    __assign$ey = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ey.apply(this, arguments);
	};
	var SwapHorizFontIcon = React.forwardRef(function SwapHorizFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ey({}, props, { ref: ref }), "swap_horiz"));
	});

	var __assign$ez = (undefined && undefined.__assign) || function () {
	    __assign$ez = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ez.apply(this, arguments);
	};
	var SwapVertFontIcon = React.forwardRef(function SwapVertFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ez({}, props, { ref: ref }), "swap_vert"));
	});

	var __assign$eA = (undefined && undefined.__assign) || function () {
	    __assign$eA = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eA.apply(this, arguments);
	};
	var SwapVerticalCircleFontIcon = React.forwardRef(function SwapVerticalCircleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eA({}, props, { ref: ref }), "swap_vertical_circle"));
	});

	var __assign$eB = (undefined && undefined.__assign) || function () {
	    __assign$eB = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eB.apply(this, arguments);
	};
	var SwitchCameraFontIcon = React.forwardRef(function SwitchCameraFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eB({}, props, { ref: ref }), "switch_camera"));
	});

	var __assign$eC = (undefined && undefined.__assign) || function () {
	    __assign$eC = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eC.apply(this, arguments);
	};
	var SwitchVideoFontIcon = React.forwardRef(function SwitchVideoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eC({}, props, { ref: ref }), "switch_video"));
	});

	var __assign$eD = (undefined && undefined.__assign) || function () {
	    __assign$eD = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eD.apply(this, arguments);
	};
	var SyncDisabledFontIcon = React.forwardRef(function SyncDisabledFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eD({}, props, { ref: ref }), "sync_disabled"));
	});

	var __assign$eE = (undefined && undefined.__assign) || function () {
	    __assign$eE = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eE.apply(this, arguments);
	};
	var SyncProblemFontIcon = React.forwardRef(function SyncProblemFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eE({}, props, { ref: ref }), "sync_problem"));
	});

	var __assign$eF = (undefined && undefined.__assign) || function () {
	    __assign$eF = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eF.apply(this, arguments);
	};
	var SyncFontIcon = React.forwardRef(function SyncFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eF({}, props, { ref: ref }), "sync"));
	});

	var __assign$eG = (undefined && undefined.__assign) || function () {
	    __assign$eG = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eG.apply(this, arguments);
	};
	var SystemUpdateAltFontIcon = React.forwardRef(function SystemUpdateAltFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eG({}, props, { ref: ref }), "system_update_alt"));
	});

	var __assign$eH = (undefined && undefined.__assign) || function () {
	    __assign$eH = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eH.apply(this, arguments);
	};
	var SystemUpdateFontIcon = React.forwardRef(function SystemUpdateFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eH({}, props, { ref: ref }), "system_update"));
	});

	var __assign$eI = (undefined && undefined.__assign) || function () {
	    __assign$eI = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eI.apply(this, arguments);
	};
	var TabUnselectedFontIcon = React.forwardRef(function TabUnselectedFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eI({}, props, { ref: ref }), "tab_unselected"));
	});

	var __assign$eJ = (undefined && undefined.__assign) || function () {
	    __assign$eJ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eJ.apply(this, arguments);
	};
	var TabFontIcon = React.forwardRef(function TabFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eJ({}, props, { ref: ref }), "tab"));
	});

	var __assign$eK = (undefined && undefined.__assign) || function () {
	    __assign$eK = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eK.apply(this, arguments);
	};
	var TabletAndroidFontIcon = React.forwardRef(function TabletAndroidFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eK({}, props, { ref: ref }), "tablet_android"));
	});

	var __assign$eL = (undefined && undefined.__assign) || function () {
	    __assign$eL = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eL.apply(this, arguments);
	};
	var TabletMacFontIcon = React.forwardRef(function TabletMacFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eL({}, props, { ref: ref }), "tablet_mac"));
	});

	var __assign$eM = (undefined && undefined.__assign) || function () {
	    __assign$eM = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eM.apply(this, arguments);
	};
	var TabletFontIcon = React.forwardRef(function TabletFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eM({}, props, { ref: ref }), "tablet"));
	});

	var __assign$eN = (undefined && undefined.__assign) || function () {
	    __assign$eN = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eN.apply(this, arguments);
	};
	var TagFacesFontIcon = React.forwardRef(function TagFacesFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eN({}, props, { ref: ref }), "tag_faces"));
	});

	var __assign$eO = (undefined && undefined.__assign) || function () {
	    __assign$eO = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eO.apply(this, arguments);
	};
	var TapAndPlayFontIcon = React.forwardRef(function TapAndPlayFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eO({}, props, { ref: ref }), "tap_and_play"));
	});

	var __assign$eP = (undefined && undefined.__assign) || function () {
	    __assign$eP = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eP.apply(this, arguments);
	};
	var TerrainFontIcon = React.forwardRef(function TerrainFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eP({}, props, { ref: ref }), "terrain"));
	});

	var __assign$eQ = (undefined && undefined.__assign) || function () {
	    __assign$eQ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eQ.apply(this, arguments);
	};
	var TextFieldsFontIcon = React.forwardRef(function TextFieldsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eQ({}, props, { ref: ref }), "text_fields"));
	});

	var __assign$eR = (undefined && undefined.__assign) || function () {
	    __assign$eR = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eR.apply(this, arguments);
	};
	var TextFormatFontIcon = React.forwardRef(function TextFormatFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eR({}, props, { ref: ref }), "text_format"));
	});

	var __assign$eS = (undefined && undefined.__assign) || function () {
	    __assign$eS = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eS.apply(this, arguments);
	};
	var TextsmsFontIcon = React.forwardRef(function TextsmsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eS({}, props, { ref: ref }), "textsms"));
	});

	var __assign$eT = (undefined && undefined.__assign) || function () {
	    __assign$eT = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eT.apply(this, arguments);
	};
	var TextureFontIcon = React.forwardRef(function TextureFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eT({}, props, { ref: ref }), "texture"));
	});

	var __assign$eU = (undefined && undefined.__assign) || function () {
	    __assign$eU = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eU.apply(this, arguments);
	};
	var TheatersFontIcon = React.forwardRef(function TheatersFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eU({}, props, { ref: ref }), "theaters"));
	});

	var __assign$eV = (undefined && undefined.__assign) || function () {
	    __assign$eV = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eV.apply(this, arguments);
	};
	var ThumbDownFontIcon = React.forwardRef(function ThumbDownFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eV({}, props, { ref: ref }), "thumb_down"));
	});

	var __assign$eW = (undefined && undefined.__assign) || function () {
	    __assign$eW = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eW.apply(this, arguments);
	};
	var ThumbUpFontIcon = React.forwardRef(function ThumbUpFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eW({}, props, { ref: ref }), "thumb_up"));
	});

	var __assign$eX = (undefined && undefined.__assign) || function () {
	    __assign$eX = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eX.apply(this, arguments);
	};
	var ThumbsUpDownFontIcon = React.forwardRef(function ThumbsUpDownFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eX({}, props, { ref: ref }), "thumbs_up_down"));
	});

	var __assign$eY = (undefined && undefined.__assign) || function () {
	    __assign$eY = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eY.apply(this, arguments);
	};
	var TimeToLeaveFontIcon = React.forwardRef(function TimeToLeaveFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eY({}, props, { ref: ref }), "time_to_leave"));
	});

	var __assign$eZ = (undefined && undefined.__assign) || function () {
	    __assign$eZ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$eZ.apply(this, arguments);
	};
	var TimelapseFontIcon = React.forwardRef(function TimelapseFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$eZ({}, props, { ref: ref }), "timelapse"));
	});

	var __assign$e_ = (undefined && undefined.__assign) || function () {
	    __assign$e_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e_.apply(this, arguments);
	};
	var TimelineFontIcon = React.forwardRef(function TimelineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$e_({}, props, { ref: ref }), "timeline"));
	});

	var __assign$e$ = (undefined && undefined.__assign) || function () {
	    __assign$e$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$e$.apply(this, arguments);
	};
	var Timer10FontIcon = React.forwardRef(function Timer10FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$e$({}, props, { ref: ref }), "timer_10"));
	});

	var __assign$f0 = (undefined && undefined.__assign) || function () {
	    __assign$f0 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f0.apply(this, arguments);
	};
	var Timer3FontIcon = React.forwardRef(function Timer3FontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$f0({}, props, { ref: ref }), "timer_3"));
	});

	var __assign$f1 = (undefined && undefined.__assign) || function () {
	    __assign$f1 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f1.apply(this, arguments);
	};
	var TimerOffFontIcon = React.forwardRef(function TimerOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$f1({}, props, { ref: ref }), "timer_off"));
	});

	var __assign$f2 = (undefined && undefined.__assign) || function () {
	    __assign$f2 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f2.apply(this, arguments);
	};
	var TimerFontIcon = React.forwardRef(function TimerFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$f2({}, props, { ref: ref }), "timer"));
	});

	var __assign$f3 = (undefined && undefined.__assign) || function () {
	    __assign$f3 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f3.apply(this, arguments);
	};
	var TitleFontIcon = React.forwardRef(function TitleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$f3({}, props, { ref: ref }), "title"));
	});

	var __assign$f4 = (undefined && undefined.__assign) || function () {
	    __assign$f4 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f4.apply(this, arguments);
	};
	var TocFontIcon = React.forwardRef(function TocFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$f4({}, props, { ref: ref }), "toc"));
	});

	var __assign$f5 = (undefined && undefined.__assign) || function () {
	    __assign$f5 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f5.apply(this, arguments);
	};
	var TodayFontIcon = React.forwardRef(function TodayFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$f5({}, props, { ref: ref }), "today"));
	});

	var __assign$f6 = (undefined && undefined.__assign) || function () {
	    __assign$f6 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f6.apply(this, arguments);
	};
	var TollFontIcon = React.forwardRef(function TollFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$f6({}, props, { ref: ref }), "toll"));
	});

	var __assign$f7 = (undefined && undefined.__assign) || function () {
	    __assign$f7 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f7.apply(this, arguments);
	};
	var TonalityFontIcon = React.forwardRef(function TonalityFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$f7({}, props, { ref: ref }), "tonality"));
	});

	var __assign$f8 = (undefined && undefined.__assign) || function () {
	    __assign$f8 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f8.apply(this, arguments);
	};
	var TouchAppFontIcon = React.forwardRef(function TouchAppFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$f8({}, props, { ref: ref }), "touch_app"));
	});

	var __assign$f9 = (undefined && undefined.__assign) || function () {
	    __assign$f9 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f9.apply(this, arguments);
	};
	var ToysFontIcon = React.forwardRef(function ToysFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$f9({}, props, { ref: ref }), "toys"));
	});

	var __assign$fa = (undefined && undefined.__assign) || function () {
	    __assign$fa = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fa.apply(this, arguments);
	};
	var TrackChangesFontIcon = React.forwardRef(function TrackChangesFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fa({}, props, { ref: ref }), "track_changes"));
	});

	var __assign$fb = (undefined && undefined.__assign) || function () {
	    __assign$fb = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fb.apply(this, arguments);
	};
	var TrafficFontIcon = React.forwardRef(function TrafficFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fb({}, props, { ref: ref }), "traffic"));
	});

	var __assign$fc = (undefined && undefined.__assign) || function () {
	    __assign$fc = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fc.apply(this, arguments);
	};
	var TrainFontIcon = React.forwardRef(function TrainFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fc({}, props, { ref: ref }), "train"));
	});

	var __assign$fd = (undefined && undefined.__assign) || function () {
	    __assign$fd = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fd.apply(this, arguments);
	};
	var TramFontIcon = React.forwardRef(function TramFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fd({}, props, { ref: ref }), "tram"));
	});

	var __assign$fe = (undefined && undefined.__assign) || function () {
	    __assign$fe = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fe.apply(this, arguments);
	};
	var TransferWithinAStationFontIcon = React.forwardRef(function TransferWithinAStationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fe({}, props, { ref: ref }), "transfer_within_a_station"));
	});

	var __assign$ff = (undefined && undefined.__assign) || function () {
	    __assign$ff = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ff.apply(this, arguments);
	};
	var TransformFontIcon = React.forwardRef(function TransformFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ff({}, props, { ref: ref }), "transform"));
	});

	var __assign$fg = (undefined && undefined.__assign) || function () {
	    __assign$fg = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fg.apply(this, arguments);
	};
	var TranslateFontIcon = React.forwardRef(function TranslateFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fg({}, props, { ref: ref }), "translate"));
	});

	var __assign$fh = (undefined && undefined.__assign) || function () {
	    __assign$fh = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fh.apply(this, arguments);
	};
	var TrendingDownFontIcon = React.forwardRef(function TrendingDownFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fh({}, props, { ref: ref }), "trending_down"));
	});

	var __assign$fi = (undefined && undefined.__assign) || function () {
	    __assign$fi = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fi.apply(this, arguments);
	};
	var TrendingFlatFontIcon = React.forwardRef(function TrendingFlatFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fi({}, props, { ref: ref }), "trending_flat"));
	});

	var __assign$fj = (undefined && undefined.__assign) || function () {
	    __assign$fj = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fj.apply(this, arguments);
	};
	var TrendingUpFontIcon = React.forwardRef(function TrendingUpFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fj({}, props, { ref: ref }), "trending_up"));
	});

	var __assign$fk = (undefined && undefined.__assign) || function () {
	    __assign$fk = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fk.apply(this, arguments);
	};
	var TuneFontIcon = React.forwardRef(function TuneFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fk({}, props, { ref: ref }), "tune"));
	});

	var __assign$fl = (undefined && undefined.__assign) || function () {
	    __assign$fl = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fl.apply(this, arguments);
	};
	var TurnedInNotFontIcon = React.forwardRef(function TurnedInNotFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fl({}, props, { ref: ref }), "turned_in_not"));
	});

	var __assign$fm = (undefined && undefined.__assign) || function () {
	    __assign$fm = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fm.apply(this, arguments);
	};
	var TurnedInFontIcon = React.forwardRef(function TurnedInFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fm({}, props, { ref: ref }), "turned_in"));
	});

	var __assign$fn = (undefined && undefined.__assign) || function () {
	    __assign$fn = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fn.apply(this, arguments);
	};
	var TvFontIcon = React.forwardRef(function TvFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fn({}, props, { ref: ref }), "tv"));
	});

	var __assign$fo = (undefined && undefined.__assign) || function () {
	    __assign$fo = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fo.apply(this, arguments);
	};
	var UnarchiveFontIcon = React.forwardRef(function UnarchiveFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fo({}, props, { ref: ref }), "unarchive"));
	});

	var __assign$fp = (undefined && undefined.__assign) || function () {
	    __assign$fp = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fp.apply(this, arguments);
	};
	var UndoFontIcon = React.forwardRef(function UndoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fp({}, props, { ref: ref }), "undo"));
	});

	var __assign$fq = (undefined && undefined.__assign) || function () {
	    __assign$fq = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fq.apply(this, arguments);
	};
	var UnfoldLessFontIcon = React.forwardRef(function UnfoldLessFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fq({}, props, { ref: ref }), "unfold_less"));
	});

	var __assign$fr = (undefined && undefined.__assign) || function () {
	    __assign$fr = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fr.apply(this, arguments);
	};
	var UnfoldMoreFontIcon = React.forwardRef(function UnfoldMoreFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fr({}, props, { ref: ref }), "unfold_more"));
	});

	var __assign$fs = (undefined && undefined.__assign) || function () {
	    __assign$fs = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fs.apply(this, arguments);
	};
	var UpdateFontIcon = React.forwardRef(function UpdateFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fs({}, props, { ref: ref }), "update"));
	});

	var __assign$ft = (undefined && undefined.__assign) || function () {
	    __assign$ft = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ft.apply(this, arguments);
	};
	var UsbFontIcon = React.forwardRef(function UsbFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ft({}, props, { ref: ref }), "usb"));
	});

	var __assign$fu = (undefined && undefined.__assign) || function () {
	    __assign$fu = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fu.apply(this, arguments);
	};
	var VerifiedUserFontIcon = React.forwardRef(function VerifiedUserFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fu({}, props, { ref: ref }), "verified_user"));
	});

	var __assign$fv = (undefined && undefined.__assign) || function () {
	    __assign$fv = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fv.apply(this, arguments);
	};
	var VerticalAlignBottomFontIcon = React.forwardRef(function VerticalAlignBottomFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fv({}, props, { ref: ref }), "vertical_align_bottom"));
	});

	var __assign$fw = (undefined && undefined.__assign) || function () {
	    __assign$fw = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fw.apply(this, arguments);
	};
	var VerticalAlignCenterFontIcon = React.forwardRef(function VerticalAlignCenterFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fw({}, props, { ref: ref }), "vertical_align_center"));
	});

	var __assign$fx = (undefined && undefined.__assign) || function () {
	    __assign$fx = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fx.apply(this, arguments);
	};
	var VerticalAlignTopFontIcon = React.forwardRef(function VerticalAlignTopFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fx({}, props, { ref: ref }), "vertical_align_top"));
	});

	var __assign$fy = (undefined && undefined.__assign) || function () {
	    __assign$fy = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fy.apply(this, arguments);
	};
	var VibrationFontIcon = React.forwardRef(function VibrationFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fy({}, props, { ref: ref }), "vibration"));
	});

	var __assign$fz = (undefined && undefined.__assign) || function () {
	    __assign$fz = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fz.apply(this, arguments);
	};
	var VideoCallFontIcon = React.forwardRef(function VideoCallFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fz({}, props, { ref: ref }), "video_call"));
	});

	var __assign$fA = (undefined && undefined.__assign) || function () {
	    __assign$fA = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fA.apply(this, arguments);
	};
	var VideoLabelFontIcon = React.forwardRef(function VideoLabelFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fA({}, props, { ref: ref }), "video_label"));
	});

	var __assign$fB = (undefined && undefined.__assign) || function () {
	    __assign$fB = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fB.apply(this, arguments);
	};
	var VideoLibraryFontIcon = React.forwardRef(function VideoLibraryFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fB({}, props, { ref: ref }), "video_library"));
	});

	var __assign$fC = (undefined && undefined.__assign) || function () {
	    __assign$fC = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fC.apply(this, arguments);
	};
	var VideocamOffFontIcon = React.forwardRef(function VideocamOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fC({}, props, { ref: ref }), "videocam_off"));
	});

	var __assign$fD = (undefined && undefined.__assign) || function () {
	    __assign$fD = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fD.apply(this, arguments);
	};
	var VideocamFontIcon = React.forwardRef(function VideocamFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fD({}, props, { ref: ref }), "videocam"));
	});

	var __assign$fE = (undefined && undefined.__assign) || function () {
	    __assign$fE = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fE.apply(this, arguments);
	};
	var VideogameAssetFontIcon = React.forwardRef(function VideogameAssetFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fE({}, props, { ref: ref }), "videogame_asset"));
	});

	var __assign$fF = (undefined && undefined.__assign) || function () {
	    __assign$fF = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fF.apply(this, arguments);
	};
	var ViewAgendaFontIcon = React.forwardRef(function ViewAgendaFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fF({}, props, { ref: ref }), "view_agenda"));
	});

	var __assign$fG = (undefined && undefined.__assign) || function () {
	    __assign$fG = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fG.apply(this, arguments);
	};
	var ViewArrayFontIcon = React.forwardRef(function ViewArrayFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fG({}, props, { ref: ref }), "view_array"));
	});

	var __assign$fH = (undefined && undefined.__assign) || function () {
	    __assign$fH = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fH.apply(this, arguments);
	};
	var ViewCarouselFontIcon = React.forwardRef(function ViewCarouselFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fH({}, props, { ref: ref }), "view_carousel"));
	});

	var __assign$fI = (undefined && undefined.__assign) || function () {
	    __assign$fI = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fI.apply(this, arguments);
	};
	var ViewColumnFontIcon = React.forwardRef(function ViewColumnFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fI({}, props, { ref: ref }), "view_column"));
	});

	var __assign$fJ = (undefined && undefined.__assign) || function () {
	    __assign$fJ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fJ.apply(this, arguments);
	};
	var ViewComfyFontIcon = React.forwardRef(function ViewComfyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fJ({}, props, { ref: ref }), "view_comfy"));
	});

	var __assign$fK = (undefined && undefined.__assign) || function () {
	    __assign$fK = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fK.apply(this, arguments);
	};
	var ViewCompactFontIcon = React.forwardRef(function ViewCompactFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fK({}, props, { ref: ref }), "view_compact"));
	});

	var __assign$fL = (undefined && undefined.__assign) || function () {
	    __assign$fL = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fL.apply(this, arguments);
	};
	var ViewDayFontIcon = React.forwardRef(function ViewDayFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fL({}, props, { ref: ref }), "view_day"));
	});

	var __assign$fM = (undefined && undefined.__assign) || function () {
	    __assign$fM = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fM.apply(this, arguments);
	};
	var ViewHeadlineFontIcon = React.forwardRef(function ViewHeadlineFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fM({}, props, { ref: ref }), "view_headline"));
	});

	var __assign$fN = (undefined && undefined.__assign) || function () {
	    __assign$fN = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fN.apply(this, arguments);
	};
	var ViewListFontIcon = React.forwardRef(function ViewListFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fN({}, props, { ref: ref }), "view_list"));
	});

	var __assign$fO = (undefined && undefined.__assign) || function () {
	    __assign$fO = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fO.apply(this, arguments);
	};
	var ViewModuleFontIcon = React.forwardRef(function ViewModuleFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fO({}, props, { ref: ref }), "view_module"));
	});

	var __assign$fP = (undefined && undefined.__assign) || function () {
	    __assign$fP = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fP.apply(this, arguments);
	};
	var ViewQuiltFontIcon = React.forwardRef(function ViewQuiltFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fP({}, props, { ref: ref }), "view_quilt"));
	});

	var __assign$fQ = (undefined && undefined.__assign) || function () {
	    __assign$fQ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fQ.apply(this, arguments);
	};
	var ViewStreamFontIcon = React.forwardRef(function ViewStreamFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fQ({}, props, { ref: ref }), "view_stream"));
	});

	var __assign$fR = (undefined && undefined.__assign) || function () {
	    __assign$fR = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fR.apply(this, arguments);
	};
	var ViewWeekFontIcon = React.forwardRef(function ViewWeekFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fR({}, props, { ref: ref }), "view_week"));
	});

	var __assign$fS = (undefined && undefined.__assign) || function () {
	    __assign$fS = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fS.apply(this, arguments);
	};
	var VignetteFontIcon = React.forwardRef(function VignetteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fS({}, props, { ref: ref }), "vignette"));
	});

	var __assign$fT = (undefined && undefined.__assign) || function () {
	    __assign$fT = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fT.apply(this, arguments);
	};
	var VisibilityOffFontIcon = React.forwardRef(function VisibilityOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fT({}, props, { ref: ref }), "visibility_off"));
	});

	var __assign$fU = (undefined && undefined.__assign) || function () {
	    __assign$fU = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fU.apply(this, arguments);
	};
	var VisibilityFontIcon = React.forwardRef(function VisibilityFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fU({}, props, { ref: ref }), "visibility"));
	});

	var __assign$fV = (undefined && undefined.__assign) || function () {
	    __assign$fV = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fV.apply(this, arguments);
	};
	var VoiceChatFontIcon = React.forwardRef(function VoiceChatFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fV({}, props, { ref: ref }), "voice_chat"));
	});

	var __assign$fW = (undefined && undefined.__assign) || function () {
	    __assign$fW = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fW.apply(this, arguments);
	};
	var VoicemailFontIcon = React.forwardRef(function VoicemailFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fW({}, props, { ref: ref }), "voicemail"));
	});

	var __assign$fX = (undefined && undefined.__assign) || function () {
	    __assign$fX = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fX.apply(this, arguments);
	};
	var VolumeDownFontIcon = React.forwardRef(function VolumeDownFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fX({}, props, { ref: ref }), "volume_down"));
	});

	var __assign$fY = (undefined && undefined.__assign) || function () {
	    __assign$fY = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fY.apply(this, arguments);
	};
	var VolumeMuteFontIcon = React.forwardRef(function VolumeMuteFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fY({}, props, { ref: ref }), "volume_mute"));
	});

	var __assign$fZ = (undefined && undefined.__assign) || function () {
	    __assign$fZ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$fZ.apply(this, arguments);
	};
	var VolumeOffFontIcon = React.forwardRef(function VolumeOffFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$fZ({}, props, { ref: ref }), "volume_off"));
	});

	var __assign$f_ = (undefined && undefined.__assign) || function () {
	    __assign$f_ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f_.apply(this, arguments);
	};
	var VolumeUpFontIcon = React.forwardRef(function VolumeUpFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$f_({}, props, { ref: ref }), "volume_up"));
	});

	var __assign$f$ = (undefined && undefined.__assign) || function () {
	    __assign$f$ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$f$.apply(this, arguments);
	};
	var VpnKeyFontIcon = React.forwardRef(function VpnKeyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$f$({}, props, { ref: ref }), "vpn_key"));
	});

	var __assign$g0 = (undefined && undefined.__assign) || function () {
	    __assign$g0 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$g0.apply(this, arguments);
	};
	var VpnLockFontIcon = React.forwardRef(function VpnLockFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$g0({}, props, { ref: ref }), "vpn_lock"));
	});

	var __assign$g1 = (undefined && undefined.__assign) || function () {
	    __assign$g1 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$g1.apply(this, arguments);
	};
	var WallpaperFontIcon = React.forwardRef(function WallpaperFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$g1({}, props, { ref: ref }), "wallpaper"));
	});

	var __assign$g2 = (undefined && undefined.__assign) || function () {
	    __assign$g2 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$g2.apply(this, arguments);
	};
	var WarningFontIcon = React.forwardRef(function WarningFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$g2({}, props, { ref: ref }), "warning"));
	});

	var __assign$g3 = (undefined && undefined.__assign) || function () {
	    __assign$g3 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$g3.apply(this, arguments);
	};
	var WatchLaterFontIcon = React.forwardRef(function WatchLaterFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$g3({}, props, { ref: ref }), "watch_later"));
	});

	var __assign$g4 = (undefined && undefined.__assign) || function () {
	    __assign$g4 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$g4.apply(this, arguments);
	};
	var WatchFontIcon = React.forwardRef(function WatchFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$g4({}, props, { ref: ref }), "watch"));
	});

	var __assign$g5 = (undefined && undefined.__assign) || function () {
	    __assign$g5 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$g5.apply(this, arguments);
	};
	var WbAutoFontIcon = React.forwardRef(function WbAutoFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$g5({}, props, { ref: ref }), "wb_auto"));
	});

	var __assign$g6 = (undefined && undefined.__assign) || function () {
	    __assign$g6 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$g6.apply(this, arguments);
	};
	var WbCloudyFontIcon = React.forwardRef(function WbCloudyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$g6({}, props, { ref: ref }), "wb_cloudy"));
	});

	var __assign$g7 = (undefined && undefined.__assign) || function () {
	    __assign$g7 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$g7.apply(this, arguments);
	};
	var WbIncandescentFontIcon = React.forwardRef(function WbIncandescentFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$g7({}, props, { ref: ref }), "wb_incandescent"));
	});

	var __assign$g8 = (undefined && undefined.__assign) || function () {
	    __assign$g8 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$g8.apply(this, arguments);
	};
	var WbIridescentFontIcon = React.forwardRef(function WbIridescentFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$g8({}, props, { ref: ref }), "wb_iridescent"));
	});

	var __assign$g9 = (undefined && undefined.__assign) || function () {
	    __assign$g9 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$g9.apply(this, arguments);
	};
	var WbSunnyFontIcon = React.forwardRef(function WbSunnyFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$g9({}, props, { ref: ref }), "wb_sunny"));
	});

	var __assign$ga = (undefined && undefined.__assign) || function () {
	    __assign$ga = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ga.apply(this, arguments);
	};
	var WcFontIcon = React.forwardRef(function WcFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ga({}, props, { ref: ref }), "wc"));
	});

	var __assign$gb = (undefined && undefined.__assign) || function () {
	    __assign$gb = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gb.apply(this, arguments);
	};
	var WebAssetFontIcon = React.forwardRef(function WebAssetFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$gb({}, props, { ref: ref }), "web_asset"));
	});

	var __assign$gc = (undefined && undefined.__assign) || function () {
	    __assign$gc = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gc.apply(this, arguments);
	};
	var WebFontIcon = React.forwardRef(function WebFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$gc({}, props, { ref: ref }), "web"));
	});

	var __assign$gd = (undefined && undefined.__assign) || function () {
	    __assign$gd = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gd.apply(this, arguments);
	};
	var WeekendFontIcon = React.forwardRef(function WeekendFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$gd({}, props, { ref: ref }), "weekend"));
	});

	var __assign$ge = (undefined && undefined.__assign) || function () {
	    __assign$ge = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$ge.apply(this, arguments);
	};
	var WhatshotFontIcon = React.forwardRef(function WhatshotFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$ge({}, props, { ref: ref }), "whatshot"));
	});

	var __assign$gf = (undefined && undefined.__assign) || function () {
	    __assign$gf = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gf.apply(this, arguments);
	};
	var WidgetsFontIcon = React.forwardRef(function WidgetsFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$gf({}, props, { ref: ref }), "widgets"));
	});

	var __assign$gg = (undefined && undefined.__assign) || function () {
	    __assign$gg = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gg.apply(this, arguments);
	};
	var WifiLockFontIcon = React.forwardRef(function WifiLockFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$gg({}, props, { ref: ref }), "wifi_lock"));
	});

	var __assign$gh = (undefined && undefined.__assign) || function () {
	    __assign$gh = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gh.apply(this, arguments);
	};
	var WifiTetheringFontIcon = React.forwardRef(function WifiTetheringFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$gh({}, props, { ref: ref }), "wifi_tethering"));
	});

	var __assign$gi = (undefined && undefined.__assign) || function () {
	    __assign$gi = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gi.apply(this, arguments);
	};
	var WifiFontIcon = React.forwardRef(function WifiFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$gi({}, props, { ref: ref }), "wifi"));
	});

	var __assign$gj = (undefined && undefined.__assign) || function () {
	    __assign$gj = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gj.apply(this, arguments);
	};
	var WorkFontIcon = React.forwardRef(function WorkFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$gj({}, props, { ref: ref }), "work"));
	});

	var __assign$gk = (undefined && undefined.__assign) || function () {
	    __assign$gk = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gk.apply(this, arguments);
	};
	var WrapTextFontIcon = React.forwardRef(function WrapTextFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$gk({}, props, { ref: ref }), "wrap_text"));
	});

	var __assign$gl = (undefined && undefined.__assign) || function () {
	    __assign$gl = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gl.apply(this, arguments);
	};
	var YoutubeSearchedForFontIcon = React.forwardRef(function YoutubeSearchedForFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$gl({}, props, { ref: ref }), "youtube_searched_for"));
	});

	var __assign$gm = (undefined && undefined.__assign) || function () {
	    __assign$gm = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gm.apply(this, arguments);
	};
	var ZoomInFontIcon = React.forwardRef(function ZoomInFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$gm({}, props, { ref: ref }), "zoom_in"));
	});

	var __assign$gn = (undefined && undefined.__assign) || function () {
	    __assign$gn = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gn.apply(this, arguments);
	};
	var ZoomOutMapFontIcon = React.forwardRef(function ZoomOutMapFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$gn({}, props, { ref: ref }), "zoom_out_map"));
	});

	var __assign$go = (undefined && undefined.__assign) || function () {
	    __assign$go = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$go.apply(this, arguments);
	};
	var ZoomOutFontIcon = React.forwardRef(function ZoomOutFontIcon(props, ref) {
	    return (React__default.createElement(FontIcon, __assign$go({}, props, { ref: ref }), "zoom_out"));
	});

	var __assign$gp = (undefined && undefined.__assign) || function () {
	    __assign$gp = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gp.apply(this, arguments);
	};
	var __rest$1z = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$13 = bem("rmd-media-container");
	/**
	 * The `MediaContainer` component is used to make responsive images and videos
	 * within your app. This component also allows for focing a specific aspect
	 * ratio for these elements with both the `height` and `width` props are
	 * provided.
	 */
	var MediaContainer = React.forwardRef(function MediaContainer(_a, ref) {
	    var className = _a.className, height = _a.height, width = _a.width, children = _a.children, _b = _a.auto, auto = _b === void 0 ? true : _b, _c = _a.fullWidth, fullWidth = _c === void 0 ? false : _c, props = __rest$1z(_a, ["className", "height", "width", "children", "auto", "fullWidth"]);
	    var aspectRatio = height && width ? "rmd-media-container--" + width + "-" + height : "";
	    return (React__default.createElement("div", __assign$gp({}, props, { ref: ref, className: classnames(block$13({
	            auto: auto,
	            "aspect-ratio": aspectRatio,
	            "full-width": fullWidth,
	        }), aspectRatio, className) }), children));
	});
	{
	    try {
	        var PropTypes$1F = require("prop-types");
	        MediaContainer.propTypes = {
	            auto: PropTypes$1F.bool,
	            height: PropTypes$1F.number,
	            width: PropTypes$1F.number,
	            fullWidth: PropTypes$1F.bool,
	            className: PropTypes$1F.string,
	            children: PropTypes$1F.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gq = (undefined && undefined.__assign) || function () {
	    __assign$gq = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gq.apply(this, arguments);
	};
	var __rest$1A = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * The `MediaOverlay` component is used to create an overlay over specific media
	 * items within the `MediaContainer` component. You will need to apply most of
	 * your own styles as this is really just used for positioning.
	 */
	var MediaOverlay = React.forwardRef(function MediaOverlay(_a, ref) {
	    var className = _a.className, children = _a.children, _b = _a.position, position = _b === void 0 ? "bottom" : _b, props = __rest$1A(_a, ["className", "children", "position"]);
	    return (React__default.createElement("div", __assign$gq({}, props, { ref: ref, className: classnames("rmd-media-overlay rmd-media-overlay--" + position, className) }), children));
	});
	{
	    try {
	        var PropTypes$1G = require("prop-types");
	        MediaOverlay.propTypes = {
	            className: PropTypes$1G.string,
	            children: PropTypes$1G.node,
	            position: PropTypes$1G.oneOf([
	                "top",
	                "right",
	                "bottom",
	                "left",
	                "center",
	                "middle",
	                "absolute-center",
	            ]),
	        };
	    }
	    catch (e) { }
	}

	/* eslint-disable react/prop-types */
	var block$14 = bem("rmd-menu-icon");
	function ToggleChildren(_a) {
	    var dropdownIcon = _a.dropdownIcon, disableDropdownIcon = _a.disableDropdownIcon, children = _a.children, visible = _a.visible;
	    if (disableDropdownIcon || !dropdownIcon) {
	        return React__default.createElement(React__default.Fragment, null, children);
	    }
	    return (React__default.createElement(TextIconSpacing, { icon: React__default.createElement(IconRotator, { rotated: visible, className: block$14() }, dropdownIcon), iconAfter: true }, children));
	}

	var __assign$gr = (undefined && undefined.__assign) || function () {
	    __assign$gr = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gr.apply(this, arguments);
	};
	var __rest$1B = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$15 = bem("rmd-menu-button");
	/**
	 * This component is an extension of the `Button` component that will:
	 * - apply the required a11y prosp for a menu button
	 * - dynamically add a dropdown icon after the button contents
	 */
	var MenuButton = React.forwardRef(function MenuButton(_a, ref) {
	    var _b;
	    var _c = _a["aria-haspopup"], ariaHasPopup = _c === void 0 ? "menu" : _c, className = _a.className, visible = _a.visible, children = _a.children, propDropdownIcon = _a.dropdownIcon, _d = _a.disableDropdownIcon, disableDropdownIcon = _d === void 0 ? false : _d, _e = _a.first, first = _e === void 0 ? false : _e, _f = _a.last, last = _f === void 0 ? false : _f, inheritColor = _a.inheritColor, _g = _a.asAppBarAction, asAppBarAction = _g === void 0 ? false : _g, props = __rest$1B(_a, ["aria-haspopup", "className", "visible", "children", "dropdownIcon", "disableDropdownIcon", "first", "last", "inheritColor", "asAppBarAction"]);
	    var buttonType = props.buttonType;
	    var dropdownIcon = useIcon("dropdown", propDropdownIcon);
	    var actionClassName = useActionClassName({ first: first, last: last, inheritColor: inheritColor });
	    return (React__default.createElement(Button, __assign$gr({}, props, { ref: ref, "aria-haspopup": ariaHasPopup, "aria-expanded": visible ? "true" : undefined, className: classnames(block$15(), (_b = {},
	            _b[actionClassName] = first || last || inheritColor || asAppBarAction,
	            _b), className) }),
	        React__default.createElement(ToggleChildren, { visible: visible, dropdownIcon: dropdownIcon, disableDropdownIcon: disableDropdownIcon || buttonType === "icon" }, children)));
	});
	{
	    try {
	        var PropTypes$1H = require("prop-types");
	        MenuButton.propTypes = {
	            "aria-haspopup": PropTypes$1H.oneOf(["menu", "true", true]),
	            id: PropTypes$1H.string.isRequired,
	            visible: PropTypes$1H.bool.isRequired,
	            dropdownIcon: PropTypes$1H.node,
	            disableDropdownIcon: PropTypes$1H.bool,
	            className: PropTypes$1H.string,
	            children: PropTypes$1H.node,
	            buttonType: PropTypes$1H.oneOf(["text", "icon"]),
	            first: PropTypes$1H.bool,
	            last: PropTypes$1H.bool,
	            inheritColor: PropTypes$1H.bool,
	            asAppBarAction: PropTypes$1H.bool,
	        };
	    }
	    catch (e) { }
	}

	/**
	 * This is just a simple component that is used with the `Menu` component to
	 * handle the initial focus on mount and re-focusing a previous element on
	 * unmount.
	 * @private
	 */
	function MenuEvents(_a) {
	    var menuRef = _a.menuRef, cancelled = _a.cancelled, defaultFocus = _a.defaultFocus;
	    usePreviousFocus(cancelled);
	    useFocusOnMount(menuRef, defaultFocus, false, true);
	    return null;
	}

	/* eslint-disable react/prop-types */
	var Orientation = React.createContext("vertical");
	function useOrientation$1() {
	    return React.useContext(Orientation);
	}
	var OrientationProvider = function (_a) {
	    var orientation = _a.orientation, children = _a.children;
	    return (React__default.createElement(Orientation.Provider, { value: orientation }, children));
	};

	/**
	 * This hook is used to create a click handler on the menu that will close the
	 * menu when any `MenuItem` is clicked.
	 */
	function useMenuClick(_a) {
	    var onClick = _a.onClick, onRequestClose = _a.onRequestClose;
	    var cache = useRefCache({ onClick: onClick, onRequestClose: onRequestClose });
	    return React.useCallback(function (event) {
	        var _a = cache.current, onClick = _a.onClick, onRequestClose = _a.onRequestClose;
	        if (onClick) {
	            onClick(event);
	        }
	        var target = event.target;
	        if (!target ||
	            (event.currentTarget !== target && !target.closest("[aria-haspopup]"))) {
	            onRequestClose();
	        }
	        // disabled since useRefCache
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, []);
	}

	var __assign$gs = (undefined && undefined.__assign) || function () {
	    __assign$gs = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gs.apply(this, arguments);
	};
	/**
	 * This hook allows for the keyboard movement within a menu. It'll make sure
	 * that the arrow keys and typing letters can correctly focus menu items. In
	 * addition, it'll automatically swap to the left and right arrow keys if the
	 * menu is displayed horizontally.
	 */
	function useMenuKeyDown(_a) {
	    var menu = _a.menu, onKeyDown = _a.onKeyDown, onRequestClose = _a.onRequestClose, portalled = _a.portalled, horizontal = _a.horizontal, defaultFocus = _a.defaultFocus;
	    var _b = React.useState(0), focusedIndex = _b[0], setFocusedIndex = _b[1];
	    var items = React.useMemo(function () {
	        if (!menu) {
	            return [];
	        }
	        return getFocusableElements(menu, true);
	    }, [menu]);
	    React.useEffect(function () {
	        if (!menu) {
	            return;
	        }
	        if (defaultFocus === "last") {
	            setFocusedIndex(items.length - 1);
	        }
	        else {
	            setFocusedIndex(0);
	        }
	        // only want to trigger this on initial menu mount
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [menu]);
	    return useKeyboardMovement(__assign$gs(__assign$gs({}, (horizontal
	        ? HORIZONTAL_MENU
	        : VERTICAL_MENU)), { focusedIndex: focusedIndex,
	        onChange: function (_a) {
	            var index = _a.index;
	            setFocusedIndex(index);
	            if (items[index]) {
	                items[index].focus();
	            }
	        }, items: items.map(function (item) { return extractTextContent(item); }), onKeyDown: function (event) {
	            if (onKeyDown) {
	                onKeyDown(event);
	            }
	            if (event.key === "Escape") {
	                event.stopPropagation();
	                onRequestClose();
	            }
	            else if (event.key === "Tab") {
	                if (portalled) {
	                    // have to prevent default tab behavior since tab order is ruined when
	                    // something is portalled. this will make it interact the same as if
	                    // it was an escape keypress. it's too much work to try to emulate a
	                    // real tab here
	                    event.preventDefault();
	                }
	                onRequestClose();
	            }
	        } }))[1];
	}

	/**
	 * This hook is used to provide all the menu functionality within the `Menu`
	 * component.  It'll ensure that:
	 *
	 * - the menu will be closed if an element outside of the menu is clicked
	 * - the menu items within the menu are keyboard focusable after typing or using
	 *   the arrow keys
	 * - the menu will close if the Escape key or Tab key is pressed (tab since
	 *   it'll lose focus)
	 * - conditionally close the menu if the page is scrolled while visible.
	 */
	function useMenu(_a) {
	    var ref = _a.ref, visible = _a.visible, controlId = _a.controlId, _b = _a.horizontal, horizontal = _b === void 0 ? false : _b, propOnClick = _a.onClick, propOnKeyDown = _a.onKeyDown, _c = _a.portalled, portalled = _c === void 0 ? false : _c, defaultFocus = _a.defaultFocus, onRequestClose = _a.onRequestClose, _d = _a.disableControlClickOkay, disableControlClickOkay = _d === void 0 ? false : _d;
	    var menu = React.useRef(null);
	    var refHandler = React.useCallback(function (instance) {
	        applyRef(instance, ref);
	        menu.current = instance;
	    }, [ref]);
	    useCloseOnOutsideClick({
	        element: menu,
	        enabled: visible,
	        onOutsideClick: function (element, target, contains) {
	            if (!element || !target) {
	                return;
	            }
	            var control = document.getElementById(controlId);
	            // Need to also check if we have an `aria-expanded` visible anywhere since
	            // the child menus need to be portalled out to fix the overflow issue in
	            // Safari. If we didn't need to portal, this line could be removed as the
	            // `menu.current` would contain the child menu and not close.
	            var expanded = menu.current &&
	                menu.current.querySelector('[aria-expanded="true"]') &&
	                target.closest('[role="menu"]');
	            if ((disableControlClickOkay || !contains(control, target)) &&
	                !expanded) {
	                onRequestClose();
	            }
	        },
	    });
	    var onClick = useMenuClick({ onClick: propOnClick, onRequestClose: onRequestClose });
	    var onKeyDown = useMenuKeyDown({
	        menu: menu.current,
	        onKeyDown: propOnKeyDown,
	        onRequestClose: onRequestClose,
	        portalled: portalled,
	        horizontal: horizontal,
	        defaultFocus: defaultFocus,
	    });
	    return {
	        ref: refHandler,
	        menuRef: menu,
	        onClick: onClick,
	        onKeyDown: onKeyDown,
	    };
	}

	var __assign$gt = (undefined && undefined.__assign) || function () {
	    __assign$gt = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gt.apply(this, arguments);
	};
	var __rest$1C = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$16 = bem("rmd-menu");
	/**
	 * The `Menu` component is a fully controlled component that will animate in and
	 * out based on the `visible` prop as well as handle keyboard focus, closing
	 * when needed, etc.
	 */
	var Menu = React.forwardRef(function Menu(_a, forwardedRef) {
	    var _b = _a.role, role = _b === void 0 ? "menu" : _b, _c = _a.tabIndex, tabIndex = _c === void 0 ? -1 : _c, controlId = _a.controlId, className = _a.className, visible = _a.visible, onRequestClose = _a.onRequestClose, children = _a.children, portal = _a.portal, portalInto = _a.portalInto, portalIntoId = _a.portalIntoId, _d = _a.mountOnEnter, mountOnEnter = _d === void 0 ? true : _d, _e = _a.unmountOnExit, unmountOnExit = _e === void 0 ? true : _e, propOnEnter = _a.onEnter, propOnEntering = _a.onEntering, propOnEntered = _a.onEntered, onExit = _a.onExit, onExiting = _a.onExiting, propOnExited = _a.onExited, timeout = _a.timeout, classNames = _a.classNames, propAnchor = _a.anchor, propOnClick = _a.onClick, propOnKeyDown = _a.onKeyDown, _f = _a.defaultFocus, defaultFocus = _f === void 0 ? "first" : _f, _g = _a.horizontal, horizontal = _g === void 0 ? false : _g, positionOptions = _a.positionOptions, _h = _a.closeOnScroll, closeOnScroll = _h === void 0 ? false : _h, _j = _a.closeOnResize, closeOnResize = _j === void 0 ? false : _j, _k = _a.disableControlClickOkay, disableControlClickOkay = _k === void 0 ? false : _k, props = __rest$1C(_a, ["role", "tabIndex", "controlId", "className", "visible", "onRequestClose", "children", "portal", "portalInto", "portalIntoId", "mountOnEnter", "unmountOnExit", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "timeout", "classNames", "anchor", "onClick", "onKeyDown", "defaultFocus", "horizontal", "positionOptions", "closeOnScroll", "closeOnResize", "disableControlClickOkay"]);
	    var anchor = propAnchor;
	    if (!anchor) {
	        anchor = horizontal ? CENTER_CENTER_ANCHOR : TOP_INNER_RIGHT_ANCHOR;
	    }
	    // TODO: Refactor all the menu functionality since I made this when I had no
	    // idea what I was doing with hooks
	    var _l = useMenu({
	        ref: forwardedRef,
	        visible: visible,
	        controlId: controlId,
	        horizontal: horizontal,
	        onClick: propOnClick,
	        onKeyDown: propOnKeyDown,
	        portalled: portal || typeof portalInto !== "undefined" || !!portalIntoId,
	        defaultFocus: defaultFocus,
	        onRequestClose: onRequestClose,
	        disableControlClickOkay: disableControlClickOkay,
	    }), ref = _l.ref, menuRef = _l.menuRef, onClick = _l.onClick, onKeyDown = _l.onKeyDown;
	    var _m = React.useState(false), cancelled = _m[0], setCancelled = _m[1];
	    var prevVisible = React.useRef(visible);
	    if (prevVisible.current !== visible) {
	        prevVisible.current = visible;
	        if (cancelled) {
	            setCancelled(false);
	        }
	    }
	    var _o = useFixedPositioning(__assign$gt(__assign$gt({}, positionOptions), { fixedTo: function () { return document.getElementById(controlId); }, onScroll: function (_event, _a) {
	            var visible = _a.visible;
	            if (!closeOnScroll && visible) {
	                return;
	            }
	            if (!visible) {
	                setCancelled(true);
	            }
	            onRequestClose();
	        }, onResize: closeOnResize ? onRequestClose : undefined, anchor: anchor, onEnter: propOnEnter, onEntering: propOnEntering, onEntered: propOnEntered, onExited: propOnExited, transformOrigin: true })), style = _o.style, onEnter = _o.onEnter, onEntering = _o.onEntering, onEntered = _o.onEntered, onExited = _o.onExited;
	    var orientation = horizontal ? "horizontal" : "vertical";
	    return (React__default.createElement(ScaleTransition, { portal: portal, portalInto: portalInto, portalIntoId: portalIntoId, appear: mountOnEnter, visible: visible, classNames: classNames, timeout: timeout, onEnter: onEnter, onEntering: onEntering, onEntered: onEntered, onExit: onExit, onExiting: onExiting, onExited: onExited, mountOnEnter: mountOnEnter, unmountOnExit: unmountOnExit },
	        React__default.createElement(OrientationProvider, { orientation: orientation },
	            React__default.createElement("div", __assign$gt({}, props, { "aria-orientation": orientation, ref: ref, role: role, tabIndex: tabIndex, style: style, className: classnames(block$16({ horizontal: horizontal }), className), onClick: onClick, onKeyDown: onKeyDown }),
	                children,
	                React__default.createElement(MenuEvents, { menuRef: menuRef, cancelled: cancelled, defaultFocus: defaultFocus })))));
	});
	{
	    try {
	        var PropTypes$1I = require("prop-types");
	        Menu.propTypes = {
	            id: PropTypes$1I.string.isRequired,
	            role: PropTypes$1I.string,
	            className: PropTypes$1I.string,
	            controlId: PropTypes$1I.string.isRequired,
	            visible: PropTypes$1I.bool.isRequired,
	            onRequestClose: PropTypes$1I.func.isRequired,
	            "aria-label": PropTypes$1I.string,
	            "aria-labelledby": PropTypes$1I.string,
	            tabIndex: PropTypes$1I.number,
	            anchor: PropTypes$1I.shape({
	                x: PropTypes$1I.oneOf([
	                    "inner-left",
	                    "inner-right",
	                    "center",
	                    "left",
	                    "right",
	                ]),
	                y: PropTypes$1I.oneOf(["above", "below", "center", "top", "bottom"]),
	            }),
	            positionOptions: PropTypes$1I.shape({
	                xMargin: PropTypes$1I.number,
	                yMargin: PropTypes$1I.number,
	                vwMargin: PropTypes$1I.number,
	                vhMargin: PropTypes$1I.number,
	                disableSwapping: PropTypes$1I.bool,
	            }),
	            mountOnEnter: PropTypes$1I.bool,
	            unmountOnExit: PropTypes$1I.bool,
	            defaultFocus: PropTypes$1I.oneOf(["first", "last"]),
	            classNames: PropTypes$1I.oneOfType([
	                PropTypes$1I.string,
	                PropTypes$1I.shape({
	                    appear: PropTypes$1I.string,
	                    appearActive: PropTypes$1I.string,
	                    enter: PropTypes$1I.string,
	                    enterActive: PropTypes$1I.string,
	                    exit: PropTypes$1I.string,
	                    exitActive: PropTypes$1I.string,
	                }),
	            ]),
	            timeout: PropTypes$1I.oneOfType([
	                PropTypes$1I.number,
	                PropTypes$1I.shape({
	                    enter: PropTypes$1I.number,
	                    exit: PropTypes$1I.number,
	                }),
	            ]),
	            onClick: PropTypes$1I.func,
	            onKeyDown: PropTypes$1I.func,
	            children: PropTypes$1I.node,
	            horizontal: PropTypes$1I.bool,
	            onEnter: PropTypes$1I.func,
	            onEntering: PropTypes$1I.func,
	            onEntered: PropTypes$1I.func,
	            onExit: PropTypes$1I.func,
	            onExiting: PropTypes$1I.func,
	            onExited: PropTypes$1I.func,
	            portal: PropTypes$1I.bool,
	            portalInto: PropTypes$1I.oneOfType([
	                PropTypes$1I.string,
	                PropTypes$1I.func,
	                PropTypes$1I.object,
	            ]),
	            portalIntoId: PropTypes$1I.string,
	            closeOnScroll: PropTypes$1I.bool,
	            closeOnResize: PropTypes$1I.bool,
	            disableControlClickOkay: PropTypes$1I.bool,
	            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
	            // @ts-ignore
	            _a11yValidator: function (props, _propName, component) {
	                var label = props["aria-label"];
	                var labelledBy = props["aria-labelledby"];
	                if (label || labelledBy) {
	                    return null;
	                }
	                return new Error("Either the `aria-label` or `aria-labelledby` props are required for accessibility in the " + component + " component, but neither were provided.");
	            },
	        };
	    }
	    catch (e) { }
	}

	var __assign$gu = (undefined && undefined.__assign) || function () {
	    __assign$gu = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gu.apply(this, arguments);
	};
	var __rest$1D = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var MenuItem = React.forwardRef(function MenuItem(_a, ref) {
	    var className = _a.className, children = _a.children, _b = _a.role, role = _b === void 0 ? "menuitem" : _b, _c = _a.tabIndex, tabIndex = _c === void 0 ? -1 : _c, props = __rest$1D(_a, ["className", "children", "role", "tabIndex"]);
	    return (React__default.createElement(ListItem, __assign$gu({}, props, { ref: ref, role: role, tabIndex: tabIndex, className: classnames("rmd-menu-item", className) }), children));
	});
	{
	    try {
	        var PropTypes$1J = require("prop-types");
	        MenuItem.propTypes = {
	            id: PropTypes$1J.string,
	            className: PropTypes$1J.string,
	            role: PropTypes$1J.string,
	            tabIndex: PropTypes$1J.number,
	            children: PropTypes$1J.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gv = (undefined && undefined.__assign) || function () {
	    __assign$gv = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gv.apply(this, arguments);
	};
	var __rest$1E = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var MenuItemLink = React.forwardRef(function MenuItemLink(_a, ref) {
	    var className = _a.className, children = _a.children, _b = _a.role, role = _b === void 0 ? "menuitem" : _b, _c = _a.tabIndex, tabIndex = _c === void 0 ? -1 : _c, props = __rest$1E(_a, ["className", "children", "role", "tabIndex"]);
	    return (React__default.createElement("li", { role: "none" },
	        React__default.createElement(ListItemLink, __assign$gv({}, props, { ref: ref, role: role, tabIndex: tabIndex, className: classnames("rmd-menu-item", className) }), children)));
	});
	{
	    try {
	        var PropTypes$1K = require("prop-types");
	        MenuItemLink.propTypes = {
	            className: PropTypes$1K.string,
	            children: PropTypes$1K.node,
	            role: PropTypes$1K.oneOf(["menuitem"]),
	            tabIndex: PropTypes$1K.number,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gw = (undefined && undefined.__assign) || function () {
	    __assign$gw = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gw.apply(this, arguments);
	};
	var __rest$1F = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var MenuItemSeparator = React.forwardRef(function MenuItemSeparator(_a, ref) {
	    var ariaOrientation = _a["aria-orientation"], maxHeight = _a.maxHeight, props = __rest$1F(_a, ["aria-orientation", "maxHeight"]);
	    var menuOrientation = useOrientation$1();
	    if (ariaOrientation === "vertical" ||
	        (!ariaOrientation && menuOrientation === "horizontal")) {
	        return (React__default.createElement(VerticalDivider, __assign$gw({}, props, { ref: ref, "aria-orientation": "vertical", maxHeight: maxHeight, role: "separator" })));
	    }
	    return React__default.createElement(Divider, __assign$gw({}, props, { ref: ref, role: "separator" }));
	});
	{
	    try {
	        var PropTypes$1L = require("prop-types");
	        MenuItemSeparator.propTypes = {
	            "aria-orientation": PropTypes$1L.oneOf(["horizontal", "vertical"]),
	            className: PropTypes$1L.string,
	            maxHeight: PropTypes$1L.number,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gx = (undefined && undefined.__assign) || function () {
	    __assign$gx = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gx.apply(this, arguments);
	};
	function defaultMenuItemRenderer(item, key) {
	    if (item !== 0 && !item) {
	        return null;
	    }
	    if (item === "separator") {
	        return React__default.createElement(MenuItemSeparator, { key: key });
	    }
	    var type = typeof item;
	    if (type === "number" || type === "string" || type === "boolean") {
	        return React__default.createElement(MenuItem, { key: key }, item);
	    }
	    if (React.isValidElement(item)) {
	        return React.cloneElement(item, { key: key });
	    }
	    var separatorProps = item;
	    if (separatorProps.role === "separator") {
	        return React__default.createElement(MenuItemSeparator, __assign$gx({}, separatorProps, { key: key }));
	    }
	    var linkProps = item;
	    if (linkProps.to || linkProps.href || linkProps.component) {
	        return React__default.createElement(MenuItemLink, __assign$gx({ key: key }, linkProps));
	    }
	    var itemProps = item;
	    return React__default.createElement(MenuItem, __assign$gx({ key: key }, itemProps));
	}

	var __assign$gy = (undefined && undefined.__assign) || function () {
	    __assign$gy = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gy.apply(this, arguments);
	};
	var __rest$1G = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * The default menu renderer that will just render the `Menu` component along
	 * with a `List` by passing all props down to the main `Menu` component.
	 */
	function defaultMenuRenderer(_a) {
	    var horizontal = _a.horizontal, children = _a.children, props = __rest$1G(_a, ["horizontal", "children"]);
	    return (React__default.createElement(Menu, __assign$gy({}, props, { horizontal: horizontal }),
	        React__default.createElement(List, { horizontal: horizontal }, children)));
	}

	/**
	 * This is the main visibility hook to be used for the `DropdownMenu` and
	 * `DropdownMenuItem` components. It'll provide the current visibility as well
	 * as the default focus type once the menu becomes visible.
	 *
	 * @private
	 */
	function useVisibility(_a) {
	    var _b = _a === void 0 ? {} : _a, _c = _b.defaultVisible, defaultVisible = _c === void 0 ? false : _c, _d = _b.defaultFocus, defaultFocusValue = _d === void 0 ? "first" : _d, onVisibilityChange = _b.onVisibilityChange;
	    var _e = React.useState({
	        visible: defaultVisible,
	        defaultFocus: defaultFocusValue,
	    }), _f = _e[0], visible = _f.visible, defaultFocus = _f.defaultFocus, setState = _e[1];
	    var prevVisible = React.useRef(visible);
	    if (prevVisible.current !== visible) {
	        prevVisible.current = visible;
	        if (onVisibilityChange) {
	            onVisibilityChange(visible);
	        }
	    }
	    /**
	     * A callback to use that allows you to provide a string for if the focus
	     * target should be the "first" or "last" focusable element in the menu.  This
	     * should be "first" for all cases except when the control opens the menu with
	     * an arrow up key event.
	     */
	    var showWithFocus = React.useCallback(function (defaultFocus) {
	        setState({ visible: true, defaultFocus: defaultFocus });
	    }, []);
	    /**
	     * The default implementation of showing the menu that will focus the first
	     * menu item once visible.
	     */
	    var show = React.useCallback(function () {
	        showWithFocus("first");
	    }, [showWithFocus]);
	    /**
	     * Hides the menu.
	     */
	    var hide = React.useCallback(function () {
	        setState({ visible: false, defaultFocus: "first" });
	    }, []);
	    /**
	     * Toggles the visibility of the menu.
	     */
	    var toggle = React.useCallback(function () {
	        setState(function (_a) {
	            var visible = _a.visible, defaultFocus = _a.defaultFocus;
	            return ({
	                visible: !visible,
	                defaultFocus: defaultFocus,
	            });
	        });
	    }, []);
	    return {
	        visible: visible,
	        defaultFocus: defaultFocus,
	        show: show,
	        showWithFocus: showWithFocus,
	        hide: hide,
	        toggle: toggle,
	    };
	}

	/**
	 * This hook is used to provide the menu visibility based on interacting with
	 * the `MenuButton` component. It'll merge and return the required `onClick` and
	 * `onKeyDown` event handlers that should be passed down to the `MenuButton` as
	 * well as the current visibility state and a `hide` function to pass to the
	 * `Menu`.
	 *
	 * @private
	 */
	function useButtonVisibility(_a) {
	    var _b = _a === void 0 ? {} : _a, propOnClick = _b.onClick, propOnKeyDown = _b.onKeyDown, defaultVisible = _b.defaultVisible, propDefaultFocus = _b.defaultFocus, onVisibilityChange = _b.onVisibilityChange;
	    var handlers = useRefCache({
	        onClick: propOnClick,
	        onKeyDown: propOnKeyDown,
	    });
	    var _c = useVisibility({
	        defaultVisible: defaultVisible,
	        defaultFocus: propDefaultFocus,
	        onVisibilityChange: onVisibilityChange,
	    }), visible = _c.visible, defaultFocus = _c.defaultFocus, hide = _c.hide, showWithFocus = _c.showWithFocus, toggle = _c.toggle;
	    var onClick = React.useCallback(function (event) {
	        var onClick = handlers.current.onClick;
	        if (onClick) {
	            onClick(event);
	        }
	        toggle();
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [toggle]);
	    var onKeyDown = React.useCallback(function (event) {
	        var onKeyDown = handlers.current.onKeyDown;
	        if (onKeyDown) {
	            onKeyDown(event);
	        }
	        switch (event.key) {
	            case "ArrowDown":
	                event.preventDefault();
	                showWithFocus("first");
	                break;
	            case "ArrowUp":
	                event.preventDefault();
	                showWithFocus("last");
	                break;
	            // no default
	        }
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [showWithFocus]);
	    return {
	        visible: visible,
	        defaultFocus: defaultFocus,
	        hide: hide,
	        onClick: onClick,
	        onKeyDown: onKeyDown,
	    };
	}

	var __assign$gz = (undefined && undefined.__assign) || function () {
	    __assign$gz = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gz.apply(this, arguments);
	};
	var __rest$1H = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var DropdownMenu = React.forwardRef(function DropdownMenu(_a, ref) {
	    var propOnClick = _a.onClick, propOnKeyDown = _a.onKeyDown, children = _a.children, anchor = _a.anchor, menuLabel = _a.menuLabel, menuLabelledBy = _a.menuLabelledBy, _b = _a.menuRenderer, menuRenderer = _b === void 0 ? defaultMenuRenderer : _b, items = _a.items, _c = _a.itemRenderer, itemRenderer = _c === void 0 ? defaultMenuItemRenderer : _c, horizontal = _a.horizontal, onVisibilityChange = _a.onVisibilityChange, portal = _a.portal, portalInto = _a.portalInto, portalIntoId = _a.portalIntoId, positionOptions = _a.positionOptions, _d = _a.defaultVisible, defaultVisible = _d === void 0 ? false : _d, closeOnScroll = _a.closeOnScroll, closeOnResize = _a.closeOnResize, propDropdownIcon = _a.dropdownIcon, _e = _a.disableDropdownIcon, disableDropdownIcon = _e === void 0 ? false : _e, props = __rest$1H(_a, ["onClick", "onKeyDown", "children", "anchor", "menuLabel", "menuLabelledBy", "menuRenderer", "items", "itemRenderer", "horizontal", "onVisibilityChange", "portal", "portalInto", "portalIntoId", "positionOptions", "defaultVisible", "closeOnScroll", "closeOnResize", "dropdownIcon", "disableDropdownIcon"]);
	    var id = props.id;
	    var dropdownIcon = useIcon("dropdown", propDropdownIcon);
	    var _f = useButtonVisibility({
	        onClick: propOnClick,
	        onKeyDown: propOnKeyDown,
	        defaultVisible: defaultVisible,
	        onVisibilityChange: onVisibilityChange,
	    }), visible = _f.visible, defaultFocus = _f.defaultFocus, onClick = _f.onClick, onKeyDown = _f.onKeyDown, hide = _f.hide;
	    var labelledBy = menuLabelledBy;
	    if (!menuLabel && !menuLabelledBy) {
	        labelledBy = id;
	    }
	    return (React__default.createElement(React__default.Fragment, null,
	        React__default.createElement(MenuButton, __assign$gz({}, props, { ref: ref, "aria-haspopup": "menu", visible: visible, onClick: onClick, onKeyDown: onKeyDown, dropdownIcon: dropdownIcon, disableDropdownIcon: disableDropdownIcon }), children),
	        menuRenderer({
	            "aria-label": menuLabel,
	            // ok to typecast since one of these two should be a string by this
	            // line
	            "aria-labelledby": labelledBy,
	            id: id + "-menu",
	            controlId: id,
	            anchor: anchor,
	            positionOptions: positionOptions,
	            closeOnScroll: closeOnScroll,
	            closeOnResize: closeOnResize,
	            horizontal: horizontal,
	            visible: visible,
	            defaultFocus: defaultFocus,
	            onRequestClose: hide,
	            children: items.map(function (item, i) { return itemRenderer(item, "item-" + i); }),
	            portal: portal,
	            portalInto: portalInto,
	            portalIntoId: portalIntoId,
	        }, items)));
	});
	{
	    try {
	        var PropTypes$1M = require("prop-types");
	        DropdownMenu.propTypes = {
	            id: PropTypes$1M.string.isRequired,
	            defaultVisible: PropTypes$1M.bool,
	            menuLabel: PropTypes$1M.string,
	            menuLabelledBy: PropTypes$1M.string,
	            menuRenderer: PropTypes$1M.func,
	            items: PropTypes$1M.arrayOf(PropTypes$1M.oneOfType([
	                PropTypes$1M.string,
	                PropTypes$1M.number,
	                PropTypes$1M.node,
	                PropTypes$1M.object,
	            ])).isRequired,
	            onClick: PropTypes$1M.func,
	            onKeyDown: PropTypes$1M.func,
	            children: PropTypes$1M.node,
	            horizontal: PropTypes$1M.bool,
	            portal: PropTypes$1M.bool,
	            portalInto: PropTypes$1M.oneOfType([
	                PropTypes$1M.string,
	                PropTypes$1M.func,
	                PropTypes$1M.object,
	            ]),
	            portalIntoId: PropTypes$1M.string,
	            anchor: PropTypes$1M.shape({
	                x: PropTypes$1M.oneOf([
	                    "left",
	                    "right",
	                    "center",
	                    "inner-left",
	                    "inner-right",
	                ]).isRequired,
	                y: PropTypes$1M.oneOf(["above", "below", "center", "top", "bottom"])
	                    .isRequired,
	            }),
	            positionOptions: PropTypes$1M.shape({
	                vwMargin: PropTypes$1M.number,
	                vhMargin: PropTypes$1M.number,
	                xMargin: PropTypes$1M.number,
	                yMargin: PropTypes$1M.number,
	                initialX: PropTypes$1M.number,
	                initialY: PropTypes$1M.number,
	                disableSwapping: PropTypes$1M.bool,
	            }),
	            itemRenderer: PropTypes$1M.func,
	            dropdownIcon: PropTypes$1M.node,
	            disableDropdownIcon: PropTypes$1M.bool,
	            onVisibilityChange: PropTypes$1M.func,
	            closeOnScroll: PropTypes$1M.bool,
	            closeOnResize: PropTypes$1M.bool,
	        };
	    }
	    catch (e) { }
	}

	function useItemVisibility(_a) {
	    var _b = _a === void 0 ? {} : _a, _c = _b.horizontal, horizontal = _c === void 0 ? false : _c, propOnClick = _b.onClick, propOnKeyDown = _b.onKeyDown, defaultVisible = _b.defaultVisible, propDefaultFocus = _b.defaultFocus, onVisibilityChange = _b.onVisibilityChange;
	    var cache = useRefCache({
	        horizontal: horizontal,
	        onClick: propOnClick,
	        onKeyDown: propOnKeyDown,
	    });
	    var _d = useVisibility({
	        defaultVisible: defaultVisible,
	        defaultFocus: propDefaultFocus,
	        onVisibilityChange: onVisibilityChange,
	    }), visible = _d.visible, defaultFocus = _d.defaultFocus, hide = _d.hide, showWithFocus = _d.showWithFocus, toggle = _d.toggle;
	    var onClick = React.useCallback(function (event) {
	        var onClick = cache.current.onClick;
	        if (onClick) {
	            onClick(event);
	        }
	        toggle();
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [toggle]);
	    var onKeyDown = React.useCallback(function (event) {
	        var _a = cache.current, onKeyDown = _a.onKeyDown, horizontal = _a.horizontal;
	        if (onKeyDown) {
	            onKeyDown(event);
	        }
	        var firstKey = horizontal ? "ArrowDown" : "ArrowRight";
	        var lastKey = horizontal ? "ArrowUp" : "ArrowLeft";
	        if (event.key !== firstKey && event.key !== lastKey) {
	            return;
	        }
	        // don't want to trigger default behavior of screen scrolling
	        event.preventDefault();
	        // don't want parent menus to be effected by this as well.
	        event.stopPropagation();
	        showWithFocus(event.key === firstKey ? "first" : "last");
	    }, 
	    // disabled since useRefCache
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	    [showWithFocus]);
	    return {
	        visible: visible,
	        defaultFocus: defaultFocus,
	        hide: hide,
	        onClick: onClick,
	        onKeyDown: onKeyDown,
	    };
	}

	var __assign$gA = (undefined && undefined.__assign) || function () {
	    __assign$gA = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gA.apply(this, arguments);
	};
	var __rest$1I = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * The `DropdownMenuItem` component is used to be able to render nested dropdown menus.
	 */
	var DropdownMenuItem = React.forwardRef(function DropdownMenuItem(_a, ref) {
	    var propOnClick = _a.onClick, propOnKeyDown = _a.onKeyDown, children = _a.children, propAnchor = _a.anchor, menuLabel = _a.menuLabel, menuLabelledBy = _a.menuLabelledBy, _b = _a.menuRenderer, menuRenderer = _b === void 0 ? defaultMenuRenderer : _b, items = _a.items, _c = _a.itemRenderer, itemRenderer = _c === void 0 ? defaultMenuItemRenderer : _c, horizontal = _a.horizontal, onVisibilityChange = _a.onVisibilityChange, _d = _a.portal, portal = _d === void 0 ? true : _d, portalInto = _a.portalInto, portalIntoId = _a.portalIntoId, positionOptions = _a.positionOptions, propRightAddon = _a.rightAddon, propDropdownIcon = _a.dropdownIcon, _e = _a.closeOnScroll, closeOnScroll = _e === void 0 ? false : _e, _f = _a.closeOnResize, closeOnResize = _f === void 0 ? false : _f, _g = _a.disableEscapeCascade, disableEscapeCascade = _g === void 0 ? false : _g, _h = _a.disableDropdownIcon, disableDropdownIcon = _h === void 0 ? false : _h, props = __rest$1I(_a, ["onClick", "onKeyDown", "children", "anchor", "menuLabel", "menuLabelledBy", "menuRenderer", "items", "itemRenderer", "horizontal", "onVisibilityChange", "portal", "portalInto", "portalIntoId", "positionOptions", "rightAddon", "dropdownIcon", "closeOnScroll", "closeOnResize", "disableEscapeCascade", "disableDropdownIcon"]);
	    var id = props.id;
	    var dropdownIcon = useIcon("forward", propDropdownIcon);
	    var _j = useItemVisibility({
	        onClick: propOnClick,
	        onKeyDown: propOnKeyDown,
	        onVisibilityChange: onVisibilityChange,
	    }), visible = _j.visible, hide = _j.hide, onClick = _j.onClick, onKeyDown = _j.onKeyDown, defaultFocus = _j.defaultFocus;
	    var labelledBy = menuLabelledBy;
	    if (!menuLabel && !menuLabelledBy) {
	        labelledBy = id;
	    }
	    var rightAddon = propRightAddon;
	    if (!disableDropdownIcon && dropdownIcon && !rightAddon) {
	        rightAddon = React__default.createElement(IconRotator, { rotated: visible }, dropdownIcon);
	    }
	    var anchor = propAnchor;
	    if (!anchor) {
	        anchor = horizontal ? BELOW_INNER_RIGHT_ANCHOR : TOP_RIGHT_ANCHOR;
	    }
	    return (React__default.createElement(React__default.Fragment, null,
	        React__default.createElement(MenuItem, __assign$gA({}, props, { ref: ref, "aria-haspopup": "menu", "aria-expanded": visible ? "true" : undefined, role: "button", onClick: onClick, onKeyDown: onKeyDown, rightAddon: rightAddon }), children),
	        menuRenderer({
	            "aria-label": menuLabel,
	            // ok to typecast since one of these two should be a string by this
	            // line
	            "aria-labelledby": labelledBy,
	            id: id + "-menu",
	            controlId: id,
	            anchor: anchor,
	            positionOptions: positionOptions,
	            closeOnScroll: closeOnScroll,
	            closeOnResize: closeOnResize,
	            horizontal: horizontal,
	            visible: visible,
	            defaultFocus: defaultFocus,
	            onRequestClose: hide,
	            children: items.map(function (item, i) { return itemRenderer(item, "item-" + i); }),
	            portal: portal,
	            portalInto: portalInto,
	            portalIntoId: portalIntoId,
	            onKeyDown: function (event) {
	                if (event.key !== "Escape" || disableEscapeCascade) {
	                    // don't want parent keydown listeners to be triggered as well
	                    event.stopPropagation();
	                }
	                if (!horizontal && event.key === "ArrowLeft") {
	                    hide();
	                }
	            },
	        }, items)));
	});
	{
	    try {
	        var PropTypes$1N = require("prop-types");
	        DropdownMenuItem.propTypes = {
	            id: PropTypes$1N.string.isRequired,
	            className: PropTypes$1N.string,
	            portal: PropTypes$1N.bool,
	            portalInto: PropTypes$1N.oneOfType([
	                PropTypes$1N.string,
	                PropTypes$1N.func,
	                PropTypes$1N.object,
	            ]),
	            portalIntoId: PropTypes$1N.string,
	            onClick: PropTypes$1N.func,
	            onKeyDown: PropTypes$1N.func,
	            children: PropTypes$1N.node,
	            anchor: PropTypes$1N.shape({
	                x: PropTypes$1N.oneOf([
	                    "left",
	                    "right",
	                    "center",
	                    "inner-left",
	                    "inner-right",
	                ]).isRequired,
	                y: PropTypes$1N.oneOf(["above", "below", "center", "top", "bottom"])
	                    .isRequired,
	            }),
	            items: PropTypes$1N.arrayOf(PropTypes$1N.oneOfType([
	                PropTypes$1N.string,
	                PropTypes$1N.number,
	                PropTypes$1N.node,
	                PropTypes$1N.object,
	            ])).isRequired,
	            menuLabel: PropTypes$1N.string,
	            menuLabelledBy: PropTypes$1N.string,
	            menuRenderer: PropTypes$1N.func,
	            itemRenderer: PropTypes$1N.func,
	            dropdownIcon: PropTypes$1N.node,
	            horizontal: PropTypes$1N.bool,
	            positionOptions: PropTypes$1N.shape({
	                vwMargin: PropTypes$1N.number,
	                vhMargin: PropTypes$1N.number,
	                xMargin: PropTypes$1N.number,
	                yMargin: PropTypes$1N.number,
	                initialX: PropTypes$1N.number,
	                initialY: PropTypes$1N.number,
	                disableSwapping: PropTypes$1N.bool,
	            }),
	            rightAddon: PropTypes$1N.node,
	            onVisibilityChange: PropTypes$1N.func,
	            disableDropdownIcon: PropTypes$1N.bool,
	            disableEscapeCascade: PropTypes$1N.bool,
	            closeOnScroll: PropTypes$1N.bool,
	            closeOnResize: PropTypes$1N.bool,
	        };
	    }
	    catch (e) { }
	}

	var DEFAULT_CONTEXT_MENU_ID = "context-menu";
	function useContextMenu(_a) {
	    var _b = _a === void 0 ? {} : _a, _c = _b.id, id = _c === void 0 ? DEFAULT_CONTEXT_MENU_ID : _c, propRef = _b.ref, _d = _b.anchor, anchor = _d === void 0 ? TOP_INNER_LEFT_ANCHOR : _d, _e = _b.classNames, classNames = _e === void 0 ? SCALE_Y_CLASSNAMES : _e, _f = _b.disableDeselect, disableDeselect = _f === void 0 ? false : _f;
	    var _g = React.useState(false), visible = _g[0], setVisible = _g[1];
	    var onRequestClose = React.useCallback(function () {
	        setVisible(false);
	    }, []);
	    var _h = React.useState({}), coords = _h[0], setCoords = _h[1];
	    var onContextMenu = React.useCallback(function (event) {
	        event.preventDefault();
	        event.stopPropagation();
	        var selection = window.getSelection();
	        if (selection && !disableDeselect) {
	            selection.empty();
	        }
	        setVisible(true);
	        if (event.button === 0 && event.buttons === 0) {
	            setCoords({});
	            return;
	        }
	        setCoords({ initialX: event.clientX, initialY: event.clientY });
	    }, [disableDeselect]);
	    var menuRef = React.useRef(null);
	    React.useEffect(function () {
	        if (!visible) {
	            return;
	        }
	        var hide = function (event) {
	            var target = event.target;
	            if (!containsElement(menuRef, target)) {
	                onRequestClose();
	            }
	        };
	        window.addEventListener("contextmenu", hide, true);
	        return function () {
	            window.removeEventListener("contextmenu", hide, true);
	        };
	    }, [onRequestClose, visible]);
	    var ref = React.useCallback(function (instance) {
	        applyRef(instance, propRef);
	        menuRef.current = instance;
	    }, [propRef]);
	    var menuProps = {
	        id: id,
	        ref: ref,
	        anchor: anchor,
	        visible: visible,
	        classNames: classNames,
	        onRequestClose: onRequestClose,
	        positionOptions: coords,
	        disableControlClickOkay: true,
	    };
	    return [menuProps, onContextMenu, setVisible];
	}

	var __assign$gB = (undefined && undefined.__assign) || function () {
	    __assign$gB = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gB.apply(this, arguments);
	};
	var __rest$1J = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * An extremely "useful" component that should be used with the `Table`
	 * component if you want to make a responsive table within the page. If you
	 * don't want to use this component, you can just apply `overflow: auto` to a
	 * parent element of the table.
	 */
	var TableContainer = React.forwardRef(function TableContainer(_a, ref) {
	    var className = _a.className, children = _a.children, props = __rest$1J(_a, ["className", "children"]);
	    return (React__default.createElement("div", __assign$gB({}, props, { ref: ref, className: classnames("rmd-table-container", className) }), children));
	});
	{
	    try {
	        var PropTypes$1O = require("prop-types");
	        TableContainer.propTypes = {
	            className: PropTypes$1O.string,
	            children: PropTypes$1O.node,
	        };
	    }
	    catch (e) { }
	}

	var context$4 = React.createContext({
	    header: false,
	    hAlign: "left",
	    vAlign: "middle",
	    lineWrap: false,
	    disableHover: false,
	    disableBorders: false,
	});
	/**
	 * An internal hook for getting the current table configuration in child
	 * components for the table. This will use the inherited table configuration
	 * context if the prop value is `undefined`.
	 *
	 * @private
	 */
	function useTableConfig(options) {
	    var _a, _b, _c, _d, _e, _f;
	    var inherited = React.useContext(context$4);
	    var header = (_a = options.header) !== null && _a !== void 0 ? _a : inherited.header;
	    var hAlign = (_b = options.hAlign) !== null && _b !== void 0 ? _b : inherited.hAlign;
	    var vAlign = (_c = options.vAlign) !== null && _c !== void 0 ? _c : inherited.vAlign;
	    var lineWrap = (_d = options.lineWrap) !== null && _d !== void 0 ? _d : inherited.lineWrap;
	    var disableHover = (_e = options.disableHover) !== null && _e !== void 0 ? _e : inherited.disableHover;
	    var disableBorders = (_f = options.disableBorders) !== null && _f !== void 0 ? _f : inherited.disableBorders;
	    return {
	        header: header,
	        hAlign: hAlign,
	        vAlign: vAlign,
	        lineWrap: lineWrap,
	        disableHover: disableHover,
	        disableBorders: disableBorders,
	    };
	}
	/**
	 * @private
	 */
	var TableConfigProvider = context$4.Provider;

	var __assign$gC = (undefined && undefined.__assign) || function () {
	    __assign$gC = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gC.apply(this, arguments);
	};
	var __rest$1K = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$17 = bem("rmd-table");
	/**
	 * Creates a `<table>` element with some default styles and a quick way to
	 * configure the other styles within a table. That being said, styling tables is
	 * awful if you are used to flexbox and this component will not be helping with
	 * layout styles of tables.
	 *
	 * The table will not be responsive by default, but you can easily create a
	 * responsive table with overflow by wrapping with the `TableContainer`
	 * component or just adding `overflow: auto` to a parent element. Note that
	 * horizontal scrolling is still not one of the best user interactions and it
	 * might be better to render a table in a different manner for mobile devices to
	 * help display all the required data.
	 */
	var Table = React.forwardRef(function Table(_a, ref) {
	    var className = _a.className, children = _a.children, _b = _a.dense, dense = _b === void 0 ? false : _b, _c = _a.hAlign, hAlign = _c === void 0 ? "left" : _c, _d = _a.vAlign, vAlign = _d === void 0 ? "middle" : _d, _e = _a.lineWrap, lineWrap = _e === void 0 ? false : _e, _f = _a.fullWidth, fullWidth = _f === void 0 ? false : _f, _g = _a.disableHover, disableHover = _g === void 0 ? false : _g, _h = _a.disableBorders, disableBorders = _h === void 0 ? false : _h, props = __rest$1K(_a, ["className", "children", "dense", "hAlign", "vAlign", "lineWrap", "fullWidth", "disableHover", "disableBorders"]);
	    var configuration = React.useMemo(function () { return ({
	        header: false,
	        hAlign: hAlign,
	        vAlign: vAlign,
	        lineWrap: lineWrap,
	        disableHover: disableHover,
	        disableBorders: disableBorders,
	    }); }, [hAlign, vAlign, lineWrap, disableHover, disableBorders]);
	    return (React__default.createElement(TableConfigProvider, { value: configuration },
	        React__default.createElement("table", __assign$gC({}, props, { ref: ref, className: classnames(block$17({
	                dense: dense,
	                "full-width": fullWidth,
	            }), className) }), children)));
	});
	{
	    try {
	        var PropTypes$1P = require("prop-types");
	        Table.propTypes = {
	            children: PropTypes$1P.node,
	            className: PropTypes$1P.string,
	            dense: PropTypes$1P.bool,
	            fullWidth: PropTypes$1P.bool,
	            disableHover: PropTypes$1P.bool,
	            disableBorders: PropTypes$1P.bool,
	            hAlign: PropTypes$1P.oneOf(["left", "center", "right"]),
	            vAlign: PropTypes$1P.oneOf(["top", "middle", "bottom"]),
	            lineWrap: PropTypes$1P.oneOfType([
	                PropTypes$1P.bool,
	                PropTypes$1P.oneOf(["padded"]),
	            ]),
	        };
	    }
	    catch (e) { }
	}

	var context$5 = React.createContext(false);
	/**
	 * A quick way to conditionally inherit the sticky context within a table.  If
	 * the sticky prop was defined and a boolean, it will be used. Otherwise the
	 * inherited context value will be used.
	 * @private
	 */
	function useSticky(sticky) {
	    var isSticky = React.useContext(context$5);
	    return typeof sticky !== "undefined" ? !!sticky : isSticky;
	}
	/**
	 * @private
	 */
	var StickyTableProvider = context$5.Provider;

	var __assign$gD = (undefined && undefined.__assign) || function () {
	    __assign$gD = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gD.apply(this, arguments);
	};
	var __rest$1L = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$18 = bem("rmd-thead");
	/**
	 * Creates a `<thead>` element with some basic styles. This component will also
	 * update the table configuration so that all the `TableCell` children will
	 * automatically become `<th>` elements instead of the normal `<td>` as well as
	 * disabling the hover effect and line wrapping. The hover effect and
	 * line-wrapping can be re-enabled if desired through the `hoverable` and
	 * `disableNoWrap` props.
	 */
	var TableHeader = React.forwardRef(function TableHeader(_a, ref) {
	    var className = _a.className, _b = _a.hoverable, hoverable = _b === void 0 ? false : _b, propLineWrap = _a.lineWrap, children = _a.children, _c = _a.sticky, sticky = _c === void 0 ? false : _c, props = __rest$1L(_a, ["className", "hoverable", "lineWrap", "children", "sticky"]);
	    // update the table configuration with the custom overrides for the `<thead>`
	    var _d = useTableConfig({
	        lineWrap: propLineWrap,
	        disableHover: !hoverable,
	    }), hAlign = _d.hAlign, vAlign = _d.vAlign, lineWrap = _d.lineWrap, disableHover = _d.disableHover, disableBorders = _d.disableBorders;
	    var configuration = React.useMemo(function () { return ({
	        header: true,
	        hAlign: hAlign,
	        vAlign: vAlign,
	        lineWrap: lineWrap,
	        disableBorders: disableBorders,
	        disableHover: disableHover,
	    }); }, [hAlign, vAlign, lineWrap, disableBorders, disableHover]);
	    return (React__default.createElement(TableConfigProvider, { value: configuration },
	        React__default.createElement("thead", __assign$gD({}, props, { ref: ref, className: classnames(block$18(), className) }),
	            React__default.createElement(StickyTableProvider, { value: sticky }, children))));
	});
	{
	    try {
	        var PropTypes$1Q = require("prop-types");
	        TableHeader.propTypes = {
	            className: PropTypes$1Q.string,
	            lineWrap: PropTypes$1Q.oneOfType([
	                PropTypes$1Q.bool,
	                PropTypes$1Q.oneOf(["padded"]),
	            ]),
	            hoverable: PropTypes$1Q.bool,
	            sticky: PropTypes$1Q.bool,
	            children: PropTypes$1Q.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gE = (undefined && undefined.__assign) || function () {
	    __assign$gE = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gE.apply(this, arguments);
	};
	var __rest$1M = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * Creates a `<tbody>` element that also allows for overriding all the child
	 * `TableCell` components with additional styling behavior.
	 */
	var TableBody = React.forwardRef(function TableBody(_a, ref) {
	    var className = _a.className, children = _a.children, propHAlign = _a.hAlign, propVAlign = _a.vAlign, propLineWrap = _a.lineWrap, propDisableHover = _a.disableHover, propDisableBorders = _a.disableBorders, props = __rest$1M(_a, ["className", "children", "hAlign", "vAlign", "lineWrap", "disableHover", "disableBorders"]);
	    // update the table configuration with the custom overrides for the `<thead>`
	    var _b = useTableConfig({
	        hAlign: propHAlign,
	        vAlign: propVAlign,
	        lineWrap: propLineWrap,
	        disableHover: propDisableHover,
	        disableBorders: propDisableBorders,
	    }), hAlign = _b.hAlign, vAlign = _b.vAlign, lineWrap = _b.lineWrap, disableHover = _b.disableHover, disableBorders = _b.disableBorders;
	    var configuration = React.useMemo(function () { return ({
	        header: false,
	        hAlign: hAlign,
	        vAlign: vAlign,
	        lineWrap: lineWrap,
	        disableBorders: disableBorders,
	        disableHover: disableHover,
	    }); }, [hAlign, vAlign, lineWrap, disableBorders, disableHover]);
	    return (React__default.createElement(TableConfigProvider, { value: configuration },
	        React__default.createElement("tbody", __assign$gE({}, props, { ref: ref, className: classnames("rmd-tbody", className) }), children)));
	});
	{
	    try {
	        var PropTypes$1R = require("prop-types");
	        TableBody.propTypes = {
	            className: PropTypes$1R.string,
	            children: PropTypes$1R.node,
	            lineWrap: PropTypes$1R.oneOfType([
	                PropTypes$1R.bool,
	                PropTypes$1R.oneOf(["padded"]),
	            ]),
	            hAlign: PropTypes$1R.oneOf(["left", "center", "right"]),
	            vAlign: PropTypes$1R.oneOf(["top", "middle", "bottom"]),
	            disableHover: PropTypes$1R.bool,
	            disableBorders: PropTypes$1R.bool,
	        };
	    }
	    catch (e) { }
	}

	var context$6 = React.createContext(false);
	{
	    context$6.displayName = "TableFooterContext";
	}
	/**
	 * @private
	 */
	var TableFooterProvider = context$6.Provider;
	/**
	 * @private
	 */
	function useTableFooter() {
	    return React.useContext(context$6);
	}

	var __assign$gF = (undefined && undefined.__assign) || function () {
	    __assign$gF = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gF.apply(this, arguments);
	};
	var __rest$1N = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$19 = bem("rmd-foot");
	/**
	 * Creates a `<tfoot>` element with some basic styles. This component will
	 * disable the hover effect and line wrapping by default, but the hover effect
	 * and line-wrapping can be re-enabled if desired through the `hoverable` and
	 * `disableNoWrap` props.
	 */
	var TableFooter = React.forwardRef(function TableFooter(_a, ref) {
	    var className = _a.className, _b = _a.hoverable, hoverable = _b === void 0 ? false : _b, propLineWrap = _a.lineWrap, children = _a.children, _c = _a.sticky, sticky = _c === void 0 ? false : _c, props = __rest$1N(_a, ["className", "hoverable", "lineWrap", "children", "sticky"]);
	    // update the table configuration with the custom overrides for the `<tfoot>`
	    var _d = useTableConfig({
	        lineWrap: propLineWrap,
	        disableHover: !hoverable,
	    }), hAlign = _d.hAlign, vAlign = _d.vAlign, lineWrap = _d.lineWrap, disableHover = _d.disableHover, disableBorders = _d.disableBorders;
	    var configuration = React.useMemo(function () { return ({
	        header: false,
	        hAlign: hAlign,
	        vAlign: vAlign,
	        lineWrap: lineWrap,
	        disableBorders: disableBorders,
	        disableHover: disableHover,
	    }); }, [hAlign, vAlign, lineWrap, disableBorders, disableHover]);
	    return (React__default.createElement(TableConfigProvider, { value: configuration },
	        React__default.createElement(TableFooterProvider, { value: true },
	            React__default.createElement("tfoot", __assign$gF({}, props, { ref: ref, className: classnames(block$19(), className) }),
	                React__default.createElement(StickyTableProvider, { value: sticky }, children)))));
	});
	{
	    try {
	        var PropTypes$1S = require("prop-types");
	        TableFooter.propTypes = {
	            className: PropTypes$1S.string,
	            lineWrap: PropTypes$1S.oneOfType([
	                PropTypes$1S.bool,
	                PropTypes$1S.oneOf(["padded"]),
	            ]),
	            hoverable: PropTypes$1S.bool,
	            sticky: PropTypes$1S.bool,
	            children: PropTypes$1S.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gG = (undefined && undefined.__assign) || function () {
	    __assign$gG = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gG.apply(this, arguments);
	};
	var __rest$1O = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$1a = bem("rmd-tr");
	/**
	 * Creates a `<tr>` element with some general styles that are inherited from the
	 * base table configuration.
	 */
	var TableRow = React.forwardRef(function TableRow(_a, ref) {
	    var className = _a.className, propDisableHover = _a.disableHover, propDisableBorders = _a.disableBorders, children = _a.children, _b = _a.selected, selected = _b === void 0 ? false : _b, _c = _a.clickable, clickable = _c === void 0 ? false : _c, props = __rest$1O(_a, ["className", "disableHover", "disableBorders", "children", "selected", "clickable"]);
	    var _d = useTableConfig({
	        disableHover: propDisableHover,
	        disableBorders: propDisableBorders,
	    }), disableHover = _d.disableHover, disableBorders = _d.disableBorders;
	    return (React__default.createElement("tr", __assign$gG({}, props, { ref: ref, className: classnames(block$1a({
	            bordered: !disableBorders,
	            hoverable: !disableHover,
	            clickable: clickable,
	            selected: selected,
	            "selected-hoverable": selected && !disableHover,
	        }), className) }), children));
	});
	{
	    try {
	        var PropTypes$1T = require("prop-types");
	        TableRow.propTypes = {
	            className: PropTypes$1T.string,
	            children: PropTypes$1T.node,
	            disableHover: PropTypes$1T.bool,
	            disableBorders: PropTypes$1T.bool,
	            selected: PropTypes$1T.bool,
	            clickable: PropTypes$1T.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gH = (undefined && undefined.__assign) || function () {
	    __assign$gH = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gH.apply(this, arguments);
	};
	var __rest$1P = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$1b = bem("rmd-table-cell");
	/**
	 * This is mostly an internal component since it is automatically used within
	 * the `TableCell` component but this will conditionally wrap the `children`
	 * within an `UnstyledButton` to make a clickable cell. This is really to help
	 * with sort behavior within headers.
	 */
	var TableCellContent = React.forwardRef(function TableCellContent(_a, ref) {
	    var id = _a.id, propIcon = _a.icon, style = _a.style, className = _a.className, sortOrder = _a.sortOrder, children = _a.children, propRotated = _a.rotated, props = __rest$1P(_a, ["id", "icon", "style", "className", "sortOrder", "children", "rotated"]);
	    if (!sortOrder || propIcon === null) {
	        return React__default.createElement(React__default.Fragment, null, children);
	    }
	    var icon = null;
	    if (sortOrder !== "none") {
	        var rotated = propRotated !== null && propRotated !== void 0 ? propRotated : sortOrder === "descending";
	        icon = React__default.createElement(IconRotator, { rotated: rotated }, propIcon);
	    }
	    return (React__default.createElement(UnstyledButton, { id: id, ref: ref, style: style, className: classnames(block$1b("child"), className) },
	        React__default.createElement(TextIconSpacing, __assign$gH({}, props, { icon: icon }), children)));
	});
	{
	    try {
	        var PropTypes$1U = require("prop-types");
	        TableCellContent.propTypes = {
	            id: PropTypes$1U.string,
	            style: PropTypes$1U.object,
	            className: PropTypes$1U.string,
	            icon: PropTypes$1U.node,
	            sortOrder: PropTypes$1U.oneOf(["ascending", "descending", "none", "other"]),
	            rotated: PropTypes$1U.bool,
	            children: PropTypes$1U.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gI = (undefined && undefined.__assign) || function () {
	    __assign$gI = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gI.apply(this, arguments);
	};
	var __rest$1Q = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$1c = bem("rmd-table-cell");
	/**
	 * Creates a `<th>` or `<td>` cell with sensible styled defaults. You can create
	 * a `<th>` element by enabling the `header` prop OR having a `TableCell` as a
	 * child of the `TableHeader` component.
	 *
	 * Note: If you have a checkbox column in the `TableHeader` without any labels,
	 * you will need to manually set the `header={false}` prop for that cell since
	 * it is invalid to have a `<th>` without any readable content for screen
	 * readers.
	 */
	var TableCell = React.forwardRef(function TableCell(_a, ref) {
	    var _b;
	    var sortOrder = _a["aria-sort"], id = _a.id, className = _a.className, _c = _a.grow, grow = _c === void 0 ? false : _c, propScope = _a.scope, propHAlign = _a.hAlign, propVAlign = _a.vAlign, propHeader = _a.header, propDisableLineWrap = _a.lineWrap, children = _a.children, propSticky = _a.sticky, propSortIcon = _a.sortIcon, _d = _a.sortIconAfter, sortIconAfter = _d === void 0 ? false : _d, sortIconRotated = _a.sortIconRotated, disablePadding = _a.disablePadding, propColSpan = _a.colSpan, props = __rest$1Q(_a, ["aria-sort", "id", "className", "grow", "scope", "hAlign", "vAlign", "header", "lineWrap", "children", "sticky", "sortIcon", "sortIconAfter", "sortIconRotated", "disablePadding", "colSpan"]);
	    // have to double cast to get the `100%` value to work.
	    var colSpan = propColSpan;
	    var sortIcon = useIcon("sort", propSortIcon);
	    var isNoPadding = disablePadding !== null && disablePadding !== void 0 ? disablePadding : (sortIcon && sortOrder);
	    // Note: unlike the other usages of `useTableConfig`, the `propHeader`
	    // is not provided. This is so that `TableCheckbox` components can still
	    // be a sticky header without being rendered as a `<th>`. This also makes
	    // it so the scope can be defaulted to `col` or `row` automatically.
	    var _e = useTableConfig({
	        hAlign: propHAlign,
	        vAlign: propVAlign,
	        lineWrap: propDisableLineWrap,
	    }), inheritedHeader = _e.header, hAlign = _e.hAlign, vAlign = _e.vAlign, lineWrap = _e.lineWrap;
	    var header = propHeader !== null && propHeader !== void 0 ? propHeader : inheritedHeader;
	    var footer = useTableFooter();
	    var sticky = useSticky(propSticky);
	    var isStickyCell = propSticky === "cell" || (!header && sticky);
	    var isStickyHeader = propSticky === "header";
	    var isStickyFooter = sticky && footer;
	    var isStickyFooterCell = isStickyFooter && (propColSpan === "100%" || propColSpan === 0);
	    var isStickyAbove = propSticky === "header-cell" || isStickyFooterCell;
	    var scope = propScope;
	    if (!scope && header) {
	        scope = !inheritedHeader && propHeader ? "row" : "col";
	    }
	    var Component = header ? "th" : "td";
	    return (React__default.createElement(Component, __assign$gI({}, props, { ref: ref, id: id, "aria-sort": sortOrder === "none" ? undefined : sortOrder, colSpan: colSpan, className: classnames(block$1c((_b = {
	                grow: grow,
	                header: header,
	                sticky: sticky,
	                "sticky-header": (header && sticky && propSticky !== "cell") ||
	                    isStickyHeader ||
	                    isStickyAbove,
	                "sticky-cell": isStickyCell || isStickyAbove || isStickyFooterCell,
	                "sticky-footer": isStickyFooter,
	                "sticky-above": isStickyAbove
	            },
	            _b[hAlign] = hAlign !== "left",
	            _b[vAlign] = vAlign !== "middle",
	            _b.vertical = vAlign !== "middle",
	            _b["no-wrap"] = !lineWrap,
	            _b.padded = !isNoPadding && lineWrap === "padded",
	            _b["no-padding"] = isNoPadding,
	            _b)), className), scope: scope }),
	        React__default.createElement(TableCellContent, { id: id ? id + "-sort" : undefined, icon: sortIcon, iconAfter: sortIconAfter, sortOrder: sortOrder, rotated: sortIconRotated }, children)));
	});
	{
	    try {
	        var PropTypes$1V = require("prop-types");
	        TableCell.propTypes = {
	            "aria-sort": PropTypes$1V.oneOf([
	                "ascending",
	                "descending",
	                "none",
	                "other",
	            ]),
	            id: PropTypes$1V.string,
	            colSpan: PropTypes$1V.oneOfType([
	                PropTypes$1V.number,
	                PropTypes$1V.oneOf(["100%"]),
	            ]),
	            className: PropTypes$1V.string,
	            scope: PropTypes$1V.oneOf(["row", "col", "rowgroup", "colgroup"]),
	            grow: PropTypes$1V.bool,
	            hAlign: PropTypes$1V.oneOf(["left", "center", "right"]),
	            vAlign: PropTypes$1V.oneOf(["top", "middle", "bottom"]),
	            header: PropTypes$1V.bool,
	            lineWrap: PropTypes$1V.oneOfType([
	                PropTypes$1V.bool,
	                PropTypes$1V.oneOf(["padded"]),
	            ]),
	            sortIcon: PropTypes$1V.node,
	            sortIconAfter: PropTypes$1V.bool,
	            sortIconRotated: PropTypes$1V.bool,
	            disablePadding: PropTypes$1V.bool,
	            children: PropTypes$1V.node,
	            sticky: PropTypes$1V.oneOfType([
	                PropTypes$1V.bool,
	                PropTypes$1V.oneOf(["header", "cell", "header-cell"]),
	            ]),
	        };
	    }
	    catch (e) { }
	}

	var __assign$gJ = (undefined && undefined.__assign) || function () {
	    __assign$gJ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gJ.apply(this, arguments);
	};
	var __rest$1R = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * This component is really just a simple wrapper for applying the `<caption>`
	 * typography styles and probably doesn't have much real use if you don't use
	 * captions.
	 */
	var Caption = React.forwardRef(function Caption(_a, ref) {
	    var className = _a.className, children = _a.children, props = __rest$1R(_a, ["className", "children"]);
	    return (React__default.createElement("caption", __assign$gJ({}, props, { ref: ref, className: classnames("rmd-caption", className) }), children));
	});
	{
	    try {
	        var PropTypes$1W = require("prop-types");
	        Caption.propTypes = {
	            className: PropTypes$1W.string,
	            children: PropTypes$1W.node,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gK = (undefined && undefined.__assign) || function () {
	    __assign$gK = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gK.apply(this, arguments);
	};
	var __rest$1S = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var DEFAULT_ARIA_LABEL = "Toggle Row Selection";
	/**
	 * This is a simple wrapper for the `Checkbox` component that allows you to
	 * render a nicely styled `Checkbox` within a `TableCell` element. This will
	 * mostly just remove the additional padding applied and default an `aria-label`
	 * since you normally don't want a checkbox with a label within a table since
	 * it's more for selection.
	 */
	var TableCheckbox = React.forwardRef(function TableCheckbox(_a, ref) {
	    var cellId = _a.cellId, className = _a.className, id = _a.id, ariaLabel = _a["aria-label"], ariaLabelledBy = _a["aria-labelledby"], ariaChecked = _a["aria-checked"], ariaControls = _a["aria-controls"], checkboxRef = _a.checkboxRef, checkboxStyle = _a.checkboxStyle, checkboxClassName = _a.checkboxClassName, icon = _a.icon, iconStyle = _a.iconStyle, iconClassName = _a.iconClassName, toggleStyle = _a.toggleStyle, toggleClassName = _a.toggleClassName, disableIconOverlay = _a.disableIconOverlay, name = _a.name, value = _a.value, checked = _a.checked, onChange = _a.onChange, defaultChecked = _a.defaultChecked, indeterminate = _a.indeterminate, props = __rest$1S(_a, ["cellId", "className", "id", "aria-label", "aria-labelledby", "aria-checked", "aria-controls", "checkboxRef", "checkboxStyle", "checkboxClassName", "icon", "iconStyle", "iconClassName", "toggleStyle", "toggleClassName", "disableIconOverlay", "name", "value", "checked", "onChange", "defaultChecked", "indeterminate"]);
	    return (React__default.createElement(TableCell, __assign$gK({}, props, { ref: ref, id: cellId, header: false, className: classnames("rmd-table-cell--checkbox", className) }),
	        React__default.createElement(Checkbox, { id: id, "aria-label": (ariaLabel !== null && ariaLabel !== void 0 ? ariaLabel : ariaLabelledBy) ? undefined : DEFAULT_ARIA_LABEL, "aria-labelledby": ariaLabelledBy, "aria-checked": ariaChecked, "aria-controls": ariaControls, ref: checkboxRef, style: checkboxStyle, indeterminate: indeterminate, className: checkboxClassName, icon: icon, iconStyle: iconStyle, iconClassName: iconClassName, toggleStyle: toggleStyle, toggleClassName: toggleClassName, disableIconOverlay: disableIconOverlay, name: name, value: value, checked: checked, onChange: onChange, defaultChecked: defaultChecked })));
	});
	{
	    try {
	        var PropTypes$1X = require("prop-types");
	        TableCheckbox.propTypes = {
	            id: PropTypes$1X.string.isRequired,
	            className: PropTypes$1X.string,
	            "aria-label": PropTypes$1X.string,
	            "aria-labelledby": PropTypes$1X.string,
	            "aria-checked": PropTypes$1X.string,
	            "aria-controls": PropTypes$1X.string,
	            checkboxRef: PropTypes$1X.oneOfType([PropTypes$1X.func, PropTypes$1X.object]),
	            checkboxStyle: PropTypes$1X.object,
	            checkboxClassName: PropTypes$1X.string,
	            icon: PropTypes$1X.node,
	            iconStyle: PropTypes$1X.object,
	            iconClassName: PropTypes$1X.string,
	            toggleStyle: PropTypes$1X.object,
	            toggleClassName: PropTypes$1X.string,
	            disableIconOverlay: PropTypes$1X.bool,
	            name: PropTypes$1X.string,
	            value: PropTypes$1X.string,
	            checked: PropTypes$1X.bool,
	            defaultChecked: PropTypes$1X.bool,
	            onChange: PropTypes$1X.func,
	            cellId: PropTypes$1X.string,
	            indeterminate: PropTypes$1X.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gL = (undefined && undefined.__assign) || function () {
	    __assign$gL = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gL.apply(this, arguments);
	};
	var TAB_WIDTH_VAR = "--rmd-tab-width";
	var TAB_OFFSET_VAR = "--rmd-tab-offset";
	var getActiveTab = function (itemRefs, activeIndex) {
	    return (itemRefs[activeIndex] && itemRefs[activeIndex].current) || null;
	};
	/**
	 * This hook will merge the provided style object along with the required css
	 * variables for the active tab underline moving to the correct location. The
	 * indicator will be updated to be the same width as the tab along with offset
	 * by all the tabs' sizes.
	 *
	 * @private
	 */
	function useTabIndicatorStyle(_a) {
	    var style = _a.style, ref = _a.ref, align = _a.align, itemRefs = _a.itemRefs, totalTabs = _a.totalTabs, activeIndex = _a.activeIndex;
	    var _b = React.useState(function () {
	        var _a;
	        var tabWidth = 100 / totalTabs + "%";
	        return _a = {},
	            _a[TAB_WIDTH_VAR] = tabWidth,
	            _a[TAB_OFFSET_VAR] = "calc(" + activeIndex + " * " + tabWidth + ")",
	            _a;
	    }), cssVars = _b[0], setCSSVars = _b[1];
	    var prevCSSVars = React.useRef(cssVars);
	    var updateCSSVars = React.useCallback(function (itemRefs, activeIndex) {
	        var _a;
	        var activeTab = getActiveTab(itemRefs, activeIndex);
	        if (!activeTab) {
	            return;
	        }
	        var nextCSSVars = (_a = {},
	            _a[TAB_WIDTH_VAR] = activeTab.offsetWidth + "px",
	            _a[TAB_OFFSET_VAR] = activeTab.offsetLeft + "px",
	            _a);
	        var cssVars = prevCSSVars.current;
	        if (cssVars[TAB_WIDTH_VAR] !== nextCSSVars[TAB_WIDTH_VAR] ||
	            cssVars[TAB_OFFSET_VAR] !== nextCSSVars[TAB_OFFSET_VAR]) {
	            prevCSSVars.current = nextCSSVars;
	            setCSSVars(nextCSSVars);
	        }
	    }, []);
	    React.useEffect(function () {
	        updateCSSVars(itemRefs, activeIndex);
	        // has to also be triggered for align changes since the indicator offset
	        // will be incorrect for that.
	    }, [activeIndex, itemRefs, updateCSSVars, align]);
	    var tabsRef = React.useRef(null);
	    var mergedRef = React.useCallback(function (instance) {
	        applyRef(instance, ref);
	        tabsRef.current = instance;
	    }, [ref]);
	    useResizeObserver({
	        target: tabsRef,
	        onResize: function () {
	            // whenever the tabs container element is resized, it _probably_ means
	            // that the tabs will be resized or moved. this means the indicator will
	            // be in the wrong place so we need to fix it here.
	            updateCSSVars(itemRefs, activeIndex);
	        },
	    });
	    // TODO: Look into removing this resize observer. This is only required if
	    // someone manually updates the width of the tab (dev utils) or if the width
	    // was not changed due to the tabs container element resizing (iffy)
	    useResizeObserver({
	        target: function () { return getActiveTab(itemRefs, activeIndex); },
	        onResize: function () {
	            updateCSSVars(itemRefs, activeIndex);
	        },
	    });
	    var mergedStyle = React.useMemo(function () { return (__assign$gL(__assign$gL({}, style), cssVars)); }, [
	        style,
	        cssVars,
	    ]);
	    return [mergedStyle, mergedRef, tabsRef];
	}

	var __assign$gM = (undefined && undefined.__assign) || function () {
	    __assign$gM = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gM.apply(this, arguments);
	};
	/**
	 * @private
	 */
	function useTabsMovement(_a) {
	    var onClick = _a.onClick, onKeyDown = _a.onKeyDown, children = _a.children, automatic = _a.automatic, horizontal = _a.horizontal, activeIndex = _a.activeIndex, onActiveIndexChange = _a.onActiveIndexChange;
	    // first filter out all "nulled" or falsish elements since it's possible to do:
	    // {!thing && <Tab />}
	    var tabs = React.useMemo(function () { return React.Children.toArray(children).filter(Boolean); }, [
	        children,
	    ]);
	    // now filter out any other invalid elements (text nodes for some reason) and
	    // disabled tabs since they shouldn't be keyboard focusable
	    var visibleTabs = React.useMemo(function () {
	        return tabs.filter(function (child) { return React.isValidElement(child) && !child.props.disabled; });
	    }, [tabs]);
	    var _b = React.useState(activeIndex), focusedIndex = _b[0], setFocusedIndex = _b[1];
	    React.useEffect(function () {
	        setFocusedIndex(activeIndex);
	    }, [activeIndex]);
	    var _c = useKeyboardMovement(__assign$gM(__assign$gM({}, (horizontal
	        ? HORIZONTAL_TABS
	        : VERTICAL_TABS)), { onKeyDown: onKeyDown,
	        focusedIndex: focusedIndex, items: visibleTabs, onChange: function (_a) {
	            var index = _a.index;
	            if (index === -1) {
	                return;
	            }
	            if (automatic) {
	                onActiveIndexChange(index);
	            }
	            var item = itemRefs[index] && itemRefs[index].current;
	            if (item) {
	                item.focus();
	            }
	            setFocusedIndex(index);
	        } })), itemRefs = _c[0], handleKeyDown = _c[1];
	    var handleClick = React.useCallback(function (event) {
	        if (onClick) {
	            onClick(event);
	        }
	        var target = event.target && event.target.closest("button");
	        if (!target) {
	            return;
	        }
	        var index = itemRefs.findIndex(function (ref) { return ref.current === target; });
	        if (activeIndex !== index) {
	            onActiveIndexChange(index);
	        }
	    }, [activeIndex, itemRefs, onActiveIndexChange, onClick]);
	    return {
	        tabs: tabs,
	        itemRefs: itemRefs,
	        handleClick: handleClick,
	        handleKeyDown: handleKeyDown,
	    };
	}

	var __assign$gN = (undefined && undefined.__assign) || function () {
	    __assign$gN = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gN.apply(this, arguments);
	};
	var __rest$1T = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$1d = bem("rmd-tabs");
	/**
	 * The `TabsList` component is the container for all the individual `Tab`s that
	 * should be rendered. This handles adding an active indicator underneath the
	 * active tab and animating it to the new location when a new tab becomes
	 * active. It also handles the ability update which tab is selected when it has
	 * been clicked or updated with keyboard movement.
	 *
	 * This should probably not be used outside of this package unless a custom
	 * implementation is desired.
	 */
	var TabsList = React.forwardRef(function TabsList(_a, forwardedRef) {
	    var _b;
	    var style = _a.style, className = _a.className, onClick = _a.onClick, onKeyDown = _a.onKeyDown, children = _a.children, activeIndex = _a.activeIndex, _c = _a.align, align = _c === void 0 ? "left" : _c, _d = _a.automatic, automatic = _d === void 0 ? false : _d, _e = _a.padded, padded = _e === void 0 ? false : _e, _f = _a.orientation, orientation = _f === void 0 ? "horizontal" : _f, onActiveIndexChange = _a.onActiveIndexChange, _g = _a.disableTransition, disableTransition = _g === void 0 ? false : _g, props = __rest$1T(_a, ["style", "className", "onClick", "onKeyDown", "children", "activeIndex", "align", "automatic", "padded", "orientation", "onActiveIndexChange", "disableTransition"]);
	    var horizontal = orientation === "horizontal";
	    var _h = useTabsMovement({
	        onClick: onClick,
	        onKeyDown: onKeyDown,
	        children: children,
	        horizontal: horizontal,
	        activeIndex: activeIndex,
	        onActiveIndexChange: onActiveIndexChange,
	        automatic: automatic,
	    }), tabs = _h.tabs, itemRefs = _h.itemRefs, handleClick = _h.handleClick, handleKeyDown = _h.handleKeyDown;
	    var _j = useTabIndicatorStyle({
	        style: style,
	        ref: forwardedRef,
	        align: align,
	        itemRefs: itemRefs,
	        totalTabs: tabs.length,
	        activeIndex: activeIndex,
	    }), mergedStyle = _j[0], ref = _j[1], tabsRef = _j[2];
	    var isKeyboard = useIsUserInteractionMode("keyboard");
	    var prevActiveIndex = React.useRef(activeIndex);
	    React.useEffect(function () {
	        var tabs = tabsRef.current;
	        var tabRef = itemRefs[activeIndex] && itemRefs[activeIndex].current;
	        var incrementing = prevActiveIndex.current < activeIndex;
	        prevActiveIndex.current = activeIndex;
	        if (!tabs || !tabRef) {
	            return;
	        }
	        var currentX = tabs.scrollLeft + tabs.offsetWidth;
	        var tabLeft = tabRef.offsetLeft;
	        var tabWidth = tabRef.offsetWidth;
	        if (incrementing && currentX < tabLeft + tabWidth) {
	            tabs.scrollLeft = tabLeft - tabWidth;
	        }
	        else if (!incrementing && tabs.scrollLeft > tabLeft) {
	            tabs.scrollLeft = tabLeft;
	        }
	        // don't want this to trigger on itemRefs or tabsRef changes since those
	        // have a chance of updating each render.
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [activeIndex]);
	    return (React__default.createElement("div", __assign$gN({}, props, { "aria-orientation": orientation, style: mergedStyle, role: "tablist", className: classnames(block$1d((_b = {},
	            _b[align] = true,
	            _b.padded = padded,
	            _b.vertical = !horizontal,
	            _b.animate = !disableTransition && (!automatic || !isKeyboard),
	            _b)), className), ref: ref, onClick: handleClick, onKeyDown: handleKeyDown }), React.Children.map(tabs, function (child, i) {
	        if (!React.isValidElement(child)) {
	            return child;
	        }
	        var tab = React.Children.only(child);
	        var ref = itemRefs[i];
	        if (tab.props.ref) {
	            ref = function (instance) {
	                itemRefs[i].current = instance;
	                applyRef(instance, tab.props.ref);
	            };
	        }
	        return React.cloneElement(tab, { ref: ref });
	    })));
	});
	{
	    try {
	        var PropTypes$1Y = require("prop-types");
	        TabsList.propTypes = {
	            style: PropTypes$1Y.object,
	            className: PropTypes$1Y.string,
	            children: PropTypes$1Y.node,
	            onClick: PropTypes$1Y.func,
	            onKeyDown: PropTypes$1Y.func,
	            align: PropTypes$1Y.oneOf(["left", "center", "right"]),
	            automatic: PropTypes$1Y.bool,
	            padded: PropTypes$1Y.bool,
	            orientation: PropTypes$1Y.oneOf(["horizontal", "vertical"]),
	            activeIndex: PropTypes$1Y.number.isRequired,
	            onActiveIndexChange: PropTypes$1Y.func.isRequired,
	            disableTransition: PropTypes$1Y.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gO = (undefined && undefined.__assign) || function () {
	    __assign$gO = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gO.apply(this, arguments);
	};
	var __rest$1U = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$1e = bem("rmd-tab");
	/**
	 * The `Tab` is a low-level component that just renders an accessible tab widget
	 * along with some general styles and an optional icon.
	 */
	var Tab = React.forwardRef(function Tab(_a, ref) {
	    var propClassName = _a.className, contentStyle = _a.contentStyle, contentClassName = _a.contentClassName, _b = _a.disabled, disabled = _b === void 0 ? false : _b, icon = _a.icon, _c = _a.stacked, stacked = _c === void 0 ? false : _c, _d = _a.iconAfter, iconAfter = _d === void 0 ? false : _d, children = _a.children, active = _a.active, panelId = _a.panelId, disableRipple = _a.disableRipple, disableProgrammaticRipple = _a.disableProgrammaticRipple, rippleTimeout = _a.rippleTimeout, rippleClassNames = _a.rippleClassNames, rippleClassName = _a.rippleClassName, rippleContainerClassName = _a.rippleContainerClassName, enablePressedAndRipple = _a.enablePressedAndRipple, props = __rest$1U(_a, ["className", "contentStyle", "contentClassName", "disabled", "icon", "stacked", "iconAfter", "children", "active", "panelId", "disableRipple", "disableProgrammaticRipple", "rippleTimeout", "rippleClassNames", "rippleClassName", "rippleContainerClassName", "enablePressedAndRipple"]);
	    var _e = useInteractionStates({
	        handlers: props,
	        className: propClassName,
	        disabled: disabled,
	        disableRipple: disableRipple,
	        disableProgrammaticRipple: disableProgrammaticRipple,
	        rippleTimeout: rippleTimeout,
	        rippleClassNames: rippleClassNames,
	        rippleClassName: rippleClassName,
	        rippleContainerClassName: rippleContainerClassName,
	        enablePressedAndRipple: enablePressedAndRipple,
	    }), ripples = _e.ripples, className = _e.className, handlers = _e.handlers;
	    return (React__default.createElement("button", __assign$gO({}, props, handlers, { ref: ref, "aria-selected": active, "aria-controls": panelId, type: "button", role: "tab", disabled: disabled, className: classnames(block$1e({ active: active, stacked: icon && stacked }), className), tabIndex: active ? undefined : -1 }),
	        React__default.createElement(TextIconSpacing, { icon: icon, stacked: stacked, iconAfter: iconAfter },
	            React__default.createElement("span", { style: contentStyle, className: classnames(block$1e("content"), contentClassName) }, children)),
	        ripples));
	});
	{
	    try {
	        var PropTypes$1Z = require("prop-types");
	        Tab.propTypes = {
	            id: PropTypes$1Z.string.isRequired,
	            panelId: PropTypes$1Z.string,
	            active: PropTypes$1Z.bool.isRequired,
	            className: PropTypes$1Z.string,
	            contentStyle: PropTypes$1Z.object,
	            contentClassName: PropTypes$1Z.string,
	            children: PropTypes$1Z.node,
	            icon: PropTypes$1Z.node,
	            stacked: PropTypes$1Z.bool,
	            iconAfter: PropTypes$1Z.bool,
	            disabled: PropTypes$1Z.bool,
	            onKeyDown: PropTypes$1Z.func,
	            disableRipple: PropTypes$1Z.bool,
	            disableProgrammaticRipple: PropTypes$1Z.bool,
	            rippleTimeout: PropTypes$1Z.oneOfType([
	                PropTypes$1Z.number,
	                PropTypes$1Z.shape({
	                    appear: PropTypes$1Z.number,
	                    enter: PropTypes$1Z.number,
	                    exit: PropTypes$1Z.number,
	                }),
	            ]),
	            rippleClassNames: PropTypes$1Z.oneOfType([
	                PropTypes$1Z.string,
	                PropTypes$1Z.shape({
	                    appear: PropTypes$1Z.string,
	                    appearActive: PropTypes$1Z.string,
	                    enter: PropTypes$1Z.string,
	                    enterActive: PropTypes$1Z.string,
	                    enterDone: PropTypes$1Z.string,
	                    exit: PropTypes$1Z.string,
	                    exitActive: PropTypes$1Z.string,
	                    exitDone: PropTypes$1Z.string,
	                }),
	            ]),
	            rippleClassName: PropTypes$1Z.string,
	            rippleContainerClassName: PropTypes$1Z.string,
	            enablePressedAndRipple: PropTypes$1Z.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gP = (undefined && undefined.__assign) || function () {
	    __assign$gP = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gP.apply(this, arguments);
	};
	var context$7 = React.createContext({
	    tabsId: "tabs",
	    activeIndex: 0,
	    onActiveIndexChange: function () { },
	    tabs: [],
	});
	/**
	 * This hook returns the current "state" for the tabs which can be useful if you
	 * need additional control or access to the tabs behavior.
	 */
	function useTabs() {
	    return React.useContext(context$7);
	}
	var Provider$4 = context$7.Provider;
	/**
	 * The `TabsManager` is used to configure your `Tabs` component and handle some
	 * of the default behavior such as:
	 *
	 * - controlling the `activeIndex`
	 * - general tab configuration
	 * - callbacks when the tab has changed
	 * - providing an `id` prefix for all tabs for simplicity
	 */
	function TabsManager(_a) {
	    var tabsId = _a.tabsId, _b = _a.defaultActiveIndex, defaultActiveIndex = _b === void 0 ? 0 : _b, propActiveIndex = _a.activeIndex, onActiveIndexChange = _a.onActiveIndexChange, tabs = _a.tabs, _c = _a.stacked, stacked = _c === void 0 ? false : _c, _d = _a.iconAfter, iconAfter = _d === void 0 ? false : _d, children = _a.children;
	    var _e = React.useState(defaultActiveIndex), localActiveIndex = _e[0], setActiveIndex = _e[1];
	    var handleActiveIndexChange = React.useCallback(function (activeIndex) {
	        if (onActiveIndexChange) {
	            onActiveIndexChange(activeIndex);
	        }
	        setActiveIndex(activeIndex);
	    }, [onActiveIndexChange]);
	    var activeIndex = typeof propActiveIndex === "number" ? propActiveIndex : localActiveIndex;
	    var updateActiveIndex = typeof propActiveIndex === "number"
	        ? onActiveIndexChange
	        : handleActiveIndexChange;
	    var value = React.useMemo(function () { return ({
	        activeIndex: activeIndex,
	        onActiveIndexChange: updateActiveIndex,
	        tabs: tabs.map(function (config, i) {
	            var tab;
	            if (typeof config === "string" || React.isValidElement(config)) {
	                tab = { children: config };
	            }
	            else {
	                tab = config;
	            }
	            return __assign$gP(__assign$gP({}, tab), { id: tab.id || tabsId + "-tab-" + (i + 1), panelId: activeIndex === i
	                    ? tabsId + "-panel-" + (activeIndex + 1)
	                    : undefined, stacked: typeof tab.stacked === "boolean" ? tab.stacked : stacked, iconAfter: typeof tab.iconAfter === "boolean" ? tab.iconAfter : iconAfter });
	        }),
	        tabsId: tabsId,
	    }); }, [activeIndex, iconAfter, stacked, tabs, tabsId, updateActiveIndex]);
	    return React__default.createElement(Provider$4, { value: value }, children);
	}

	var __assign$gQ = (undefined && undefined.__assign) || function () {
	    __assign$gQ = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gQ.apply(this, arguments);
	};
	var __rest$1V = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	/**
	 * The `Tabs` component is used to render all the configured `tabs` from the
	 * parent `TabsManager` component inside of the `TabsList`.
	 */
	var Tabs = React.forwardRef(function Tabs(props, ref) {
	    var _a = useTabs(), tabsId = _a.tabsId, tabs = _a.tabs, activeIndex = _a.activeIndex, onActiveIndexChange = _a.onActiveIndexChange;
	    return (React__default.createElement(TabsList, __assign$gQ({}, props, { id: tabsId, ref: ref, activeIndex: activeIndex, onActiveIndexChange: onActiveIndexChange }), tabs.map(function (_a, index) {
	        var id = _a.id, config = __rest$1V(_a, ["id"]);
	        return (React__default.createElement(Tab, __assign$gQ({}, config, { id: id, key: id, active: activeIndex === index })));
	    })));
	});

	function _assertThisInitialized(self) {
	  if (self === void 0) {
	    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
	  }

	  return self;
	}

	/**
	 * Given `this.props.children`, return an object mapping key to child.
	 *
	 * @param {*} children `this.props.children`
	 * @return {object} Mapping of key to child
	 */

	function getChildMapping(children, mapFn) {
	  var mapper = function mapper(child) {
	    return mapFn && React.isValidElement(child) ? mapFn(child) : child;
	  };

	  var result = Object.create(null);
	  if (children) React.Children.map(children, function (c) {
	    return c;
	  }).forEach(function (child) {
	    // run the map function here instead so that the key is the computed one
	    result[child.key] = mapper(child);
	  });
	  return result;
	}
	/**
	 * When you're adding or removing children some may be added or removed in the
	 * same render pass. We want to show *both* since we want to simultaneously
	 * animate elements in and out. This function takes a previous set of keys
	 * and a new set of keys and merges them with its best guess of the correct
	 * ordering. In the future we may expose some of the utilities in
	 * ReactMultiChild to make this easy, but for now React itself does not
	 * directly have this concept of the union of prevChildren and nextChildren
	 * so we implement it here.
	 *
	 * @param {object} prev prev children as returned from
	 * `ReactTransitionChildMapping.getChildMapping()`.
	 * @param {object} next next children as returned from
	 * `ReactTransitionChildMapping.getChildMapping()`.
	 * @return {object} a key set that contains all keys in `prev` and all keys
	 * in `next` in a reasonable order.
	 */

	function mergeChildMappings(prev, next) {
	  prev = prev || {};
	  next = next || {};

	  function getValueForKey(key) {
	    return key in next ? next[key] : prev[key];
	  } // For each key of `next`, the list of keys to insert before that key in
	  // the combined list


	  var nextKeysPending = Object.create(null);
	  var pendingKeys = [];

	  for (var prevKey in prev) {
	    if (prevKey in next) {
	      if (pendingKeys.length) {
	        nextKeysPending[prevKey] = pendingKeys;
	        pendingKeys = [];
	      }
	    } else {
	      pendingKeys.push(prevKey);
	    }
	  }

	  var i;
	  var childMapping = {};

	  for (var nextKey in next) {
	    if (nextKeysPending[nextKey]) {
	      for (i = 0; i < nextKeysPending[nextKey].length; i++) {
	        var pendingNextKey = nextKeysPending[nextKey][i];
	        childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);
	      }
	    }

	    childMapping[nextKey] = getValueForKey(nextKey);
	  } // Finally, add the keys which didn't appear before any key in `next`


	  for (i = 0; i < pendingKeys.length; i++) {
	    childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);
	  }

	  return childMapping;
	}

	function getProp(child, prop, props) {
	  return props[prop] != null ? props[prop] : child.props[prop];
	}

	function getInitialChildMapping(props, onExited) {
	  return getChildMapping(props.children, function (child) {
	    return React.cloneElement(child, {
	      onExited: onExited.bind(null, child),
	      in: true,
	      appear: getProp(child, 'appear', props),
	      enter: getProp(child, 'enter', props),
	      exit: getProp(child, 'exit', props)
	    });
	  });
	}
	function getNextChildMapping(nextProps, prevChildMapping, onExited) {
	  var nextChildMapping = getChildMapping(nextProps.children);
	  var children = mergeChildMappings(prevChildMapping, nextChildMapping);
	  Object.keys(children).forEach(function (key) {
	    var child = children[key];
	    if (!React.isValidElement(child)) return;
	    var hasPrev = key in prevChildMapping;
	    var hasNext = key in nextChildMapping;
	    var prevChild = prevChildMapping[key];
	    var isLeaving = React.isValidElement(prevChild) && !prevChild.props.in; // item is new (entering)

	    if (hasNext && (!hasPrev || isLeaving)) {
	      // console.log('entering', key)
	      children[key] = React.cloneElement(child, {
	        onExited: onExited.bind(null, child),
	        in: true,
	        exit: getProp(child, 'exit', nextProps),
	        enter: getProp(child, 'enter', nextProps)
	      });
	    } else if (!hasNext && hasPrev && !isLeaving) {
	      // item is old (exiting)
	      // console.log('leaving', key)
	      children[key] = React.cloneElement(child, {
	        in: false
	      });
	    } else if (hasNext && hasPrev && React.isValidElement(prevChild)) {
	      // item hasn't changed transition states
	      // copy over the last transition props;
	      // console.log('unchanged', key)
	      children[key] = React.cloneElement(child, {
	        onExited: onExited.bind(null, child),
	        in: prevChild.props.in,
	        exit: getProp(child, 'exit', nextProps),
	        enter: getProp(child, 'enter', nextProps)
	      });
	    }
	  });
	  return children;
	}

	var values = Object.values || function (obj) {
	  return Object.keys(obj).map(function (k) {
	    return obj[k];
	  });
	};

	var defaultProps$1 = {
	  component: 'div',
	  childFactory: function childFactory(child) {
	    return child;
	  }
	  /**
	   * The `<TransitionGroup>` component manages a set of transition components
	   * (`<Transition>` and `<CSSTransition>`) in a list. Like with the transition
	   * components, `<TransitionGroup>` is a state machine for managing the mounting
	   * and unmounting of components over time.
	   *
	   * Consider the example below. As items are removed or added to the TodoList the
	   * `in` prop is toggled automatically by the `<TransitionGroup>`.
	   *
	   * Note that `<TransitionGroup>`  does not define any animation behavior!
	   * Exactly _how_ a list item animates is up to the individual transition
	   * component. This means you can mix and match animations across different list
	   * items.
	   */

	};

	var TransitionGroup =
	/*#__PURE__*/
	function (_React$Component) {
	  _inheritsLoose(TransitionGroup, _React$Component);

	  function TransitionGroup(props, context) {
	    var _this;

	    _this = _React$Component.call(this, props, context) || this;

	    var handleExited = _this.handleExited.bind(_assertThisInitialized(_assertThisInitialized(_this))); // Initial children should all be entering, dependent on appear


	    _this.state = {
	      contextValue: {
	        isMounting: true
	      },
	      handleExited: handleExited,
	      firstRender: true
	    };
	    return _this;
	  }

	  var _proto = TransitionGroup.prototype;

	  _proto.componentDidMount = function componentDidMount() {
	    this.mounted = true;
	    this.setState({
	      contextValue: {
	        isMounting: false
	      }
	    });
	  };

	  _proto.componentWillUnmount = function componentWillUnmount() {
	    this.mounted = false;
	  };

	  TransitionGroup.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) {
	    var prevChildMapping = _ref.children,
	        handleExited = _ref.handleExited,
	        firstRender = _ref.firstRender;
	    return {
	      children: firstRender ? getInitialChildMapping(nextProps, handleExited) : getNextChildMapping(nextProps, prevChildMapping, handleExited),
	      firstRender: false
	    };
	  };

	  _proto.handleExited = function handleExited(child, node) {
	    var currentChildMapping = getChildMapping(this.props.children);
	    if (child.key in currentChildMapping) return;

	    if (child.props.onExited) {
	      child.props.onExited(node);
	    }

	    if (this.mounted) {
	      this.setState(function (state) {
	        var children = _extends({}, state.children);

	        delete children[child.key];
	        return {
	          children: children
	        };
	      });
	    }
	  };

	  _proto.render = function render() {
	    var _this$props = this.props,
	        Component = _this$props.component,
	        childFactory = _this$props.childFactory,
	        props = _objectWithoutPropertiesLoose(_this$props, ["component", "childFactory"]);

	    var contextValue = this.state.contextValue;
	    var children = values(this.state.children).map(childFactory);
	    delete props.appear;
	    delete props.enter;
	    delete props.exit;

	    if (Component === null) {
	      return React__default.createElement(TransitionGroupContext.Provider, {
	        value: contextValue
	      }, children);
	    }

	    return React__default.createElement(TransitionGroupContext.Provider, {
	      value: contextValue
	    }, React__default.createElement(Component, props, children));
	  };

	  return TransitionGroup;
	}(React__default.Component);

	TransitionGroup.propTypes =  {
	  /**
	   * `<TransitionGroup>` renders a `<div>` by default. You can change this
	   * behavior by providing a `component` prop.
	   * If you use React v16+ and would like to avoid a wrapping `<div>` element
	   * you can pass in `component={null}`. This is useful if the wrapping div
	   * borks your css styles.
	   */
	  component: propTypes.any,

	  /**
	   * A set of `<Transition>` components, that are toggled `in` and out as they
	   * leave. the `<TransitionGroup>` will inject specific transition props, so
	   * remember to spread them through if you are wrapping the `<Transition>` as
	   * with our `<Fade>` example.
	   *
	   * While this component is meant for multiple `Transition` or `CSSTransition`
	   * children, sometimes you may want to have a single transition child with
	   * content that you want to be transitioned out and in when you change it
	   * (e.g. routes, images etc.) In that case you can change the `key` prop of
	   * the transition child as you change its content, this will cause
	   * `TransitionGroup` to transition the child out and back in.
	   */
	  children: propTypes.node,

	  /**
	   * A convenience prop that enables or disables appear animations
	   * for all children. Note that specifying this will override any defaults set
	   * on individual children Transitions.
	   */
	  appear: propTypes.bool,

	  /**
	   * A convenience prop that enables or disables enter animations
	   * for all children. Note that specifying this will override any defaults set
	   * on individual children Transitions.
	   */
	  enter: propTypes.bool,

	  /**
	   * A convenience prop that enables or disables exit animations
	   * for all children. Note that specifying this will override any defaults set
	   * on individual children Transitions.
	   */
	  exit: propTypes.bool,

	  /**
	   * You may need to apply reactive updates to a child as it is exiting.
	   * This is generally done by using `cloneElement` however in the case of an exiting
	   * child the element has already been removed and not accessible to the consumer.
	   *
	   * If you do need to update a child as it leaves you can provide a `childFactory`
	   * to wrap every child, even the ones that are leaving.
	   *
	   * @type Function(child: ReactElement) -> ReactElement
	   */
	  childFactory: propTypes.func
	} ;
	TransitionGroup.defaultProps = defaultProps$1;

	/* eslint-disable react/prop-types */
	/**
	 * @private
	 */
	function PanelGroup(_a) {
	    var persistent = _a.persistent, disableTransition = _a.disableTransition, children = _a.children;
	    if (persistent) {
	        return React__default.createElement(React__default.Fragment, null, children);
	    }
	    return (React__default.createElement(TransitionGroup, { component: null, appear: !disableTransition, enter: !disableTransition, exit: !disableTransition }, children));
	}

	var __assign$gR = (undefined && undefined.__assign) || function () {
	    __assign$gR = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gR.apply(this, arguments);
	};
	var __rest$1W = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$1f = bem("rmd-tab-panels");
	/**
	 * This component allows you to control the visibility of the `TabPanel`
	 * components and animating the next and current panels as needed. This works by
	 * looping over all the children and getting the current `TabPanel` by the
	 * `activeIndex`. This is why the children for this component can only be
	 * `TabPanel` and should not be conditional.
	 */
	var TabPanels = React.forwardRef(function TabPanels(_a, forwardedRef) {
	    var className = _a.className, children = _a.children, _b = _a.disableScrollFix, disableScrollFix = _b === void 0 ? false : _b, _c = _a.disableTransition, disableTransition = _c === void 0 ? false : _c, _d = _a.persistent, persistent = _d === void 0 ? false : _d, props = __rest$1W(_a, ["className", "children", "disableScrollFix", "disableTransition", "persistent"]);
	    var _e = useTabs(), tabsId = _e.tabsId, tabs = _e.tabs, activeIndex = _e.activeIndex;
	    var prevIndex = React.useRef(activeIndex);
	    var _f = React.useState({
	        previous: activeIndex,
	        incrementing: true,
	    }), _g = _f[0], previous = _g.previous, incrementing = _g.incrementing, setState = _f[1];
	    // have to set these in refs since changing these might cause mounting
	    // and unmounting in the Transition group component :/ they should only
	    // be re-evaluated when the activeIndex changes.
	    var transitionable = React.useRef(!persistent && !disableTransition);
	    var animimatable = React.useRef(persistent && !disableTransition);
	    if (prevIndex.current !== activeIndex) {
	        prevIndex.current = activeIndex;
	        transitionable.current = !persistent && !disableTransition;
	        animimatable.current = persistent && !disableTransition;
	    }
	    React.useEffect(function () {
	        setState(function (_a) {
	            var previous = _a.previous;
	            return ({
	                incrementing: previous < activeIndex,
	                previous: disableTransition ? activeIndex : previous,
	            });
	        });
	        // this is for only updating the incrementing state and should not be fired
	        // again if the disableTransition prop is changed
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [activeIndex]);
	    var onEntered = React.useCallback(function () {
	        setState(function (_a) {
	            var incrementing = _a.incrementing;
	            return ({ incrementing: incrementing, previous: activeIndex });
	        });
	    }, [activeIndex]);
	    var ref = React.useRef(null);
	    var mergedRef = React.useCallback(function (instance) {
	        applyRef(instance, forwardedRef);
	        ref.current = instance;
	    }, [forwardedRef]);
	    React.useEffect(function () {
	        if (!ref.current || disableScrollFix) {
	            return;
	        }
	        ref.current.scrollTop = 0;
	        // don't want it to be triggered if only the disableScrollFix prop has changed
	        // since it might be independent from active indexes
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	    }, [activeIndex]);
	    return (React__default.createElement("div", __assign$gR({}, props, { ref: mergedRef, className: classnames(block$1f({
	            "slide-left": incrementing && !persistent,
	            "slide-left-persistent": incrementing && persistent,
	            "slide-right": !incrementing,
	        }), className) }),
	        React__default.createElement(PanelGroup, { persistent: persistent, disableTransition: disableTransition }, React.Children.map(children, function (child, index) {
	            if (!persistent && index !== activeIndex) {
	                return null;
	            }
	            if (!React.isValidElement(child)) {
	                return child;
	            }
	            var panel = React.Children.only(child);
	            var labelledBy = panel.props["aria-labelledby"];
	            if (!labelledBy && !panel.props["aria-label"] && tabs[index]) {
	                // generally guaranteed to be defined by this point since the TabsManager
	                // will add ids if missing.
	                labelledBy = tabs[index].id;
	            }
	            var key = panel.key || undefined;
	            if (index === activeIndex && transitionable.current) {
	                key = "" + activeIndex;
	            }
	            var animateIn = panel.props.in;
	            if (animimatable.current) {
	                // when the persistent flag is in, I have too handle the TransitionGroup
	                // `in` behavior manually based on activeIndex
	                animateIn = index === activeIndex;
	            }
	            var hidden = index !== activeIndex;
	            if (persistent) {
	                hidden = hidden && index !== previous;
	            }
	            return React.cloneElement(child, {
	                key: key,
	                in: animateIn,
	                id: tabsId + "-panel-" + (index + 1),
	                "aria-labelledby": labelledBy,
	                hidden: hidden,
	                onEntered: disableTransition ? undefined : onEntered,
	            });
	        }))));
	});
	{
	    try {
	        var PropTypes$1_ = require("prop-types");
	        TabPanels.propTypes = {
	            className: PropTypes$1_.string,
	            children: PropTypes$1_.node,
	            disableScrollFix: PropTypes$1_.bool,
	            disableTransition: PropTypes$1_.bool,
	            persistent: PropTypes$1_.bool,
	        };
	    }
	    catch (e) { }
	}

	var __assign$gS = (undefined && undefined.__assign) || function () {
	    __assign$gS = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$gS.apply(this, arguments);
	};
	var __rest$1X = (undefined && undefined.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var block$1g = bem("rmd-tab-panel");
	var prefix = "rmd-tab-panel";
	var DEFAULT_TABPANEL_CLASSNAMES = {
	    enter: prefix + "--enter",
	    enterActive: prefix + "--enter-active " + prefix + "--animate",
	    exit: prefix + "--exit",
	    exitActive: prefix + "--exit-active " + prefix + "--animate",
	};
	/**
	 * This component renders an accessible tab panel with enter and exit
	 * animations.  This probably should only be used internally as it relies on the
	 * `TabPanels` component along with the `TransitionGroup` from
	 * `react-transition-group` to work as expected.
	 */
	var TabPanel = React.forwardRef(function TabPanel(_a, ref) {
	    var className = _a.className, transitionIn = _a.in, appear = _a.appear, enter = _a.enter, exit = _a.exit, onEnter = _a.onEnter, onEntering = _a.onEntering, onEntered = _a.onEntered, onExit = _a.onExit, onExiting = _a.onExiting, onExited = _a.onExited, _b = _a.timeout, timeout = _b === void 0 ? 150 : _b, _c = _a.classNames, classNames = _c === void 0 ? DEFAULT_TABPANEL_CLASSNAMES : _c, children = _a.children, hidden = _a.hidden, props = __rest$1X(_a, ["className", "in", "appear", "enter", "exit", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "timeout", "classNames", "children", "hidden"]);
	    return (React__default.createElement(CSSTransition, { in: transitionIn && !hidden, appear: appear, enter: enter, exit: exit, onEnter: onEnter, onEntering: onEntering, onEntered: onEntered, onExit: onExit, onExiting: onExiting, onExited: onExited, timeout: timeout, classNames: classNames },
	        React__default.createElement("div", __assign$gS({}, props, { ref: ref, role: "tabpanel", hidden: hidden, className: classnames(block$1g(), className) }), children)));
	});
	{
	    try {
	        var PropTypes$1$ = require("prop-types");
	        TabPanel.propTypes = {
	            className: PropTypes$1$.string,
	            timeout: PropTypes$1$.oneOfType([
	                PropTypes$1$.number,
	                PropTypes$1$.shape({
	                    enter: PropTypes$1$.number,
	                    exit: PropTypes$1$.number,
	                }),
	            ]),
	            in: PropTypes$1$.bool,
	            appear: PropTypes$1$.bool,
	            enter: PropTypes$1$.bool,
	            exit: PropTypes$1$.bool,
	            onEnter: PropTypes$1$.func,
	            onEntering: PropTypes$1$.func,
	            onEntered: PropTypes$1$.func,
	            onExit: PropTypes$1$.func,
	            onExiting: PropTypes$1$.func,
	            onExited: PropTypes$1$.func,
	            classNames: PropTypes$1$.oneOfType([
	                PropTypes$1$.string,
	                PropTypes$1$.shape({
	                    appear: PropTypes$1$.string,
	                    appearActive: PropTypes$1$.string,
	                    enter: PropTypes$1$.string,
	                    enterActive: PropTypes$1$.string,
	                    enterDone: PropTypes$1$.string,
	                    exit: PropTypes$1$.string,
	                    exitActive: PropTypes$1$.string,
	                    exitDone: PropTypes$1$.string,
	                }),
	            ]),
	            hidden: PropTypes$1$.bool,
	            children: PropTypes$1$.node,
	        };
	    }
	    catch (e) { }
	}

	exports.ABOVE_CENTER_ANCHOR = ABOVE_CENTER_ANCHOR;
	exports.ABOVE_INNER_LEFT_ANCHOR = ABOVE_INNER_LEFT_ANCHOR;
	exports.ABOVE_INNER_RIGHT_ANCHOR = ABOVE_INNER_RIGHT_ANCHOR;
	exports.ABOVE_LEFT_ANCHOR = ABOVE_LEFT_ANCHOR;
	exports.ABOVE_RIGHT_ANCHOR = ABOVE_RIGHT_ANCHOR;
	exports.APP_BAR_OFFSET_CLASSNAME = APP_BAR_OFFSET_CLASSNAME;
	exports.APP_BAR_OFFSET_DENSE_CLASSNAME = APP_BAR_OFFSET_DENSE_CLASSNAME;
	exports.APP_BAR_OFFSET_PROMINENT_CLASSNAME = APP_BAR_OFFSET_PROMINENT_CLASSNAME;
	exports.APP_BAR_OFFSET_PROMINENT_DENSE_CLASSNAME = APP_BAR_OFFSET_PROMINENT_DENSE_CLASSNAME;
	exports.AcUnitFontIcon = AcUnitFontIcon;
	exports.AccessAlarmFontIcon = AccessAlarmFontIcon;
	exports.AccessAlarmsFontIcon = AccessAlarmsFontIcon;
	exports.AccessTimeFontIcon = AccessTimeFontIcon;
	exports.AccessibilityFontIcon = AccessibilityFontIcon;
	exports.AccessibleFontIcon = AccessibleFontIcon;
	exports.AccountBalanceFontIcon = AccountBalanceFontIcon;
	exports.AccountBalanceWalletFontIcon = AccountBalanceWalletFontIcon;
	exports.AccountBoxFontIcon = AccountBoxFontIcon;
	exports.AccountCircleFontIcon = AccountCircleFontIcon;
	exports.AdbFontIcon = AdbFontIcon;
	exports.AddAPhotoFontIcon = AddAPhotoFontIcon;
	exports.AddAlarmFontIcon = AddAlarmFontIcon;
	exports.AddAlertFontIcon = AddAlertFontIcon;
	exports.AddBoxFontIcon = AddBoxFontIcon;
	exports.AddCircleFontIcon = AddCircleFontIcon;
	exports.AddCircleOutlineFontIcon = AddCircleOutlineFontIcon;
	exports.AddFontIcon = AddFontIcon;
	exports.AddLocationFontIcon = AddLocationFontIcon;
	exports.AddMessageContext = AddMessageContext;
	exports.AddShoppingCartFontIcon = AddShoppingCartFontIcon;
	exports.AddToPhotosFontIcon = AddToPhotosFontIcon;
	exports.AddToQueueFontIcon = AddToQueueFontIcon;
	exports.AdjustFontIcon = AdjustFontIcon;
	exports.AirlineSeatFlatAngledFontIcon = AirlineSeatFlatAngledFontIcon;
	exports.AirlineSeatFlatFontIcon = AirlineSeatFlatFontIcon;
	exports.AirlineSeatIndividualSuiteFontIcon = AirlineSeatIndividualSuiteFontIcon;
	exports.AirlineSeatLegroomExtraFontIcon = AirlineSeatLegroomExtraFontIcon;
	exports.AirlineSeatLegroomNormalFontIcon = AirlineSeatLegroomNormalFontIcon;
	exports.AirlineSeatLegroomReducedFontIcon = AirlineSeatLegroomReducedFontIcon;
	exports.AirlineSeatReclineExtraFontIcon = AirlineSeatReclineExtraFontIcon;
	exports.AirlineSeatReclineNormalFontIcon = AirlineSeatReclineNormalFontIcon;
	exports.AirplanemodeActiveFontIcon = AirplanemodeActiveFontIcon;
	exports.AirplanemodeInactiveFontIcon = AirplanemodeInactiveFontIcon;
	exports.AirplayFontIcon = AirplayFontIcon;
	exports.AirportShuttleFontIcon = AirportShuttleFontIcon;
	exports.AlarmAddFontIcon = AlarmAddFontIcon;
	exports.AlarmFontIcon = AlarmFontIcon;
	exports.AlarmOffFontIcon = AlarmOffFontIcon;
	exports.AlarmOnFontIcon = AlarmOnFontIcon;
	exports.AlbumFontIcon = AlbumFontIcon;
	exports.AllInclusiveFontIcon = AllInclusiveFontIcon;
	exports.AllOutFontIcon = AllOutFontIcon;
	exports.AndroidFontIcon = AndroidFontIcon;
	exports.AnnouncementFontIcon = AnnouncementFontIcon;
	exports.AppBar = AppBar;
	exports.AppBarAction = AppBarAction;
	exports.AppBarNav = AppBarNav;
	exports.AppBarTitle = AppBarTitle;
	exports.AppSizeListener = AppSizeListener;
	exports.AppsFontIcon = AppsFontIcon;
	exports.ArchiveFontIcon = ArchiveFontIcon;
	exports.ArrowBackFontIcon = ArrowBackFontIcon;
	exports.ArrowDownwardFontIcon = ArrowDownwardFontIcon;
	exports.ArrowDropDownCircleFontIcon = ArrowDropDownCircleFontIcon;
	exports.ArrowDropDownFontIcon = ArrowDropDownFontIcon;
	exports.ArrowDropUpFontIcon = ArrowDropUpFontIcon;
	exports.ArrowForwardFontIcon = ArrowForwardFontIcon;
	exports.ArrowUpwardFontIcon = ArrowUpwardFontIcon;
	exports.ArtTrackFontIcon = ArtTrackFontIcon;
	exports.AspectRatioFontIcon = AspectRatioFontIcon;
	exports.AssessmentFontIcon = AssessmentFontIcon;
	exports.AssignmentFontIcon = AssignmentFontIcon;
	exports.AssignmentIndFontIcon = AssignmentIndFontIcon;
	exports.AssignmentLateFontIcon = AssignmentLateFontIcon;
	exports.AssignmentReturnFontIcon = AssignmentReturnFontIcon;
	exports.AssignmentReturnedFontIcon = AssignmentReturnedFontIcon;
	exports.AssignmentTurnedInFontIcon = AssignmentTurnedInFontIcon;
	exports.AssistantFontIcon = AssistantFontIcon;
	exports.AssistantPhotoFontIcon = AssistantPhotoFontIcon;
	exports.AsyncSwitch = AsyncSwitch;
	exports.AttachFileFontIcon = AttachFileFontIcon;
	exports.AttachMoneyFontIcon = AttachMoneyFontIcon;
	exports.AttachmentFontIcon = AttachmentFontIcon;
	exports.AudiotrackFontIcon = AudiotrackFontIcon;
	exports.AutoComplete = AutoComplete;
	exports.AutorenewFontIcon = AutorenewFontIcon;
	exports.AvTimerFontIcon = AvTimerFontIcon;
	exports.Avatar = Avatar;
	exports.BELOW_CENTER_ANCHOR = BELOW_CENTER_ANCHOR;
	exports.BELOW_INNER_LEFT_ANCHOR = BELOW_INNER_LEFT_ANCHOR;
	exports.BELOW_INNER_RIGHT_ANCHOR = BELOW_INNER_RIGHT_ANCHOR;
	exports.BELOW_LEFT_ANCHOR = BELOW_LEFT_ANCHOR;
	exports.BELOW_RIGHT_ANCHOR = BELOW_RIGHT_ANCHOR;
	exports.BOTTOM_CENTER_ANCHOR = BOTTOM_CENTER_ANCHOR;
	exports.BOTTOM_INNER_LEFT_ANCHOR = BOTTOM_INNER_LEFT_ANCHOR;
	exports.BOTTOM_INNER_RIGHT_ANCHOR = BOTTOM_INNER_RIGHT_ANCHOR;
	exports.BOTTOM_LEFT_ANCHOR = BOTTOM_LEFT_ANCHOR;
	exports.BOTTOM_RIGHT_ANCHOR = BOTTOM_RIGHT_ANCHOR;
	exports.BackspaceFontIcon = BackspaceFontIcon;
	exports.BackupFontIcon = BackupFontIcon;
	exports.Badge = Badge;
	exports.BadgeContainer = BadgeContainer;
	exports.BadgedButton = BadgedButton;
	exports.BatteryAlertFontIcon = BatteryAlertFontIcon;
	exports.BatteryChargingFullFontIcon = BatteryChargingFullFontIcon;
	exports.BatteryFullFontIcon = BatteryFullFontIcon;
	exports.BatteryStdFontIcon = BatteryStdFontIcon;
	exports.BatteryUnknownFontIcon = BatteryUnknownFontIcon;
	exports.BeachAccessFontIcon = BeachAccessFontIcon;
	exports.BeenhereFontIcon = BeenhereFontIcon;
	exports.BlockFontIcon = BlockFontIcon;
	exports.BluetoothAudioFontIcon = BluetoothAudioFontIcon;
	exports.BluetoothConnectedFontIcon = BluetoothConnectedFontIcon;
	exports.BluetoothDisabledFontIcon = BluetoothDisabledFontIcon;
	exports.BluetoothFontIcon = BluetoothFontIcon;
	exports.BluetoothSearchingFontIcon = BluetoothSearchingFontIcon;
	exports.BlurCircularFontIcon = BlurCircularFontIcon;
	exports.BlurLinearFontIcon = BlurLinearFontIcon;
	exports.BlurOffFontIcon = BlurOffFontIcon;
	exports.BlurOnFontIcon = BlurOnFontIcon;
	exports.BookFontIcon = BookFontIcon;
	exports.BookmarkBorderFontIcon = BookmarkBorderFontIcon;
	exports.BookmarkFontIcon = BookmarkFontIcon;
	exports.BorderAllFontIcon = BorderAllFontIcon;
	exports.BorderBottomFontIcon = BorderBottomFontIcon;
	exports.BorderClearFontIcon = BorderClearFontIcon;
	exports.BorderColorFontIcon = BorderColorFontIcon;
	exports.BorderHorizontalFontIcon = BorderHorizontalFontIcon;
	exports.BorderInnerFontIcon = BorderInnerFontIcon;
	exports.BorderLeftFontIcon = BorderLeftFontIcon;
	exports.BorderOuterFontIcon = BorderOuterFontIcon;
	exports.BorderRightFontIcon = BorderRightFontIcon;
	exports.BorderStyleFontIcon = BorderStyleFontIcon;
	exports.BorderTopFontIcon = BorderTopFontIcon;
	exports.BorderVerticalFontIcon = BorderVerticalFontIcon;
	exports.BrandingWatermarkFontIcon = BrandingWatermarkFontIcon;
	exports.Brightness1FontIcon = Brightness1FontIcon;
	exports.Brightness2FontIcon = Brightness2FontIcon;
	exports.Brightness3FontIcon = Brightness3FontIcon;
	exports.Brightness4FontIcon = Brightness4FontIcon;
	exports.Brightness5FontIcon = Brightness5FontIcon;
	exports.Brightness6FontIcon = Brightness6FontIcon;
	exports.Brightness7FontIcon = Brightness7FontIcon;
	exports.BrightnessAutoFontIcon = BrightnessAutoFontIcon;
	exports.BrightnessHighFontIcon = BrightnessHighFontIcon;
	exports.BrightnessLowFontIcon = BrightnessLowFontIcon;
	exports.BrightnessMediumFontIcon = BrightnessMediumFontIcon;
	exports.BrokenImageFontIcon = BrokenImageFontIcon;
	exports.BrushFontIcon = BrushFontIcon;
	exports.BubbleChartFontIcon = BubbleChartFontIcon;
	exports.BugReportFontIcon = BugReportFontIcon;
	exports.BuildFontIcon = BuildFontIcon;
	exports.BurstModeFontIcon = BurstModeFontIcon;
	exports.BusinessCenterFontIcon = BusinessCenterFontIcon;
	exports.BusinessFontIcon = BusinessFontIcon;
	exports.Button = Button;
	exports.CELL_MARGIN_VAR = CELL_MARGIN_VAR;
	exports.CELL_SIZE_VAR = CELL_SIZE_VAR;
	exports.CENTER_CENTER_ANCHOR = CENTER_CENTER_ANCHOR;
	exports.CENTER_INNER_LEFT_ANCHOR = CENTER_INNER_LEFT_ANCHOR;
	exports.CENTER_INNER_RIGHT_ANCHOR = CENTER_INNER_RIGHT_ANCHOR;
	exports.CENTER_LEFT_ANCHOR = CENTER_LEFT_ANCHOR;
	exports.CENTER_RIGHT_ANCHOR = CENTER_RIGHT_ANCHOR;
	exports.COLLAPSE_TIMEOUT = COLLAPSE_TIMEOUT;
	exports.CROSS_FADE_CLASSNAMES = CROSS_FADE_CLASSNAMES;
	exports.CROSS_FADE_TIMEOUT = CROSS_FADE_TIMEOUT;
	exports.CachedFontIcon = CachedFontIcon;
	exports.CakeFontIcon = CakeFontIcon;
	exports.CallEndFontIcon = CallEndFontIcon;
	exports.CallFontIcon = CallFontIcon;
	exports.CallMadeFontIcon = CallMadeFontIcon;
	exports.CallMergeFontIcon = CallMergeFontIcon;
	exports.CallMissedFontIcon = CallMissedFontIcon;
	exports.CallMissedOutgoingFontIcon = CallMissedOutgoingFontIcon;
	exports.CallReceivedFontIcon = CallReceivedFontIcon;
	exports.CallSplitFontIcon = CallSplitFontIcon;
	exports.CallToActionFontIcon = CallToActionFontIcon;
	exports.CameraAltFontIcon = CameraAltFontIcon;
	exports.CameraEnhanceFontIcon = CameraEnhanceFontIcon;
	exports.CameraFontIcon = CameraFontIcon;
	exports.CameraFrontFontIcon = CameraFrontFontIcon;
	exports.CameraRearFontIcon = CameraRearFontIcon;
	exports.CameraRollFontIcon = CameraRollFontIcon;
	exports.CancelFontIcon = CancelFontIcon;
	exports.Caption = Caption;
	exports.Card = Card;
	exports.CardActions = CardActions;
	exports.CardContent = CardContent;
	exports.CardGiftcardFontIcon = CardGiftcardFontIcon;
	exports.CardHeader = CardHeader;
	exports.CardMembershipFontIcon = CardMembershipFontIcon;
	exports.CardSubtitle = CardSubtitle;
	exports.CardTitle = CardTitle;
	exports.CardTravelFontIcon = CardTravelFontIcon;
	exports.CasinoFontIcon = CasinoFontIcon;
	exports.CastConnectedFontIcon = CastConnectedFontIcon;
	exports.CastFontIcon = CastFontIcon;
	exports.CenterFocusStrongFontIcon = CenterFocusStrongFontIcon;
	exports.CenterFocusWeakFontIcon = CenterFocusWeakFontIcon;
	exports.ChangeHistoryFontIcon = ChangeHistoryFontIcon;
	exports.ChatBubbleFontIcon = ChatBubbleFontIcon;
	exports.ChatBubbleOutlineFontIcon = ChatBubbleOutlineFontIcon;
	exports.ChatFontIcon = ChatFontIcon;
	exports.CheckBoxFontIcon = CheckBoxFontIcon;
	exports.CheckBoxOutlineBlankFontIcon = CheckBoxOutlineBlankFontIcon;
	exports.CheckCircleFontIcon = CheckCircleFontIcon;
	exports.CheckFontIcon = CheckFontIcon;
	exports.Checkbox = Checkbox;
	exports.ChevronLeftFontIcon = ChevronLeftFontIcon;
	exports.ChevronRightFontIcon = ChevronRightFontIcon;
	exports.ChildCareFontIcon = ChildCareFontIcon;
	exports.ChildFriendlyFontIcon = ChildFriendlyFontIcon;
	exports.Chip = Chip;
	exports.ChromeReaderModeFontIcon = ChromeReaderModeFontIcon;
	exports.CircularProgress = CircularProgress;
	exports.ClassFontIcon = ClassFontIcon;
	exports.ClearAllFontIcon = ClearAllFontIcon;
	exports.ClearFontIcon = ClearFontIcon;
	exports.CloseFontIcon = CloseFontIcon;
	exports.ClosedCaptionFontIcon = ClosedCaptionFontIcon;
	exports.CloudCircleFontIcon = CloudCircleFontIcon;
	exports.CloudDoneFontIcon = CloudDoneFontIcon;
	exports.CloudDownloadFontIcon = CloudDownloadFontIcon;
	exports.CloudFontIcon = CloudFontIcon;
	exports.CloudOffFontIcon = CloudOffFontIcon;
	exports.CloudQueueFontIcon = CloudQueueFontIcon;
	exports.CloudUploadFontIcon = CloudUploadFontIcon;
	exports.CodeFontIcon = CodeFontIcon;
	exports.Collapse = Collapse;
	exports.CollectionsBookmarkFontIcon = CollectionsBookmarkFontIcon;
	exports.CollectionsFontIcon = CollectionsFontIcon;
	exports.ColorLensFontIcon = ColorLensFontIcon;
	exports.ColorizeFontIcon = ColorizeFontIcon;
	exports.CommentFontIcon = CommentFontIcon;
	exports.CompareArrowsFontIcon = CompareArrowsFontIcon;
	exports.CompareFontIcon = CompareFontIcon;
	exports.ComputerFontIcon = ComputerFontIcon;
	exports.ConditionalPortal = ConditionalPortal;
	exports.Configuration = Configuration;
	exports.ConfirmationNumberFontIcon = ConfirmationNumberFontIcon;
	exports.ContactMailFontIcon = ContactMailFontIcon;
	exports.ContactPhoneFontIcon = ContactPhoneFontIcon;
	exports.ContactsFontIcon = ContactsFontIcon;
	exports.ContentCopyFontIcon = ContentCopyFontIcon;
	exports.ContentCutFontIcon = ContentCutFontIcon;
	exports.ContentPasteFontIcon = ContentPasteFontIcon;
	exports.ControlPointDuplicateFontIcon = ControlPointDuplicateFontIcon;
	exports.ControlPointFontIcon = ControlPointFontIcon;
	exports.CopyrightFontIcon = CopyrightFontIcon;
	exports.CreateFontIcon = CreateFontIcon;
	exports.CreateNewFolderFontIcon = CreateNewFolderFontIcon;
	exports.CreditCardFontIcon = CreditCardFontIcon;
	exports.Crop169FontIcon = Crop169FontIcon;
	exports.Crop32FontIcon = Crop32FontIcon;
	exports.Crop54FontIcon = Crop54FontIcon;
	exports.Crop75FontIcon = Crop75FontIcon;
	exports.CropDinFontIcon = CropDinFontIcon;
	exports.CropFontIcon = CropFontIcon;
	exports.CropFreeFontIcon = CropFreeFontIcon;
	exports.CropLandscapeFontIcon = CropLandscapeFontIcon;
	exports.CropOriginalFontIcon = CropOriginalFontIcon;
	exports.CropPortraitFontIcon = CropPortraitFontIcon;
	exports.CropRotateFontIcon = CropRotateFontIcon;
	exports.CropSquareFontIcon = CropSquareFontIcon;
	exports.CrossFade = CrossFade;
	exports.DATA_RMD_NOSCROLL = DATA_RMD_NOSCROLL;
	exports.DEFAULT_APP_SIZE = DEFAULT_APP_SIZE;
	exports.DEFAULT_COLLAPSE_MIN_HEIGHT = DEFAULT_COLLAPSE_MIN_HEIGHT;
	exports.DEFAULT_COLLAPSE_MIN_PADDING_BOTTOM = DEFAULT_COLLAPSE_MIN_PADDING_BOTTOM;
	exports.DEFAULT_COLLAPSE_MIN_PADDING_TOP = DEFAULT_COLLAPSE_MIN_PADDING_TOP;
	exports.DEFAULT_DESKTOP_LARGE_MIN_WIDTH = DEFAULT_DESKTOP_LARGE_MIN_WIDTH;
	exports.DEFAULT_DESKTOP_LAYOUT = DEFAULT_DESKTOP_LAYOUT;
	exports.DEFAULT_DESKTOP_MIN_WIDTH = DEFAULT_DESKTOP_MIN_WIDTH;
	exports.DEFAULT_GET_DISPLAY_LABEL = getDisplayLabel;
	exports.DEFAULT_GET_ITEM_VALUE = DEFAULT_GET_ITEM_VALUE;
	exports.DEFAULT_GET_OPTION_ID = getOptionId;
	exports.DEFAULT_GET_OPTION_LABEL = getOptionLabel;
	exports.DEFAULT_GET_RESULT_ID = getResultId;
	exports.DEFAULT_GET_RESULT_LABEL = getResultLabel;
	exports.DEFAULT_GET_RESULT_VALUE = getResultValue;
	exports.DEFAULT_IGNORE_WHITESPACE = DEFAULT_IGNORE_WHITESPACE;
	exports.DEFAULT_LANDSCAPE_TABLET_LAYOUT = DEFAULT_LANDSCAPE_TABLET_LAYOUT;
	exports.DEFAULT_LAYOUT_MAIN_CLASSNAMES = DEFAULT_LAYOUT_MAIN_CLASSNAMES;
	exports.DEFAULT_MESSAGE_QUEUE_TIMEOUT = DEFAULT_MESSAGE_QUEUE_TIMEOUT;
	exports.DEFAULT_PHONE_LAYOUT = DEFAULT_PHONE_LAYOUT;
	exports.DEFAULT_PHONE_MAX_WIDTH = DEFAULT_PHONE_MAX_WIDTH;
	exports.DEFAULT_RIPPLE_CLASSNAMES = DEFAULT_RIPPLE_CLASSNAMES;
	exports.DEFAULT_RIPPLE_TIMEOUT = DEFAULT_RIPPLE_TIMEOUT;
	exports.DEFAULT_SEARCH_OPTIONS = DEFAULT_SEARCH_OPTIONS;
	exports.DEFAULT_SEARCH_RESET_TIME = DEFAULT_SEARCH_RESET_TIME;
	exports.DEFAULT_SHEET_CLASSNAMES = DEFAULT_SHEET_CLASSNAMES;
	exports.DEFAULT_SHEET_TIMEOUT = DEFAULT_SHEET_TIMEOUT;
	exports.DEFAULT_TABLET_LAYOUT = DEFAULT_TABLET_LAYOUT;
	exports.DEFAULT_TABLET_MAX_WIDTH = DEFAULT_TABLET_MAX_WIDTH;
	exports.DEFAULT_TABLET_MIN_WIDTH = DEFAULT_TABLET_MIN_WIDTH;
	exports.DEFAULT_TOOLTIP_CLASSNAMES = DEFAULT_TOOLTIP_CLASSNAMES;
	exports.DEFAULT_TOOLTIP_DELAY = DEFAULT_TOOLTIP_DELAY;
	exports.DEFAULT_TOOLTIP_THRESHOLD = DEFAULT_TOOLTIP_THRESHOLD;
	exports.DEFAULT_TOOLTIP_TIMEOUT = DEFAULT_TOOLTIP_TIMEOUT;
	exports.DEFAULT_TRIM = DEFAULT_TRIM;
	exports.DEFAULT_VALUE_KEY = DEFAULT_VALUE_KEY;
	exports.DEFFAULT_LAYOUT_NAV_TOGGLE_CLASSNAMES = DEFFAULT_LAYOUT_NAV_TOGGLE_CLASSNAMES;
	exports.DashboardFontIcon = DashboardFontIcon;
	exports.DataUsageFontIcon = DataUsageFontIcon;
	exports.DateRangeFontIcon = DateRangeFontIcon;
	exports.DehazeFontIcon = DehazeFontIcon;
	exports.DeleteFontIcon = DeleteFontIcon;
	exports.DeleteForeverFontIcon = DeleteForeverFontIcon;
	exports.DeleteSweepFontIcon = DeleteSweepFontIcon;
	exports.DescriptionFontIcon = DescriptionFontIcon;
	exports.DesktopMacFontIcon = DesktopMacFontIcon;
	exports.DesktopOnly = DesktopOnly;
	exports.DesktopWindowsFontIcon = DesktopWindowsFontIcon;
	exports.DetailsFontIcon = DetailsFontIcon;
	exports.DeveloperBoardFontIcon = DeveloperBoardFontIcon;
	exports.DeveloperModeFontIcon = DeveloperModeFontIcon;
	exports.DeviceHubFontIcon = DeviceHubFontIcon;
	exports.DevicesFontIcon = DevicesFontIcon;
	exports.DevicesOtherFontIcon = DevicesOtherFontIcon;
	exports.DialerSipFontIcon = DialerSipFontIcon;
	exports.Dialog = Dialog;
	exports.DialogContent = DialogContent;
	exports.DialogFooter = DialogFooter;
	exports.DialogHeader = DialogHeader;
	exports.DialogTitle = DialogTitle;
	exports.DialpadFontIcon = DialpadFontIcon;
	exports.DirectionsBikeFontIcon = DirectionsBikeFontIcon;
	exports.DirectionsBoatFontIcon = DirectionsBoatFontIcon;
	exports.DirectionsBusFontIcon = DirectionsBusFontIcon;
	exports.DirectionsCarFontIcon = DirectionsCarFontIcon;
	exports.DirectionsFontIcon = DirectionsFontIcon;
	exports.DirectionsRailwayFontIcon = DirectionsRailwayFontIcon;
	exports.DirectionsRunFontIcon = DirectionsRunFontIcon;
	exports.DirectionsSubwayFontIcon = DirectionsSubwayFontIcon;
	exports.DirectionsTransitFontIcon = DirectionsTransitFontIcon;
	exports.DirectionsWalkFontIcon = DirectionsWalkFontIcon;
	exports.DiscFullFontIcon = DiscFullFontIcon;
	exports.Divider = Divider;
	exports.DnsFontIcon = DnsFontIcon;
	exports.DoNotDisturbAltFontIcon = DoNotDisturbAltFontIcon;
	exports.DoNotDisturbFontIcon = DoNotDisturbFontIcon;
	exports.DoNotDisturbOffFontIcon = DoNotDisturbOffFontIcon;
	exports.DoNotDisturbOnFontIcon = DoNotDisturbOnFontIcon;
	exports.DockFontIcon = DockFontIcon;
	exports.DomainFontIcon = DomainFontIcon;
	exports.DoneAllFontIcon = DoneAllFontIcon;
	exports.DoneFontIcon = DoneFontIcon;
	exports.DonutLargeFontIcon = DonutLargeFontIcon;
	exports.DonutSmallFontIcon = DonutSmallFontIcon;
	exports.DraftsFontIcon = DraftsFontIcon;
	exports.DragHandleFontIcon = DragHandleFontIcon;
	exports.DriveEtaFontIcon = DriveEtaFontIcon;
	exports.DropdownMenu = DropdownMenu;
	exports.DropdownMenuItem = DropdownMenuItem;
	exports.DvrFontIcon = DvrFontIcon;
	exports.ENTER = ENTER;
	exports.ENTERED = ENTERED$2;
	exports.ENTERING = ENTERING$1;
	exports.EXIT = EXIT;
	exports.EXITED = EXITED$1;
	exports.EXITING = EXITING$1;
	exports.EditFontIcon = EditFontIcon;
	exports.EditLocationFontIcon = EditLocationFontIcon;
	exports.EjectFontIcon = EjectFontIcon;
	exports.EmailFontIcon = EmailFontIcon;
	exports.EnhancedEncryptionFontIcon = EnhancedEncryptionFontIcon;
	exports.EqualizerFontIcon = EqualizerFontIcon;
	exports.ErrorFontIcon = ErrorFontIcon;
	exports.ErrorOutlineFontIcon = ErrorOutlineFontIcon;
	exports.EuroSymbolFontIcon = EuroSymbolFontIcon;
	exports.EvStationFontIcon = EvStationFontIcon;
	exports.EventAvailableFontIcon = EventAvailableFontIcon;
	exports.EventBusyFontIcon = EventBusyFontIcon;
	exports.EventFontIcon = EventFontIcon;
	exports.EventNoteFontIcon = EventNoteFontIcon;
	exports.EventSeatFontIcon = EventSeatFontIcon;
	exports.ExitToAppFontIcon = ExitToAppFontIcon;
	exports.ExpandLessFontIcon = ExpandLessFontIcon;
	exports.ExpandMoreFontIcon = ExpandMoreFontIcon;
	exports.ExpansionList = ExpansionList;
	exports.ExpansionPanel = ExpansionPanel;
	exports.ExpansionPanelHeader = ExpansionPanelHeader;
	exports.ExplicitFontIcon = ExplicitFontIcon;
	exports.ExploreFontIcon = ExploreFontIcon;
	exports.ExposureFontIcon = ExposureFontIcon;
	exports.ExposureNeg1FontIcon = ExposureNeg1FontIcon;
	exports.ExposureNeg2FontIcon = ExposureNeg2FontIcon;
	exports.ExposurePlus1FontIcon = ExposurePlus1FontIcon;
	exports.ExposurePlus2FontIcon = ExposurePlus2FontIcon;
	exports.ExposureZeroFontIcon = ExposureZeroFontIcon;
	exports.ExtensionFontIcon = ExtensionFontIcon;
	exports.FAB = FAB;
	exports.FaceFontIcon = FaceFontIcon;
	exports.FastForwardFontIcon = FastForwardFontIcon;
	exports.FastRewindFontIcon = FastRewindFontIcon;
	exports.FavoriteBorderFontIcon = FavoriteBorderFontIcon;
	exports.FavoriteFontIcon = FavoriteFontIcon;
	exports.FeaturedPlayListFontIcon = FeaturedPlayListFontIcon;
	exports.FeaturedVideoFontIcon = FeaturedVideoFontIcon;
	exports.FeedbackFontIcon = FeedbackFontIcon;
	exports.FiberDvrFontIcon = FiberDvrFontIcon;
	exports.FiberManualRecordFontIcon = FiberManualRecordFontIcon;
	exports.FiberNewFontIcon = FiberNewFontIcon;
	exports.FiberPinFontIcon = FiberPinFontIcon;
	exports.FiberSmartRecordFontIcon = FiberSmartRecordFontIcon;
	exports.Fieldset = Fieldset;
	exports.FileDownloadFontIcon = FileDownloadFontIcon;
	exports.FileInput = FileInput;
	exports.FileUploadFontIcon = FileUploadFontIcon;
	exports.Filter1FontIcon = Filter1FontIcon;
	exports.Filter2FontIcon = Filter2FontIcon;
	exports.Filter3FontIcon = Filter3FontIcon;
	exports.Filter4FontIcon = Filter4FontIcon;
	exports.Filter5FontIcon = Filter5FontIcon;
	exports.Filter6FontIcon = Filter6FontIcon;
	exports.Filter7FontIcon = Filter7FontIcon;
	exports.Filter8FontIcon = Filter8FontIcon;
	exports.Filter9FontIcon = Filter9FontIcon;
	exports.Filter9PlusFontIcon = Filter9PlusFontIcon;
	exports.FilterBAndWFontIcon = FilterBAndWFontIcon;
	exports.FilterCenterFocusFontIcon = FilterCenterFocusFontIcon;
	exports.FilterDramaFontIcon = FilterDramaFontIcon;
	exports.FilterFontIcon = FilterFontIcon;
	exports.FilterFramesFontIcon = FilterFramesFontIcon;
	exports.FilterHdrFontIcon = FilterHdrFontIcon;
	exports.FilterListFontIcon = FilterListFontIcon;
	exports.FilterNoneFontIcon = FilterNoneFontIcon;
	exports.FilterTiltShiftFontIcon = FilterTiltShiftFontIcon;
	exports.FilterVintageFontIcon = FilterVintageFontIcon;
	exports.FindInPageFontIcon = FindInPageFontIcon;
	exports.FindReplaceFontIcon = FindReplaceFontIcon;
	exports.FingerprintFontIcon = FingerprintFontIcon;
	exports.FirstPageFontIcon = FirstPageFontIcon;
	exports.FitnessCenterFontIcon = FitnessCenterFontIcon;
	exports.FixedDialog = FixedDialog;
	exports.FlagFontIcon = FlagFontIcon;
	exports.FlareFontIcon = FlareFontIcon;
	exports.FlashAutoFontIcon = FlashAutoFontIcon;
	exports.FlashOffFontIcon = FlashOffFontIcon;
	exports.FlashOnFontIcon = FlashOnFontIcon;
	exports.FlightFontIcon = FlightFontIcon;
	exports.FlightLandFontIcon = FlightLandFontIcon;
	exports.FlightTakeoffFontIcon = FlightTakeoffFontIcon;
	exports.FlipFontIcon = FlipFontIcon;
	exports.FlipToBackFontIcon = FlipToBackFontIcon;
	exports.FlipToFrontFontIcon = FlipToFrontFontIcon;
	exports.FocusContainer = FocusContainer;
	exports.FolderFontIcon = FolderFontIcon;
	exports.FolderOpenFontIcon = FolderOpenFontIcon;
	exports.FolderSharedFontIcon = FolderSharedFontIcon;
	exports.FolderSpecialFontIcon = FolderSpecialFontIcon;
	exports.FontDownloadFontIcon = FontDownloadFontIcon;
	exports.FontIcon = FontIcon;
	exports.Form = Form;
	exports.FormMessage = FormMessage;
	exports.FormThemeProvider = FormThemeProvider;
	exports.FormatAlignCenterFontIcon = FormatAlignCenterFontIcon;
	exports.FormatAlignJustifyFontIcon = FormatAlignJustifyFontIcon;
	exports.FormatAlignLeftFontIcon = FormatAlignLeftFontIcon;
	exports.FormatAlignRightFontIcon = FormatAlignRightFontIcon;
	exports.FormatBoldFontIcon = FormatBoldFontIcon;
	exports.FormatClearFontIcon = FormatClearFontIcon;
	exports.FormatColorFillFontIcon = FormatColorFillFontIcon;
	exports.FormatColorResetFontIcon = FormatColorResetFontIcon;
	exports.FormatColorTextFontIcon = FormatColorTextFontIcon;
	exports.FormatIndentDecreaseFontIcon = FormatIndentDecreaseFontIcon;
	exports.FormatIndentIncreaseFontIcon = FormatIndentIncreaseFontIcon;
	exports.FormatItalicFontIcon = FormatItalicFontIcon;
	exports.FormatLineSpacingFontIcon = FormatLineSpacingFontIcon;
	exports.FormatListBulletedFontIcon = FormatListBulletedFontIcon;
	exports.FormatListNumberedFontIcon = FormatListNumberedFontIcon;
	exports.FormatPaintFontIcon = FormatPaintFontIcon;
	exports.FormatQuoteFontIcon = FormatQuoteFontIcon;
	exports.FormatShapesFontIcon = FormatShapesFontIcon;
	exports.FormatSizeFontIcon = FormatSizeFontIcon;
	exports.FormatStrikethroughFontIcon = FormatStrikethroughFontIcon;
	exports.FormatTextdirectionLToRFontIcon = FormatTextdirectionLToRFontIcon;
	exports.FormatTextdirectionRToLFontIcon = FormatTextdirectionRToLFontIcon;
	exports.FormatUnderlinedFontIcon = FormatUnderlinedFontIcon;
	exports.ForumFontIcon = ForumFontIcon;
	exports.Forward10FontIcon = Forward10FontIcon;
	exports.Forward30FontIcon = Forward30FontIcon;
	exports.Forward5FontIcon = Forward5FontIcon;
	exports.ForwardFontIcon = ForwardFontIcon;
	exports.FreeBreakfastFontIcon = FreeBreakfastFontIcon;
	exports.FullscreenExitFontIcon = FullscreenExitFontIcon;
	exports.FullscreenFontIcon = FullscreenFontIcon;
	exports.FunctionsFontIcon = FunctionsFontIcon;
	exports.GRID_COLUMNS_VAR = GRID_COLUMNS_VAR;
	exports.GRID_GUTTER_VAR = GRID_GUTTER_VAR;
	exports.GTranslateFontIcon = GTranslateFontIcon;
	exports.GamepadFontIcon = GamepadFontIcon;
	exports.GamesFontIcon = GamesFontIcon;
	exports.GavelFontIcon = GavelFontIcon;
	exports.GestureFontIcon = GestureFontIcon;
	exports.GetAppFontIcon = GetAppFontIcon;
	exports.GifFontIcon = GifFontIcon;
	exports.GolfCourseFontIcon = GolfCourseFontIcon;
	exports.GpsFixedFontIcon = GpsFixedFontIcon;
	exports.GpsNotFixedFontIcon = GpsNotFixedFontIcon;
	exports.GpsOffFontIcon = GpsOffFontIcon;
	exports.GradeFontIcon = GradeFontIcon;
	exports.GradientFontIcon = GradientFontIcon;
	exports.GrainFontIcon = GrainFontIcon;
	exports.GraphicEqFontIcon = GraphicEqFontIcon;
	exports.Grid = Grid;
	exports.GridCell = GridCell;
	exports.GridList = GridList;
	exports.GridListCell = GridListCell;
	exports.GridOffFontIcon = GridOffFontIcon;
	exports.GridOnFontIcon = GridOnFontIcon;
	exports.GroupAddFontIcon = GroupAddFontIcon;
	exports.GroupFontIcon = GroupFontIcon;
	exports.GroupWorkFontIcon = GroupWorkFontIcon;
	exports.HdFontIcon = HdFontIcon;
	exports.HdrOffFontIcon = HdrOffFontIcon;
	exports.HdrOnFontIcon = HdrOnFontIcon;
	exports.HdrStrongFontIcon = HdrStrongFontIcon;
	exports.HdrWeakFontIcon = HdrWeakFontIcon;
	exports.HeadsetFontIcon = HeadsetFontIcon;
	exports.HeadsetMicFontIcon = HeadsetMicFontIcon;
	exports.HealingFontIcon = HealingFontIcon;
	exports.HearingFontIcon = HearingFontIcon;
	exports.HelpFontIcon = HelpFontIcon;
	exports.HelpOutlineFontIcon = HelpOutlineFontIcon;
	exports.HighQualityFontIcon = HighQualityFontIcon;
	exports.HighlightFontIcon = HighlightFontIcon;
	exports.HighlightOffFontIcon = HighlightOffFontIcon;
	exports.HighlightedResult = HighlightedResult;
	exports.HistoryFontIcon = HistoryFontIcon;
	exports.HomeFontIcon = HomeFontIcon;
	exports.HotTubFontIcon = HotTubFontIcon;
	exports.HotelFontIcon = HotelFontIcon;
	exports.HourglassEmptyFontIcon = HourglassEmptyFontIcon;
	exports.HourglassFullFontIcon = HourglassFullFontIcon;
	exports.HttpFontIcon = HttpFontIcon;
	exports.HttpsFontIcon = HttpsFontIcon;
	exports.IconProvider = IconProvider;
	exports.IconRotator = IconRotator;
	exports.ImageAspectRatioFontIcon = ImageAspectRatioFontIcon;
	exports.ImageFontIcon = ImageFontIcon;
	exports.ImportContactsFontIcon = ImportContactsFontIcon;
	exports.ImportExportFontIcon = ImportExportFontIcon;
	exports.ImportantDevicesFontIcon = ImportantDevicesFontIcon;
	exports.InboxFontIcon = InboxFontIcon;
	exports.IndeterminateCheckBoxFontIcon = IndeterminateCheckBoxFontIcon;
	exports.InfoFontIcon = InfoFontIcon;
	exports.InfoOutlineFontIcon = InfoOutlineFontIcon;
	exports.InputFontIcon = InputFontIcon;
	exports.InputToggle = InputToggle;
	exports.InsertChartFontIcon = InsertChartFontIcon;
	exports.InsertCommentFontIcon = InsertCommentFontIcon;
	exports.InsertDriveFileFontIcon = InsertDriveFileFontIcon;
	exports.InsertEmoticonFontIcon = InsertEmoticonFontIcon;
	exports.InsertInvitationFontIcon = InsertInvitationFontIcon;
	exports.InsertLinkFontIcon = InsertLinkFontIcon;
	exports.InsertPhotoFontIcon = InsertPhotoFontIcon;
	exports.InteractionModeListener = InteractionModeListener;
	exports.InvertColorsFontIcon = InvertColorsFontIcon;
	exports.InvertColorsOffFontIcon = InvertColorsOffFontIcon;
	exports.IsoFontIcon = IsoFontIcon;
	exports.KeyboardArrowDownFontIcon = KeyboardArrowDownFontIcon;
	exports.KeyboardArrowLeftFontIcon = KeyboardArrowLeftFontIcon;
	exports.KeyboardArrowRightFontIcon = KeyboardArrowRightFontIcon;
	exports.KeyboardArrowUpFontIcon = KeyboardArrowUpFontIcon;
	exports.KeyboardBackspaceFontIcon = KeyboardBackspaceFontIcon;
	exports.KeyboardCapslockFontIcon = KeyboardCapslockFontIcon;
	exports.KeyboardFontIcon = KeyboardFontIcon;
	exports.KeyboardHideFontIcon = KeyboardHideFontIcon;
	exports.KeyboardReturnFontIcon = KeyboardReturnFontIcon;
	exports.KeyboardTabFontIcon = KeyboardTabFontIcon;
	exports.KeyboardVoiceFontIcon = KeyboardVoiceFontIcon;
	exports.KitchenFontIcon = KitchenFontIcon;
	exports.Label = Label;
	exports.LabelFontIcon = LabelFontIcon;
	exports.LabelOutlineFontIcon = LabelOutlineFontIcon;
	exports.LandscapeFontIcon = LandscapeFontIcon;
	exports.LanguageFontIcon = LanguageFontIcon;
	exports.LaptopChromebookFontIcon = LaptopChromebookFontIcon;
	exports.LaptopFontIcon = LaptopFontIcon;
	exports.LaptopMacFontIcon = LaptopMacFontIcon;
	exports.LaptopWindowsFontIcon = LaptopWindowsFontIcon;
	exports.LastPageFontIcon = LastPageFontIcon;
	exports.LaunchFontIcon = LaunchFontIcon;
	exports.LayersClearFontIcon = LayersClearFontIcon;
	exports.LayersFontIcon = LayersFontIcon;
	exports.Layout = Layout;
	exports.LayoutAppBar = LayoutAppBar;
	exports.LayoutAppBarTitle = LayoutAppBarTitle;
	exports.LayoutCloseNavigationButton = LayoutCloseNavigationButton;
	exports.LayoutMain = LayoutMain;
	exports.LayoutNavToggle = LayoutNavToggle;
	exports.LayoutNavigation = LayoutNavigation;
	exports.LayoutNavigationHeader = LayoutNavigationHeader;
	exports.LayoutProvider = LayoutProvider;
	exports.LayoutTree = LayoutTree;
	exports.LeakAddFontIcon = LeakAddFontIcon;
	exports.LeakRemoveFontIcon = LeakRemoveFontIcon;
	exports.LensFontIcon = LensFontIcon;
	exports.LibraryAddFontIcon = LibraryAddFontIcon;
	exports.LibraryBooksFontIcon = LibraryBooksFontIcon;
	exports.LibraryMusicFontIcon = LibraryMusicFontIcon;
	exports.LightbulbOutlineFontIcon = LightbulbOutlineFontIcon;
	exports.LineStyleFontIcon = LineStyleFontIcon;
	exports.LineWeightFontIcon = LineWeightFontIcon;
	exports.LinearProgress = LinearProgress;
	exports.LinearScaleFontIcon = LinearScaleFontIcon;
	exports.Link = Link;
	exports.LinkFontIcon = LinkFontIcon;
	exports.LinkedCameraFontIcon = LinkedCameraFontIcon;
	exports.List = List;
	exports.ListFontIcon = ListFontIcon;
	exports.ListItem = ListItem;
	exports.ListItemAddon = ListItemAddon;
	exports.ListItemChildren = ListItemChildren;
	exports.ListItemLink = ListItemLink;
	exports.ListItemText = ListItemText;
	exports.ListSubheader = ListSubheader;
	exports.Listbox = Listbox;
	exports.LiveHelpFontIcon = LiveHelpFontIcon;
	exports.LiveTvFontIcon = LiveTvFontIcon;
	exports.LocalActivityFontIcon = LocalActivityFontIcon;
	exports.LocalAirportFontIcon = LocalAirportFontIcon;
	exports.LocalAtmFontIcon = LocalAtmFontIcon;
	exports.LocalBarFontIcon = LocalBarFontIcon;
	exports.LocalCafeFontIcon = LocalCafeFontIcon;
	exports.LocalCarWashFontIcon = LocalCarWashFontIcon;
	exports.LocalConvenienceStoreFontIcon = LocalConvenienceStoreFontIcon;
	exports.LocalDiningFontIcon = LocalDiningFontIcon;
	exports.LocalDrinkFontIcon = LocalDrinkFontIcon;
	exports.LocalFloristFontIcon = LocalFloristFontIcon;
	exports.LocalGasStationFontIcon = LocalGasStationFontIcon;
	exports.LocalGroceryStoreFontIcon = LocalGroceryStoreFontIcon;
	exports.LocalHospitalFontIcon = LocalHospitalFontIcon;
	exports.LocalHotelFontIcon = LocalHotelFontIcon;
	exports.LocalLaundryServiceFontIcon = LocalLaundryServiceFontIcon;
	exports.LocalLibraryFontIcon = LocalLibraryFontIcon;
	exports.LocalMallFontIcon = LocalMallFontIcon;
	exports.LocalMoviesFontIcon = LocalMoviesFontIcon;
	exports.LocalOfferFontIcon = LocalOfferFontIcon;
	exports.LocalParkingFontIcon = LocalParkingFontIcon;
	exports.LocalPharmacyFontIcon = LocalPharmacyFontIcon;
	exports.LocalPhoneFontIcon = LocalPhoneFontIcon;
	exports.LocalPizzaFontIcon = LocalPizzaFontIcon;
	exports.LocalPlayFontIcon = LocalPlayFontIcon;
	exports.LocalPostOfficeFontIcon = LocalPostOfficeFontIcon;
	exports.LocalPrintshopFontIcon = LocalPrintshopFontIcon;
	exports.LocalSeeFontIcon = LocalSeeFontIcon;
	exports.LocalShippingFontIcon = LocalShippingFontIcon;
	exports.LocalTaxiFontIcon = LocalTaxiFontIcon;
	exports.LocationCityFontIcon = LocationCityFontIcon;
	exports.LocationDisabledFontIcon = LocationDisabledFontIcon;
	exports.LocationOffFontIcon = LocationOffFontIcon;
	exports.LocationOnFontIcon = LocationOnFontIcon;
	exports.LocationSearchingFontIcon = LocationSearchingFontIcon;
	exports.LockFontIcon = LockFontIcon;
	exports.LockOpenFontIcon = LockOpenFontIcon;
	exports.LockOutlineFontIcon = LockOutlineFontIcon;
	exports.Looks3FontIcon = Looks3FontIcon;
	exports.Looks4FontIcon = Looks4FontIcon;
	exports.Looks5FontIcon = Looks5FontIcon;
	exports.Looks6FontIcon = Looks6FontIcon;
	exports.LooksFontIcon = LooksFontIcon;
	exports.LooksOneFontIcon = LooksOneFontIcon;
	exports.LooksTwoFontIcon = LooksTwoFontIcon;
	exports.LoopFontIcon = LoopFontIcon;
	exports.LoupeFontIcon = LoupeFontIcon;
	exports.LowPriorityFontIcon = LowPriorityFontIcon;
	exports.LoyaltyFontIcon = LoyaltyFontIcon;
	exports.MailFontIcon = MailFontIcon;
	exports.MailOutlineFontIcon = MailOutlineFontIcon;
	exports.MapFontIcon = MapFontIcon;
	exports.MarkunreadFontIcon = MarkunreadFontIcon;
	exports.MarkunreadMailboxFontIcon = MarkunreadMailboxFontIcon;
	exports.MediaContainer = MediaContainer;
	exports.MediaOverlay = MediaOverlay;
	exports.MemoryFontIcon = MemoryFontIcon;
	exports.Menu = Menu;
	exports.MenuButton = MenuButton;
	exports.MenuFontIcon = MenuFontIcon;
	exports.MenuItem = MenuItem;
	exports.MenuItemLink = MenuItemLink;
	exports.MenuItemSeparator = MenuItemSeparator;
	exports.MergeTypeFontIcon = MergeTypeFontIcon;
	exports.MessageFontIcon = MessageFontIcon;
	exports.MessageQueue = MessageQueue;
	exports.MessageQueueActionsContext = MessageQueueActionsContext;
	exports.MessageQueueContext = MessageQueueContext;
	exports.MessageVisibilityContext = MessageVisibilityContext;
	exports.MicFontIcon = MicFontIcon;
	exports.MicNoneFontIcon = MicNoneFontIcon;
	exports.MicOffFontIcon = MicOffFontIcon;
	exports.MmsFontIcon = MmsFontIcon;
	exports.MobileOnly = MobileOnly;
	exports.ModeCommentFontIcon = ModeCommentFontIcon;
	exports.ModeEditFontIcon = ModeEditFontIcon;
	exports.MonetizationOnFontIcon = MonetizationOnFontIcon;
	exports.MoneyOffFontIcon = MoneyOffFontIcon;
	exports.MonochromePhotosFontIcon = MonochromePhotosFontIcon;
	exports.MoodBadFontIcon = MoodBadFontIcon;
	exports.MoodFontIcon = MoodFontIcon;
	exports.MoreFontIcon = MoreFontIcon;
	exports.MoreHorizFontIcon = MoreHorizFontIcon;
	exports.MoreVertFontIcon = MoreVertFontIcon;
	exports.MotorcycleFontIcon = MotorcycleFontIcon;
	exports.MouseFontIcon = MouseFontIcon;
	exports.MoveToInboxFontIcon = MoveToInboxFontIcon;
	exports.MovementPresets = presets;
	exports.MovieCreationFontIcon = MovieCreationFontIcon;
	exports.MovieFilterFontIcon = MovieFilterFontIcon;
	exports.MovieFontIcon = MovieFontIcon;
	exports.MultilineChartFontIcon = MultilineChartFontIcon;
	exports.MusicNoteFontIcon = MusicNoteFontIcon;
	exports.MusicVideoFontIcon = MusicVideoFontIcon;
	exports.MyLocationFontIcon = MyLocationFontIcon;
	exports.NativeSelect = NativeSelect;
	exports.NatureFontIcon = NatureFontIcon;
	exports.NaturePeopleFontIcon = NaturePeopleFontIcon;
	exports.NavigateBeforeFontIcon = NavigateBeforeFontIcon;
	exports.NavigateNextFontIcon = NavigateNextFontIcon;
	exports.NavigationFontIcon = NavigationFontIcon;
	exports.NearMeFontIcon = NearMeFontIcon;
	exports.NestedDialogContextProvider = NestedDialogContextProvider;
	exports.NetworkCellFontIcon = NetworkCellFontIcon;
	exports.NetworkCheckFontIcon = NetworkCheckFontIcon;
	exports.NetworkLockedFontIcon = NetworkLockedFontIcon;
	exports.NetworkWifiFontIcon = NetworkWifiFontIcon;
	exports.NewReleasesFontIcon = NewReleasesFontIcon;
	exports.NextWeekFontIcon = NextWeekFontIcon;
	exports.NfcFontIcon = NfcFontIcon;
	exports.NoEncryptionFontIcon = NoEncryptionFontIcon;
	exports.NoSimFontIcon = NoSimFontIcon;
	exports.NotInterestedFontIcon = NotInterestedFontIcon;
	exports.NoteAddFontIcon = NoteAddFontIcon;
	exports.NoteFontIcon = NoteFontIcon;
	exports.NotificationsActiveFontIcon = NotificationsActiveFontIcon;
	exports.NotificationsFontIcon = NotificationsFontIcon;
	exports.NotificationsNoneFontIcon = NotificationsNoneFontIcon;
	exports.NotificationsOffFontIcon = NotificationsOffFontIcon;
	exports.NotificationsPausedFontIcon = NotificationsPausedFontIcon;
	exports.OfflinePinFontIcon = OfflinePinFontIcon;
	exports.OndemandVideoFontIcon = OndemandVideoFontIcon;
	exports.OpacityFontIcon = OpacityFontIcon;
	exports.OpenInBrowserFontIcon = OpenInBrowserFontIcon;
	exports.OpenInNewFontIcon = OpenInNewFontIcon;
	exports.OpenWithFontIcon = OpenWithFontIcon;
	exports.Option = Option;
	exports.Overlay = Overlay;
	exports.PagesFontIcon = PagesFontIcon;
	exports.PageviewFontIcon = PageviewFontIcon;
	exports.PaletteFontIcon = PaletteFontIcon;
	exports.PanToolFontIcon = PanToolFontIcon;
	exports.PanoramaFishEyeFontIcon = PanoramaFishEyeFontIcon;
	exports.PanoramaFontIcon = PanoramaFontIcon;
	exports.PanoramaHorizontalFontIcon = PanoramaHorizontalFontIcon;
	exports.PanoramaVerticalFontIcon = PanoramaVerticalFontIcon;
	exports.PanoramaWideAngleFontIcon = PanoramaWideAngleFontIcon;
	exports.PartyModeFontIcon = PartyModeFontIcon;
	exports.PassiveEvents = passiveEvents;
	exports.Password = Password;
	exports.PauseCircleFilledFontIcon = PauseCircleFilledFontIcon;
	exports.PauseCircleOutlineFontIcon = PauseCircleOutlineFontIcon;
	exports.PauseFontIcon = PauseFontIcon;
	exports.PaymentFontIcon = PaymentFontIcon;
	exports.PeopleFontIcon = PeopleFontIcon;
	exports.PeopleOutlineFontIcon = PeopleOutlineFontIcon;
	exports.PermCameraMicFontIcon = PermCameraMicFontIcon;
	exports.PermContactCalendarFontIcon = PermContactCalendarFontIcon;
	exports.PermDataSettingFontIcon = PermDataSettingFontIcon;
	exports.PermDeviceInformationFontIcon = PermDeviceInformationFontIcon;
	exports.PermIdentityFontIcon = PermIdentityFontIcon;
	exports.PermMediaFontIcon = PermMediaFontIcon;
	exports.PermPhoneMsgFontIcon = PermPhoneMsgFontIcon;
	exports.PermScanWifiFontIcon = PermScanWifiFontIcon;
	exports.PersonAddFontIcon = PersonAddFontIcon;
	exports.PersonFontIcon = PersonFontIcon;
	exports.PersonOutlineFontIcon = PersonOutlineFontIcon;
	exports.PersonPinCircleFontIcon = PersonPinCircleFontIcon;
	exports.PersonPinFontIcon = PersonPinFontIcon;
	exports.PersonalVideoFontIcon = PersonalVideoFontIcon;
	exports.PetsFontIcon = PetsFontIcon;
	exports.PhoneAndroidFontIcon = PhoneAndroidFontIcon;
	exports.PhoneBluetoothSpeakerFontIcon = PhoneBluetoothSpeakerFontIcon;
	exports.PhoneFontIcon = PhoneFontIcon;
	exports.PhoneForwardedFontIcon = PhoneForwardedFontIcon;
	exports.PhoneInTalkFontIcon = PhoneInTalkFontIcon;
	exports.PhoneIphoneFontIcon = PhoneIphoneFontIcon;
	exports.PhoneLockedFontIcon = PhoneLockedFontIcon;
	exports.PhoneMissedFontIcon = PhoneMissedFontIcon;
	exports.PhoneOnly = PhoneOnly;
	exports.PhonePausedFontIcon = PhonePausedFontIcon;
	exports.PhonelinkEraseFontIcon = PhonelinkEraseFontIcon;
	exports.PhonelinkFontIcon = PhonelinkFontIcon;
	exports.PhonelinkLockFontIcon = PhonelinkLockFontIcon;
	exports.PhonelinkOffFontIcon = PhonelinkOffFontIcon;
	exports.PhonelinkRingFontIcon = PhonelinkRingFontIcon;
	exports.PhonelinkSetupFontIcon = PhonelinkSetupFontIcon;
	exports.PhotoAlbumFontIcon = PhotoAlbumFontIcon;
	exports.PhotoCameraFontIcon = PhotoCameraFontIcon;
	exports.PhotoFilterFontIcon = PhotoFilterFontIcon;
	exports.PhotoFontIcon = PhotoFontIcon;
	exports.PhotoLibraryFontIcon = PhotoLibraryFontIcon;
	exports.PhotoSizeSelectActualFontIcon = PhotoSizeSelectActualFontIcon;
	exports.PhotoSizeSelectLargeFontIcon = PhotoSizeSelectLargeFontIcon;
	exports.PhotoSizeSelectSmallFontIcon = PhotoSizeSelectSmallFontIcon;
	exports.PictureAsPdfFontIcon = PictureAsPdfFontIcon;
	exports.PictureInPictureAltFontIcon = PictureInPictureAltFontIcon;
	exports.PictureInPictureFontIcon = PictureInPictureFontIcon;
	exports.PieChartFontIcon = PieChartFontIcon;
	exports.PieChartOutlinedFontIcon = PieChartOutlinedFontIcon;
	exports.PinDropFontIcon = PinDropFontIcon;
	exports.PlaceFontIcon = PlaceFontIcon;
	exports.PlayArrowFontIcon = PlayArrowFontIcon;
	exports.PlayCircleFilledFontIcon = PlayCircleFilledFontIcon;
	exports.PlayCircleOutlineFontIcon = PlayCircleOutlineFontIcon;
	exports.PlayForWorkFontIcon = PlayForWorkFontIcon;
	exports.PlaylistAddCheckFontIcon = PlaylistAddCheckFontIcon;
	exports.PlaylistAddFontIcon = PlaylistAddFontIcon;
	exports.PlaylistPlayFontIcon = PlaylistPlayFontIcon;
	exports.PlusOneFontIcon = PlusOneFontIcon;
	exports.PollFontIcon = PollFontIcon;
	exports.PolymerFontIcon = PolymerFontIcon;
	exports.PoolFontIcon = PoolFontIcon;
	exports.PortableWifiOffFontIcon = PortableWifiOffFontIcon;
	exports.Portal = Portal;
	exports.PortraitFontIcon = PortraitFontIcon;
	exports.PowerFontIcon = PowerFontIcon;
	exports.PowerInputFontIcon = PowerInputFontIcon;
	exports.PowerSettingsNewFontIcon = PowerSettingsNewFontIcon;
	exports.PregnantWomanFontIcon = PregnantWomanFontIcon;
	exports.PresentToAllFontIcon = PresentToAllFontIcon;
	exports.PrintFontIcon = PrintFontIcon;
	exports.PriorityHighFontIcon = PriorityHighFontIcon;
	exports.PublicFontIcon = PublicFontIcon;
	exports.PublishFontIcon = PublishFontIcon;
	exports.QueryBuilderFontIcon = QueryBuilderFontIcon;
	exports.QuestionAnswerFontIcon = QuestionAnswerFontIcon;
	exports.QueueFontIcon = QueueFontIcon;
	exports.QueueMusicFontIcon = QueueMusicFontIcon;
	exports.QueuePlayNextFontIcon = QueuePlayNextFontIcon;
	exports.Radio = Radio;
	exports.RadioButtonCheckedFontIcon = RadioButtonCheckedFontIcon;
	exports.RadioButtonUncheckedFontIcon = RadioButtonUncheckedFontIcon;
	exports.RadioFontIcon = RadioFontIcon;
	exports.RateReviewFontIcon = RateReviewFontIcon;
	exports.ReceiptFontIcon = ReceiptFontIcon;
	exports.RecentActorsFontIcon = RecentActorsFontIcon;
	exports.RecordVoiceOverFontIcon = RecordVoiceOverFontIcon;
	exports.RedeemFontIcon = RedeemFontIcon;
	exports.RedoFontIcon = RedoFontIcon;
	exports.RefreshFontIcon = RefreshFontIcon;
	exports.RemoveCircleFontIcon = RemoveCircleFontIcon;
	exports.RemoveCircleOutlineFontIcon = RemoveCircleOutlineFontIcon;
	exports.RemoveFontIcon = RemoveFontIcon;
	exports.RemoveFromQueueFontIcon = RemoveFromQueueFontIcon;
	exports.RemoveRedEyeFontIcon = RemoveRedEyeFontIcon;
	exports.RemoveShoppingCartFontIcon = RemoveShoppingCartFontIcon;
	exports.ReorderFontIcon = ReorderFontIcon;
	exports.RepeatFontIcon = RepeatFontIcon;
	exports.RepeatOneFontIcon = RepeatOneFontIcon;
	exports.Replay10FontIcon = Replay10FontIcon;
	exports.Replay30FontIcon = Replay30FontIcon;
	exports.Replay5FontIcon = Replay5FontIcon;
	exports.ReplayFontIcon = ReplayFontIcon;
	exports.ReplyAllFontIcon = ReplyAllFontIcon;
	exports.ReplyFontIcon = ReplyFontIcon;
	exports.ReportFontIcon = ReportFontIcon;
	exports.ReportProblemFontIcon = ReportProblemFontIcon;
	exports.ResizeListener = ResizeListener;
	exports.ResizeObserver = ResizeObserver$1;
	exports.RestaurantFontIcon = RestaurantFontIcon;
	exports.RestaurantMenuFontIcon = RestaurantMenuFontIcon;
	exports.RestoreFontIcon = RestoreFontIcon;
	exports.RestorePageFontIcon = RestorePageFontIcon;
	exports.RingVolumeFontIcon = RingVolumeFontIcon;
	exports.RoomFontIcon = RoomFontIcon;
	exports.RoomServiceFontIcon = RoomServiceFontIcon;
	exports.Rotate90DegreesCcwFontIcon = Rotate90DegreesCcwFontIcon;
	exports.RotateLeftFontIcon = RotateLeftFontIcon;
	exports.RotateRightFontIcon = RotateRightFontIcon;
	exports.Rotation3DFontIcon = Rotation3DFontIcon;
	exports.RoundedCornerFontIcon = RoundedCornerFontIcon;
	exports.RouterFontIcon = RouterFontIcon;
	exports.RowingFontIcon = RowingFontIcon;
	exports.RssFeedFontIcon = RssFeedFontIcon;
	exports.RvHookupFontIcon = RvHookupFontIcon;
	exports.SCALE_CLASSNAMES = SCALE_CLASSNAMES;
	exports.SCALE_TIMEOUT = SCALE_TIMEOUT;
	exports.SCALE_Y_CLASSNAMES = SCALE_Y_CLASSNAMES;
	exports.SVGIcon = SVGIcon;
	exports.SatelliteFontIcon = SatelliteFontIcon;
	exports.SaveFontIcon = SaveFontIcon;
	exports.ScaleTransition = ScaleTransition;
	exports.ScannerFontIcon = ScannerFontIcon;
	exports.ScheduleFontIcon = ScheduleFontIcon;
	exports.SchoolFontIcon = SchoolFontIcon;
	exports.ScreenLockLandscapeFontIcon = ScreenLockLandscapeFontIcon;
	exports.ScreenLockPortraitFontIcon = ScreenLockPortraitFontIcon;
	exports.ScreenLockRotationFontIcon = ScreenLockRotationFontIcon;
	exports.ScreenRotationFontIcon = ScreenRotationFontIcon;
	exports.ScreenShareFontIcon = ScreenShareFontIcon;
	exports.ScrollListener = ScrollListener;
	exports.SdCardFontIcon = SdCardFontIcon;
	exports.SdStorageFontIcon = SdStorageFontIcon;
	exports.SearchFontIcon = SearchFontIcon;
	exports.SecurityFontIcon = SecurityFontIcon;
	exports.Select = Select;
	exports.SelectAllFontIcon = SelectAllFontIcon;
	exports.SendFontIcon = SendFontIcon;
	exports.SentimentDissatisfiedFontIcon = SentimentDissatisfiedFontIcon;
	exports.SentimentNeutralFontIcon = SentimentNeutralFontIcon;
	exports.SentimentSatisfiedFontIcon = SentimentSatisfiedFontIcon;
	exports.SentimentVeryDissatisfiedFontIcon = SentimentVeryDissatisfiedFontIcon;
	exports.SentimentVerySatisfiedFontIcon = SentimentVerySatisfiedFontIcon;
	exports.SettingsApplicationsFontIcon = SettingsApplicationsFontIcon;
	exports.SettingsBackupRestoreFontIcon = SettingsBackupRestoreFontIcon;
	exports.SettingsBluetoothFontIcon = SettingsBluetoothFontIcon;
	exports.SettingsBrightnessFontIcon = SettingsBrightnessFontIcon;
	exports.SettingsCellFontIcon = SettingsCellFontIcon;
	exports.SettingsEthernetFontIcon = SettingsEthernetFontIcon;
	exports.SettingsFontIcon = SettingsFontIcon;
	exports.SettingsInputAntennaFontIcon = SettingsInputAntennaFontIcon;
	exports.SettingsInputComponentFontIcon = SettingsInputComponentFontIcon;
	exports.SettingsInputCompositeFontIcon = SettingsInputCompositeFontIcon;
	exports.SettingsInputHdmiFontIcon = SettingsInputHdmiFontIcon;
	exports.SettingsInputSvideoFontIcon = SettingsInputSvideoFontIcon;
	exports.SettingsOverscanFontIcon = SettingsOverscanFontIcon;
	exports.SettingsPhoneFontIcon = SettingsPhoneFontIcon;
	exports.SettingsPowerFontIcon = SettingsPowerFontIcon;
	exports.SettingsRemoteFontIcon = SettingsRemoteFontIcon;
	exports.SettingsSystemDaydreamFontIcon = SettingsSystemDaydreamFontIcon;
	exports.SettingsVoiceFontIcon = SettingsVoiceFontIcon;
	exports.ShareFontIcon = ShareFontIcon;
	exports.Sheet = Sheet;
	exports.ShopFontIcon = ShopFontIcon;
	exports.ShopTwoFontIcon = ShopTwoFontIcon;
	exports.ShoppingBasketFontIcon = ShoppingBasketFontIcon;
	exports.ShoppingCartFontIcon = ShoppingCartFontIcon;
	exports.ShortTextFontIcon = ShortTextFontIcon;
	exports.ShowChartFontIcon = ShowChartFontIcon;
	exports.ShuffleFontIcon = ShuffleFontIcon;
	exports.SignalCellular4BarFontIcon = SignalCellular4BarFontIcon;
	exports.SignalCellularConnectedNoInternet4BarFontIcon = SignalCellularConnectedNoInternet4BarFontIcon;
	exports.SignalCellularNoSimFontIcon = SignalCellularNoSimFontIcon;
	exports.SignalCellularNullFontIcon = SignalCellularNullFontIcon;
	exports.SignalCellularOffFontIcon = SignalCellularOffFontIcon;
	exports.SignalWifi4BarFontIcon = SignalWifi4BarFontIcon;
	exports.SignalWifi4BarLockFontIcon = SignalWifi4BarLockFontIcon;
	exports.SignalWifiOffFontIcon = SignalWifiOffFontIcon;
	exports.SimCardAlertFontIcon = SimCardAlertFontIcon;
	exports.SimCardFontIcon = SimCardFontIcon;
	exports.SimpleListItem = SimpleListItem;
	exports.SkipNextFontIcon = SkipNextFontIcon;
	exports.SkipPreviousFontIcon = SkipPreviousFontIcon;
	exports.SkipToMainContent = SkipToMainContent;
	exports.SlideshowFontIcon = SlideshowFontIcon;
	exports.SlowMotionVideoFontIcon = SlowMotionVideoFontIcon;
	exports.SmartphoneFontIcon = SmartphoneFontIcon;
	exports.SmokeFreeFontIcon = SmokeFreeFontIcon;
	exports.SmokingRoomsFontIcon = SmokingRoomsFontIcon;
	exports.SmsFailedFontIcon = SmsFailedFontIcon;
	exports.SmsFontIcon = SmsFontIcon;
	exports.Snackbar = Snackbar;
	exports.SnoozeFontIcon = SnoozeFontIcon;
	exports.SortByAlphaFontIcon = SortByAlphaFontIcon;
	exports.SortFontIcon = SortFontIcon;
	exports.SpaFontIcon = SpaFontIcon;
	exports.SpaceBarFontIcon = SpaceBarFontIcon;
	exports.SpeakerFontIcon = SpeakerFontIcon;
	exports.SpeakerGroupFontIcon = SpeakerGroupFontIcon;
	exports.SpeakerNotesFontIcon = SpeakerNotesFontIcon;
	exports.SpeakerNotesOffFontIcon = SpeakerNotesOffFontIcon;
	exports.SpeakerPhoneFontIcon = SpeakerPhoneFontIcon;
	exports.SpellcheckFontIcon = SpellcheckFontIcon;
	exports.SrOnly = SrOnly;
	exports.StarBorderFontIcon = StarBorderFontIcon;
	exports.StarFontIcon = StarFontIcon;
	exports.StarHalfFontIcon = StarHalfFontIcon;
	exports.StarsFontIcon = StarsFontIcon;
	exports.StatesConfig = StatesConfig;
	exports.StatesConfigContext = StatesConfigContext;
	exports.StayCurrentLandscapeFontIcon = StayCurrentLandscapeFontIcon;
	exports.StayCurrentPortraitFontIcon = StayCurrentPortraitFontIcon;
	exports.StayPrimaryLandscapeFontIcon = StayPrimaryLandscapeFontIcon;
	exports.StayPrimaryPortraitFontIcon = StayPrimaryPortraitFontIcon;
	exports.StopFontIcon = StopFontIcon;
	exports.StopScreenShareFontIcon = StopScreenShareFontIcon;
	exports.StorageFontIcon = StorageFontIcon;
	exports.StoreFontIcon = StoreFontIcon;
	exports.StoreMallDirectoryFontIcon = StoreMallDirectoryFontIcon;
	exports.StraightenFontIcon = StraightenFontIcon;
	exports.StreetviewFontIcon = StreetviewFontIcon;
	exports.StrikethroughSFontIcon = StrikethroughSFontIcon;
	exports.StyleFontIcon = StyleFontIcon;
	exports.SubdirectoryArrowLeftFontIcon = SubdirectoryArrowLeftFontIcon;
	exports.SubdirectoryArrowRightFontIcon = SubdirectoryArrowRightFontIcon;
	exports.SubjectFontIcon = SubjectFontIcon;
	exports.SubscriptionsFontIcon = SubscriptionsFontIcon;
	exports.SubtitlesFontIcon = SubtitlesFontIcon;
	exports.SubwayFontIcon = SubwayFontIcon;
	exports.SupervisorAccountFontIcon = SupervisorAccountFontIcon;
	exports.SurroundSoundFontIcon = SurroundSoundFontIcon;
	exports.SwapCallsFontIcon = SwapCallsFontIcon;
	exports.SwapHorizFontIcon = SwapHorizFontIcon;
	exports.SwapVertFontIcon = SwapVertFontIcon;
	exports.SwapVerticalCircleFontIcon = SwapVerticalCircleFontIcon;
	exports.Switch = Switch;
	exports.SwitchCameraFontIcon = SwitchCameraFontIcon;
	exports.SwitchVideoFontIcon = SwitchVideoFontIcon;
	exports.SyncDisabledFontIcon = SyncDisabledFontIcon;
	exports.SyncFontIcon = SyncFontIcon;
	exports.SyncProblemFontIcon = SyncProblemFontIcon;
	exports.SystemUpdateAltFontIcon = SystemUpdateAltFontIcon;
	exports.SystemUpdateFontIcon = SystemUpdateFontIcon;
	exports.TOP_CENTER_ANCHOR = TOP_CENTER_ANCHOR;
	exports.TOP_INNER_LEFT_ANCHOR = TOP_INNER_LEFT_ANCHOR;
	exports.TOP_INNER_RIGHT_ANCHOR = TOP_INNER_RIGHT_ANCHOR;
	exports.TOP_LEFT_ANCHOR = TOP_LEFT_ANCHOR;
	exports.TOP_RIGHT_ANCHOR = TOP_RIGHT_ANCHOR;
	exports.Tab = Tab;
	exports.TabFontIcon = TabFontIcon;
	exports.TabPanel = TabPanel;
	exports.TabPanels = TabPanels;
	exports.TabUnselectedFontIcon = TabUnselectedFontIcon;
	exports.Table = Table;
	exports.TableBody = TableBody;
	exports.TableCell = TableCell;
	exports.TableCellContent = TableCellContent;
	exports.TableCheckbox = TableCheckbox;
	exports.TableContainer = TableContainer;
	exports.TableFooter = TableFooter;
	exports.TableHeader = TableHeader;
	exports.TableRow = TableRow;
	exports.TabletAndroidFontIcon = TabletAndroidFontIcon;
	exports.TabletFontIcon = TabletFontIcon;
	exports.TabletMacFontIcon = TabletMacFontIcon;
	exports.TabletOnly = TabletOnly;
	exports.Tabs = Tabs;
	exports.TabsList = TabsList;
	exports.TabsManager = TabsManager;
	exports.TagFacesFontIcon = TagFacesFontIcon;
	exports.TapAndPlayFontIcon = TapAndPlayFontIcon;
	exports.TerrainFontIcon = TerrainFontIcon;
	exports.Text = Text;
	exports.TextArea = TextArea;
	exports.TextContainer = TextContainer;
	exports.TextField = TextField;
	exports.TextFieldAddon = TextFieldAddon;
	exports.TextFieldContainer = TextFieldContainer;
	exports.TextFieldsFontIcon = TextFieldsFontIcon;
	exports.TextFormatFontIcon = TextFormatFontIcon;
	exports.TextIconSpacing = TextIconSpacing;
	exports.TextsmsFontIcon = TextsmsFontIcon;
	exports.TextureFontIcon = TextureFontIcon;
	exports.TheatersFontIcon = TheatersFontIcon;
	exports.ThumbDownFontIcon = ThumbDownFontIcon;
	exports.ThumbUpFontIcon = ThumbUpFontIcon;
	exports.ThumbsUpDownFontIcon = ThumbsUpDownFontIcon;
	exports.TimeToLeaveFontIcon = TimeToLeaveFontIcon;
	exports.TimelapseFontIcon = TimelapseFontIcon;
	exports.TimelineFontIcon = TimelineFontIcon;
	exports.Timer10FontIcon = Timer10FontIcon;
	exports.Timer3FontIcon = Timer3FontIcon;
	exports.TimerFontIcon = TimerFontIcon;
	exports.TimerOffFontIcon = TimerOffFontIcon;
	exports.TitleFontIcon = TitleFontIcon;
	exports.Toast = Toast;
	exports.TocFontIcon = TocFontIcon;
	exports.TodayFontIcon = TodayFontIcon;
	exports.ToggleContainer = ToggleContainer;
	exports.TollFontIcon = TollFontIcon;
	exports.TonalityFontIcon = TonalityFontIcon;
	exports.Tooltip = Tooltip;
	exports.TooltipHoverModeConfig = TooltipHoverModeConfig;
	exports.Tooltipped = Tooltipped;
	exports.TouchAppFontIcon = TouchAppFontIcon;
	exports.ToysFontIcon = ToysFontIcon;
	exports.TrackChangesFontIcon = TrackChangesFontIcon;
	exports.TrafficFontIcon = TrafficFontIcon;
	exports.TrainFontIcon = TrainFontIcon;
	exports.TramFontIcon = TramFontIcon;
	exports.TransferWithinAStationFontIcon = TransferWithinAStationFontIcon;
	exports.TransformFontIcon = TransformFontIcon;
	exports.TranslateFontIcon = TranslateFontIcon;
	exports.Tree = Tree;
	exports.TreeGroup = TreeGroup;
	exports.TreeItem = TreeItem;
	exports.TrendingDownFontIcon = TrendingDownFontIcon;
	exports.TrendingFlatFontIcon = TrendingFlatFontIcon;
	exports.TrendingUpFontIcon = TrendingUpFontIcon;
	exports.TuneFontIcon = TuneFontIcon;
	exports.TurnedInFontIcon = TurnedInFontIcon;
	exports.TurnedInNotFontIcon = TurnedInNotFontIcon;
	exports.TvFontIcon = TvFontIcon;
	exports.UNMOUNT = UNMOUNT;
	exports.UnarchiveFontIcon = UnarchiveFontIcon;
	exports.UndoFontIcon = UndoFontIcon;
	exports.UnfoldLessFontIcon = UnfoldLessFontIcon;
	exports.UnfoldMoreFontIcon = UnfoldMoreFontIcon;
	exports.UnstyledButton = UnstyledButton;
	exports.UpdateFontIcon = UpdateFontIcon;
	exports.UsbFontIcon = UsbFontIcon;
	exports.VerifiedUserFontIcon = VerifiedUserFontIcon;
	exports.VerticalAlignBottomFontIcon = VerticalAlignBottomFontIcon;
	exports.VerticalAlignCenterFontIcon = VerticalAlignCenterFontIcon;
	exports.VerticalAlignTopFontIcon = VerticalAlignTopFontIcon;
	exports.VerticalDivider = VerticalDivider;
	exports.VibrationFontIcon = VibrationFontIcon;
	exports.VideoCallFontIcon = VideoCallFontIcon;
	exports.VideoLabelFontIcon = VideoLabelFontIcon;
	exports.VideoLibraryFontIcon = VideoLibraryFontIcon;
	exports.VideocamFontIcon = VideocamFontIcon;
	exports.VideocamOffFontIcon = VideocamOffFontIcon;
	exports.VideogameAssetFontIcon = VideogameAssetFontIcon;
	exports.ViewAgendaFontIcon = ViewAgendaFontIcon;
	exports.ViewArrayFontIcon = ViewArrayFontIcon;
	exports.ViewCarouselFontIcon = ViewCarouselFontIcon;
	exports.ViewColumnFontIcon = ViewColumnFontIcon;
	exports.ViewComfyFontIcon = ViewComfyFontIcon;
	exports.ViewCompactFontIcon = ViewCompactFontIcon;
	exports.ViewDayFontIcon = ViewDayFontIcon;
	exports.ViewHeadlineFontIcon = ViewHeadlineFontIcon;
	exports.ViewListFontIcon = ViewListFontIcon;
	exports.ViewModuleFontIcon = ViewModuleFontIcon;
	exports.ViewQuiltFontIcon = ViewQuiltFontIcon;
	exports.ViewStreamFontIcon = ViewStreamFontIcon;
	exports.ViewWeekFontIcon = ViewWeekFontIcon;
	exports.VignetteFontIcon = VignetteFontIcon;
	exports.VisibilityFontIcon = VisibilityFontIcon;
	exports.VisibilityOffFontIcon = VisibilityOffFontIcon;
	exports.VoiceChatFontIcon = VoiceChatFontIcon;
	exports.VoicemailFontIcon = VoicemailFontIcon;
	exports.VolumeDownFontIcon = VolumeDownFontIcon;
	exports.VolumeMuteFontIcon = VolumeMuteFontIcon;
	exports.VolumeOffFontIcon = VolumeOffFontIcon;
	exports.VolumeUpFontIcon = VolumeUpFontIcon;
	exports.VpnKeyFontIcon = VpnKeyFontIcon;
	exports.VpnLockFontIcon = VpnLockFontIcon;
	exports.WallpaperFontIcon = WallpaperFontIcon;
	exports.WarningFontIcon = WarningFontIcon;
	exports.WatchFontIcon = WatchFontIcon;
	exports.WatchLaterFontIcon = WatchLaterFontIcon;
	exports.WbAutoFontIcon = WbAutoFontIcon;
	exports.WbCloudyFontIcon = WbCloudyFontIcon;
	exports.WbIncandescentFontIcon = WbIncandescentFontIcon;
	exports.WbIridescentFontIcon = WbIridescentFontIcon;
	exports.WbSunnyFontIcon = WbSunnyFontIcon;
	exports.WcFontIcon = WcFontIcon;
	exports.WebAssetFontIcon = WebAssetFontIcon;
	exports.WebFontIcon = WebFontIcon;
	exports.WeekendFontIcon = WeekendFontIcon;
	exports.WhatshotFontIcon = WhatshotFontIcon;
	exports.WidgetsFontIcon = WidgetsFontIcon;
	exports.WifiFontIcon = WifiFontIcon;
	exports.WifiLockFontIcon = WifiLockFontIcon;
	exports.WifiTetheringFontIcon = WifiTetheringFontIcon;
	exports.WorkFontIcon = WorkFontIcon;
	exports.WrapTextFontIcon = WrapTextFontIcon;
	exports.YoutubeSearchedForFontIcon = YoutubeSearchedForFontIcon;
	exports.ZoomInFontIcon = ZoomInFontIcon;
	exports.ZoomOutFontIcon = ZoomOutFontIcon;
	exports.ZoomOutMapFontIcon = ZoomOutMapFontIcon;
	exports.addTouchEvent = addTouchEvent;
	exports.applyRef = applyRef;
	exports.bem = bem;
	exports.buttonThemeClassNames = buttonThemeClassNames;
	exports.caseInsensitiveFilter = caseInsensitiveFilter;
	exports.containsElement = containsElement;
	exports.defaultMenuItemRenderer = defaultMenuItemRenderer;
	exports.defaultMenuRenderer = defaultMenuRenderer;
	exports.defaultNavigationItemRenderer = defaultNavigationItemRenderer;
	exports.defaultTreeItemRenderer = defaultTreeItemRenderer;
	exports.defaults = defaults;
	exports.delegateEvent = delegateEvent;
	exports.extractTextContent = extractTextContent;
	exports.findIgnoreCase = findIgnoreCase;
	exports.findMatchIndex = findMatchIndex;
	exports.findSizingContainer = findSizingContainer;
	exports.focusElementWithin = focusElementWithin;
	exports.fuzzyFilter = fuzzyFilter;
	exports.getChildItems = getChildItems;
	exports.getContrastRatio = getContrastRatio;
	exports.getElementRect = getElementRect;
	exports.getFixedPosition = getFixedPosition;
	exports.getFocusableElements = getFocusableElements;
	exports.getFuzzyRegExp = getFuzzyRegExp;
	exports.getItemId = getItemId;
	exports.getItemValue = getItemValue;
	exports.getItemsFrom = getItemsFrom;
	exports.getLayoutType = getLayoutType;
	exports.getListItemHeight = getListItemHeight;
	exports.getProgressA11y = getProgressA11y;
	exports.getSearchString = getSearchString;
	exports.getViewportSize = getViewportSize;
	exports.hexToRGB = hexToRGB;
	exports.isContrastCompliant = isContrastCompliant;
	exports.isFullHeightLayout = isFullHeightLayout;
	exports.isListboxOptionProps = isListboxOptionProps;
	exports.isPersistentLayout = isPersistentLayout;
	exports.isResultOf = isResultOf;
	exports.isTemporaryLayout = isTemporaryLayout;
	exports.isToggleableLayout = isToggleableLayout;
	exports.loop = loop;
	exports.omit = omit;
	exports.removeTouchEvent = removeTouchEvent;
	exports.scrollIntoView = scrollIntoView;
	exports.scrollbarSize = scrollbarSize;
	exports.setTouchEvent = setTouchEvent;
	exports.throttle = throttle$1;
	exports.unitToNumber = unitToNumber;
	exports.useActionClassName = useActionClassName;
	exports.useActiveDescendantMovement = useActiveDescendantMovement;
	exports.useAddMessage = useAddMessage;
	exports.useAppSize = useAppSize;
	exports.useAutoComplete = useAutoComplete;
	exports.useCSSTransition = useCSSTransition;
	exports.useChecked = useChecked;
	exports.useChoice = useChoice;
	exports.useCloseOnEscape = useCloseOnEscape;
	exports.useCloseOnOutsideClick = useCloseOnOutsideClick;
	exports.useCollapse = useCollapse;
	exports.useContextMenu = useContextMenu;
	exports.useCrossFade = useCrossFade;
	exports.useFixedPositioning = useFixedPositioning;
	exports.useFocusMovement = useFocusMovement;
	exports.useFocusOnMount = useFocusOnMount;
	exports.useFormTheme = useFormTheme;
	exports.useIcon = useIcon;
	exports.useIndeterminateChecked = useIndeterminateChecked;
	exports.useInteractionStates = useInteractionStates;
	exports.useInterval = useInterval;
	exports.useIsUserInteractionMode = useIsUserInteractionMode;
	exports.useKeyboardMovement = useKeyboardMovement;
	exports.useKeyboardSearch = useKeyboardSearch;
	exports.useLayoutConfig = useLayoutConfig;
	exports.useLayoutNavigation = useLayoutNavigation;
	exports.useMediaQuery = useMediaQuery;
	exports.useMessageQueueActions = useMessageQueueActions;
	exports.useMessageVisibility = useMessageVisibility;
	exports.useOrientation = useOrientation;
	exports.usePanels = usePanels;
	exports.usePreviousFocus = usePreviousFocus;
	exports.useQueue = useQueue;
	exports.useRefCache = useRefCache;
	exports.useResizeListener = useResizeListener;
	exports.useResizeObserver = useResizeObserver;
	exports.useScrollListener = useScrollListener;
	exports.useScrollLock = useScrollLock;
	exports.useSelectState = useSelectState;
	exports.useStatesConfigContext = useStatesConfigContext;
	exports.useTabs = useTabs;
	exports.useTempValue = useTempValue;
	exports.useTimeout = useTimeout;
	exports.useToggle = useToggle;
	exports.useTooltipHoverModeState = useTooltipHoverModeState;
	exports.useTooltipState = useTooltipState;
	exports.useTransition = useTransition;
	exports.useTreeItemExpansion = useTreeItemExpansion;
	exports.useTreeItemSelection = useTreeItemSelection;
	exports.useUserInteractionMode = useUserInteractionMode;
	exports.useWidthMediaQuery = useWidthMediaQuery;

	Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=react-md-with-font-icons.development.js.map