--- /dev/null
+'use strict';
+
+exports.__esModule = true;
+exports.$$ = exports.$ = undefined;
+
+var _templateObject = _taggedTemplateLiteralLoose(['Setting attributes in the second argument of createEl()\n has been deprecated. Use the third argument instead.\n createEl(type, properties, attributes). Attempting to set ', ' to ', '.'], ['Setting attributes in the second argument of createEl()\n has been deprecated. Use the third argument instead.\n createEl(type, properties, attributes). Attempting to set ', ' to ', '.']);
+
+exports.isReal = isReal;
+exports.isEl = isEl;
+exports.getEl = getEl;
+exports.createEl = createEl;
+exports.textContent = textContent;
+exports.insertElFirst = insertElFirst;
+exports.getElData = getElData;
+exports.hasElData = hasElData;
+exports.removeElData = removeElData;
+exports.hasElClass = hasElClass;
+exports.addElClass = addElClass;
+exports.removeElClass = removeElClass;
+exports.toggleElClass = toggleElClass;
+exports.setElAttributes = setElAttributes;
+exports.getElAttributes = getElAttributes;
+exports.getAttribute = getAttribute;
+exports.setAttribute = setAttribute;
+exports.removeAttribute = removeAttribute;
+exports.blockTextSelection = blockTextSelection;
+exports.unblockTextSelection = unblockTextSelection;
+exports.findElPosition = findElPosition;
+exports.getPointerPosition = getPointerPosition;
+exports.isTextNode = isTextNode;
+exports.emptyEl = emptyEl;
+exports.normalizeContent = normalizeContent;
+exports.appendContent = appendContent;
+exports.insertContent = insertContent;
+
+var _document = require('global/document');
+
+var _document2 = _interopRequireDefault(_document);
+
+var _window = require('global/window');
+
+var _window2 = _interopRequireDefault(_window);
+
+var _guid = require('./guid.js');
+
+var Guid = _interopRequireWildcard(_guid);
+
+var _log = require('./log.js');
+
+var _log2 = _interopRequireDefault(_log);
+
+var _tsml = require('tsml');
+
+var _tsml2 = _interopRequireDefault(_tsml);
+
+var _obj = require('./obj');
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+function _taggedTemplateLiteralLoose(strings, raw) { strings.raw = raw; return strings; } /**
+ * @file dom.js
+ * @module dom
+ */
+
+
+/**
+ * Detect if a value is a string with any non-whitespace characters.
+ *
+ * @param {string} str
+ * The string to check
+ *
+ * @return {boolean}
+ * - True if the string is non-blank
+ * - False otherwise
+ *
+ */
+function isNonBlankString(str) {
+ return typeof str === 'string' && /\S/.test(str);
+}
+
+/**
+ * Throws an error if the passed string has whitespace. This is used by
+ * class methods to be relatively consistent with the classList API.
+ *
+ * @param {string} str
+ * The string to check for whitespace.
+ *
+ * @throws {Error}
+ * Throws an error if there is whitespace in the string.
+ *
+ */
+function throwIfWhitespace(str) {
+ if (/\s/.test(str)) {
+ throw new Error('class has illegal whitespace characters');
+ }
+}
+
+/**
+ * Produce a regular expression for matching a className within an elements className.
+ *
+ * @param {string} className
+ * The className to generate the RegExp for.
+ *
+ * @return {RegExp}
+ * The RegExp that will check for a specific `className` in an elements
+ * className.
+ */
+function classRegExp(className) {
+ return new RegExp('(^|\\s)' + className + '($|\\s)');
+}
+
+/**
+ * Whether the current DOM interface appears to be real.
+ *
+ * @return {Boolean}
+ */
+function isReal() {
+ return (
+
+ // Both document and window will never be undefined thanks to `global`.
+ _document2['default'] === _window2['default'].document &&
+
+ // In IE < 9, DOM methods return "object" as their type, so all we can
+ // confidently check is that it exists.
+ typeof _document2['default'].createElement !== 'undefined'
+ );
+}
+
+/**
+ * Determines, via duck typing, whether or not a value is a DOM element.
+ *
+ * @param {Mixed} value
+ * The thing to check
+ *
+ * @return {boolean}
+ * - True if it is a DOM element
+ * - False otherwise
+ */
+function isEl(value) {
+ return (0, _obj.isObject)(value) && value.nodeType === 1;
+}
+
+/**
+ * Creates functions to query the DOM using a given method.
+ *
+ * @param {string} method
+ * The method to create the query with.
+ *
+ * @return {Function}
+ * The query method
+ */
+function createQuerier(method) {
+ return function (selector, context) {
+ if (!isNonBlankString(selector)) {
+ return _document2['default'][method](null);
+ }
+ if (isNonBlankString(context)) {
+ context = _document2['default'].querySelector(context);
+ }
+
+ var ctx = isEl(context) ? context : _document2['default'];
+
+ return ctx[method] && ctx[method](selector);
+ };
+}
+
+/**
+ * Shorthand for document.getElementById()
+ * Also allows for CSS (jQuery) ID syntax. But nothing other than IDs.
+ *
+ * @param {string} id
+ * The id of the element to get
+ *
+ * @return {Element|null}
+ * Element with supplied ID or null if there wasn't one.
+ */
+function getEl(id) {
+ if (id.indexOf('#') === 0) {
+ id = id.slice(1);
+ }
+
+ return _document2['default'].getElementById(id);
+}
+
+/**
+ * Creates an element and applies properties.
+ *
+ * @param {string} [tagName='div']
+ * Name of tag to be created.
+ *
+ * @param {Object} [properties={}]
+ * Element properties to be applied.
+ *
+ * @param {Object} [attributes={}]
+ * Element attributes to be applied.
+ *
+ * @param {String|Element|TextNode|Array|Function} [content]
+ * Contents for the element (see: {@link dom:normalizeContent})
+ *
+ * @return {Element}
+ * The element that was created.
+ */
+function createEl() {
+ var tagName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'div';
+ var properties = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+ var attributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+ var content = arguments[3];
+
+ var el = _document2['default'].createElement(tagName);
+
+ Object.getOwnPropertyNames(properties).forEach(function (propName) {
+ var val = properties[propName];
+
+ // See #2176
+ // We originally were accepting both properties and attributes in the
+ // same object, but that doesn't work so well.
+ if (propName.indexOf('aria-') !== -1 || propName === 'role' || propName === 'type') {
+ _log2['default'].warn((0, _tsml2['default'])(_templateObject, propName, val));
+ el.setAttribute(propName, val);
+
+ // Handle textContent since it's not supported everywhere and we have a
+ // method for it.
+ } else if (propName === 'textContent') {
+ textContent(el, val);
+ } else {
+ el[propName] = val;
+ }
+ });
+
+ Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
+ el.setAttribute(attrName, attributes[attrName]);
+ });
+
+ if (content) {
+ appendContent(el, content);
+ }
+
+ return el;
+}
+
+/**
+ * Injects text into an element, replacing any existing contents entirely.
+ *
+ * @param {Element} el
+ * The element to add text content into
+ *
+ * @param {string} text
+ * The text content to add.
+ *
+ * @return {Element}
+ * The element with added text content.
+ */
+function textContent(el, text) {
+ if (typeof el.textContent === 'undefined') {
+ el.innerText = text;
+ } else {
+ el.textContent = text;
+ }
+ return el;
+}
+
+/**
+ * Insert an element as the first child node of another
+ *
+ * @param {Element} child
+ * Element to insert
+ *
+ * @param {Element} parent
+ * Element to insert child into
+ *
+ */
+function insertElFirst(child, parent) {
+ if (parent.firstChild) {
+ parent.insertBefore(child, parent.firstChild);
+ } else {
+ parent.appendChild(child);
+ }
+}
+
+/**
+ * Element Data Store. Allows for binding data to an element without putting it directly on the element.
+ * Ex. Event listeners are stored here.
+ * (also from jsninja.com, slightly modified and updated for closure compiler)
+ *
+ * @type {Object}
+ * @private
+ */
+var elData = {};
+
+/*
+ * Unique attribute name to store an element's guid in
+ *
+ * @type {string}
+ * @constant
+ * @private
+ */
+var elIdAttr = 'vdata' + new Date().getTime();
+
+/**
+ * Returns the cache object where data for an element is stored
+ *
+ * @param {Element} el
+ * Element to store data for.
+ *
+ * @return {Object}
+ * The cache object for that el that was passed in.
+ */
+function getElData(el) {
+ var id = el[elIdAttr];
+
+ if (!id) {
+ id = el[elIdAttr] = Guid.newGUID();
+ }
+
+ if (!elData[id]) {
+ elData[id] = {};
+ }
+
+ return elData[id];
+}
+
+/**
+ * Returns whether or not an element has cached data
+ *
+ * @param {Element} el
+ * Check if this element has cached data.
+ *
+ * @return {boolean}
+ * - True if the DOM element has cached data.
+ * - False otherwise.
+ */
+function hasElData(el) {
+ var id = el[elIdAttr];
+
+ if (!id) {
+ return false;
+ }
+
+ return !!Object.getOwnPropertyNames(elData[id]).length;
+}
+
+/**
+ * Delete data for the element from the cache and the guid attr from getElementById
+ *
+ * @param {Element} el
+ * Remove cached data for this element.
+ */
+function removeElData(el) {
+ var id = el[elIdAttr];
+
+ if (!id) {
+ return;
+ }
+
+ // Remove all stored data
+ delete elData[id];
+
+ // Remove the elIdAttr property from the DOM node
+ try {
+ delete el[elIdAttr];
+ } catch (e) {
+ if (el.removeAttribute) {
+ el.removeAttribute(elIdAttr);
+ } else {
+ // IE doesn't appear to support removeAttribute on the document element
+ el[elIdAttr] = null;
+ }
+ }
+}
+
+/**
+ * Check if an element has a CSS class
+ *
+ * @param {Element} element
+ * Element to check
+ *
+ * @param {string} classToCheck
+ * Class name to check for
+ *
+ * @return {boolean}
+ * - True if the element had the class
+ * - False otherwise.
+ *
+ * @throws {Error}
+ * Throws an error if `classToCheck` has white space.
+ */
+function hasElClass(element, classToCheck) {
+ throwIfWhitespace(classToCheck);
+ if (element.classList) {
+ return element.classList.contains(classToCheck);
+ }
+ return classRegExp(classToCheck).test(element.className);
+}
+
+/**
+ * Add a CSS class name to an element
+ *
+ * @param {Element} element
+ * Element to add class name to.
+ *
+ * @param {string} classToAdd
+ * Class name to add.
+ *
+ * @return {Element}
+ * The dom element with the added class name.
+ */
+function addElClass(element, classToAdd) {
+ if (element.classList) {
+ element.classList.add(classToAdd);
+
+ // Don't need to `throwIfWhitespace` here because `hasElClass` will do it
+ // in the case of classList not being supported.
+ } else if (!hasElClass(element, classToAdd)) {
+ element.className = (element.className + ' ' + classToAdd).trim();
+ }
+
+ return element;
+}
+
+/**
+ * Remove a CSS class name from an element
+ *
+ * @param {Element} element
+ * Element to remove a class name from.
+ *
+ * @param {string} classToRemove
+ * Class name to remove
+ *
+ * @return {Element}
+ * The dom element with class name removed.
+ */
+function removeElClass(element, classToRemove) {
+ if (element.classList) {
+ element.classList.remove(classToRemove);
+ } else {
+ throwIfWhitespace(classToRemove);
+ element.className = element.className.split(/\s+/).filter(function (c) {
+ return c !== classToRemove;
+ }).join(' ');
+ }
+
+ return element;
+}
+
+/**
+ * The callback definition for toggleElClass.
+ *
+ * @callback Dom~PredicateCallback
+ * @param {Element} element
+ * The DOM element of the Component.
+ *
+ * @param {string} classToToggle
+ * The `className` that wants to be toggled
+ *
+ * @return {boolean|undefined}
+ * - If true the `classToToggle` will get added to `element`.
+ * - If false the `classToToggle` will get removed from `element`.
+ * - If undefined this callback will be ignored
+ */
+
+/**
+ * Adds or removes a CSS class name on an element depending on an optional
+ * condition or the presence/absence of the class name.
+ *
+ * @param {Element} element
+ * The element to toggle a class name on.
+ *
+ * @param {string} classToToggle
+ * The class that should be toggled
+ *
+ * @param {boolean|PredicateCallback} [predicate]
+ * See the return value for {@link Dom~PredicateCallback}
+ *
+ * @return {Element}
+ * The element with a class that has been toggled.
+ */
+function toggleElClass(element, classToToggle, predicate) {
+
+ // This CANNOT use `classList` internally because IE does not support the
+ // second parameter to the `classList.toggle()` method! Which is fine because
+ // `classList` will be used by the add/remove functions.
+ var has = hasElClass(element, classToToggle);
+
+ if (typeof predicate === 'function') {
+ predicate = predicate(element, classToToggle);
+ }
+
+ if (typeof predicate !== 'boolean') {
+ predicate = !has;
+ }
+
+ // If the necessary class operation matches the current state of the
+ // element, no action is required.
+ if (predicate === has) {
+ return;
+ }
+
+ if (predicate) {
+ addElClass(element, classToToggle);
+ } else {
+ removeElClass(element, classToToggle);
+ }
+
+ return element;
+}
+
+/**
+ * Apply attributes to an HTML element.
+ *
+ * @param {Element} el
+ * Element to add attributes to.
+ *
+ * @param {Object} [attributes]
+ * Attributes to be applied.
+ */
+function setElAttributes(el, attributes) {
+ Object.getOwnPropertyNames(attributes).forEach(function (attrName) {
+ var attrValue = attributes[attrName];
+
+ if (attrValue === null || typeof attrValue === 'undefined' || attrValue === false) {
+ el.removeAttribute(attrName);
+ } else {
+ el.setAttribute(attrName, attrValue === true ? '' : attrValue);
+ }
+ });
+}
+
+/**
+ * Get an element's attribute values, as defined on the HTML tag
+ * Attributes are not the same as properties. They're defined on the tag
+ * or with setAttribute (which shouldn't be used with HTML)
+ * This will return true or false for boolean attributes.
+ *
+ * @param {Element} tag
+ * Element from which to get tag attributes.
+ *
+ * @return {Object}
+ * All attributes of the element.
+ */
+function getElAttributes(tag) {
+ var obj = {};
+
+ // known boolean attributes
+ // we can check for matching boolean properties, but older browsers
+ // won't know about HTML5 boolean attributes that we still read from
+ var knownBooleans = ',' + 'autoplay,controls,loop,muted,default' + ',';
+
+ if (tag && tag.attributes && tag.attributes.length > 0) {
+ var attrs = tag.attributes;
+
+ for (var i = attrs.length - 1; i >= 0; i--) {
+ var attrName = attrs[i].name;
+ var attrVal = attrs[i].value;
+
+ // check for known booleans
+ // the matching element property will return a value for typeof
+ if (typeof tag[attrName] === 'boolean' || knownBooleans.indexOf(',' + attrName + ',') !== -1) {
+ // the value of an included boolean attribute is typically an empty
+ // string ('') which would equal false if we just check for a false value.
+ // we also don't want support bad code like autoplay='false'
+ attrVal = attrVal !== null ? true : false;
+ }
+
+ obj[attrName] = attrVal;
+ }
+ }
+
+ return obj;
+}
+
+/**
+ * Get the value of an element's attribute
+ *
+ * @param {Element} el
+ * A DOM element
+ *
+ * @param {string} attribute
+ * Attribute to get the value of
+ *
+ * @return {string}
+ * value of the attribute
+ */
+function getAttribute(el, attribute) {
+ return el.getAttribute(attribute);
+}
+
+/**
+ * Set the value of an element's attribute
+ *
+ * @param {Element} el
+ * A DOM element
+ *
+ * @param {string} attribute
+ * Attribute to set
+ *
+ * @param {string} value
+ * Value to set the attribute to
+ */
+function setAttribute(el, attribute, value) {
+ el.setAttribute(attribute, value);
+}
+
+/**
+ * Remove an element's attribute
+ *
+ * @param {Element} el
+ * A DOM element
+ *
+ * @param {string} attribute
+ * Attribute to remove
+ */
+function removeAttribute(el, attribute) {
+ el.removeAttribute(attribute);
+}
+
+/**
+ * Attempt to block the ability to select text while dragging controls
+ */
+function blockTextSelection() {
+ _document2['default'].body.focus();
+ _document2['default'].onselectstart = function () {
+ return false;
+ };
+}
+
+/**
+ * Turn off text selection blocking
+ */
+function unblockTextSelection() {
+ _document2['default'].onselectstart = function () {
+ return true;
+ };
+}
+
+/**
+ * The postion of a DOM element on the page.
+ *
+ * @typedef {Object} Dom~Position
+ *
+ * @property {number} left
+ * Pixels to the left
+ *
+ * @property {number} top
+ * Pixels on top
+ */
+
+/**
+ * Offset Left.
+ * getBoundingClientRect technique from
+ * John Resig
+ *
+ * @see http://ejohn.org/blog/getboundingclientrect-is-awesome/
+ *
+ * @param {Element} el
+ * Element from which to get offset
+ *
+ * @return {Dom~Position}
+ * The position of the element that was passed in.
+ */
+function findElPosition(el) {
+ var box = void 0;
+
+ if (el.getBoundingClientRect && el.parentNode) {
+ box = el.getBoundingClientRect();
+ }
+
+ if (!box) {
+ return {
+ left: 0,
+ top: 0
+ };
+ }
+
+ var docEl = _document2['default'].documentElement;
+ var body = _document2['default'].body;
+
+ var clientLeft = docEl.clientLeft || body.clientLeft || 0;
+ var scrollLeft = _window2['default'].pageXOffset || body.scrollLeft;
+ var left = box.left + scrollLeft - clientLeft;
+
+ var clientTop = docEl.clientTop || body.clientTop || 0;
+ var scrollTop = _window2['default'].pageYOffset || body.scrollTop;
+ var top = box.top + scrollTop - clientTop;
+
+ // Android sometimes returns slightly off decimal values, so need to round
+ return {
+ left: Math.round(left),
+ top: Math.round(top)
+ };
+}
+
+/**
+ * x and y coordinates for a dom element or mouse pointer
+ *
+ * @typedef {Object} Dom~Coordinates
+ *
+ * @property {number} x
+ * x coordinate in pixels
+ *
+ * @property {number} y
+ * y coordinate in pixels
+ */
+
+/**
+ * Get pointer position in element
+ * Returns an object with x and y coordinates.
+ * The base on the coordinates are the bottom left of the element.
+ *
+ * @param {Element} el
+ * Element on which to get the pointer position on
+ *
+ * @param {EventTarget~Event} event
+ * Event object
+ *
+ * @return {Dom~Coordinates}
+ * A Coordinates object corresponding to the mouse position.
+ *
+ */
+function getPointerPosition(el, event) {
+ var position = {};
+ var box = findElPosition(el);
+ var boxW = el.offsetWidth;
+ var boxH = el.offsetHeight;
+
+ var boxY = box.top;
+ var boxX = box.left;
+ var pageY = event.pageY;
+ var pageX = event.pageX;
+
+ if (event.changedTouches) {
+ pageX = event.changedTouches[0].pageX;
+ pageY = event.changedTouches[0].pageY;
+ }
+
+ position.y = Math.max(0, Math.min(1, (boxY - pageY + boxH) / boxH));
+ position.x = Math.max(0, Math.min(1, (pageX - boxX) / boxW));
+
+ return position;
+}
+
+/**
+ * Determines, via duck typing, whether or not a value is a text node.
+ *
+ * @param {Mixed} value
+ * Check if this value is a text node.
+ *
+ * @return {boolean}
+ * - True if it is a text node
+ * - False otherwise
+ */
+function isTextNode(value) {
+ return (0, _obj.isObject)(value) && value.nodeType === 3;
+}
+
+/**
+ * Empties the contents of an element.
+ *
+ * @param {Element} el
+ * The element to empty children from
+ *
+ * @return {Element}
+ * The element with no children
+ */
+function emptyEl(el) {
+ while (el.firstChild) {
+ el.removeChild(el.firstChild);
+ }
+ return el;
+}
+
+/**
+ * Normalizes content for eventual insertion into the DOM.
+ *
+ * This allows a wide range of content definition methods, but protects
+ * from falling into the trap of simply writing to `innerHTML`, which is
+ * an XSS concern.
+ *
+ * The content for an element can be passed in multiple types and
+ * combinations, whose behavior is as follows:
+ *
+ * @param {String|Element|TextNode|Array|Function} content
+ * - String: Normalized into a text node.
+ * - Element/TextNode: Passed through.
+ * - Array: A one-dimensional array of strings, elements, nodes, or functions
+ * (which return single strings, elements, or nodes).
+ * - Function: If the sole argument, is expected to produce a string, element,
+ * node, or array as defined above.
+ *
+ * @return {Array}
+ * All of the content that was passed in normalized.
+ */
+function normalizeContent(content) {
+
+ // First, invoke content if it is a function. If it produces an array,
+ // that needs to happen before normalization.
+ if (typeof content === 'function') {
+ content = content();
+ }
+
+ // Next up, normalize to an array, so one or many items can be normalized,
+ // filtered, and returned.
+ return (Array.isArray(content) ? content : [content]).map(function (value) {
+
+ // First, invoke value if it is a function to produce a new value,
+ // which will be subsequently normalized to a Node of some kind.
+ if (typeof value === 'function') {
+ value = value();
+ }
+
+ if (isEl(value) || isTextNode(value)) {
+ return value;
+ }
+
+ if (typeof value === 'string' && /\S/.test(value)) {
+ return _document2['default'].createTextNode(value);
+ }
+ }).filter(function (value) {
+ return value;
+ });
+}
+
+/**
+ * Normalizes and appends content to an element.
+ *
+ * @param {Element} el
+ * Element to append normalized content to.
+ *
+ *
+ * @param {String|Element|TextNode|Array|Function} content
+ * See the `content` argument of {@link dom:normalizeContent}
+ *
+ * @return {Element}
+ * The element with appended normalized content.
+ */
+function appendContent(el, content) {
+ normalizeContent(content).forEach(function (node) {
+ return el.appendChild(node);
+ });
+ return el;
+}
+
+/**
+ * Normalizes and inserts content into an element; this is identical to
+ * `appendContent()`, except it empties the element first.
+ *
+ * @param {Element} el
+ * Element to insert normalized content into.
+ *
+ * @param {String|Element|TextNode|Array|Function} content
+ * See the `content` argument of {@link dom:normalizeContent}
+ *
+ * @return {Element}
+ * The element with inserted normalized content.
+ *
+ */
+function insertContent(el, content) {
+ return appendContent(emptyEl(el), content);
+}
+
+/**
+ * Finds a single DOM element matching `selector` within the optional
+ * `context` of another DOM element (defaulting to `document`).
+ *
+ * @param {string} selector
+ * A valid CSS selector, which will be passed to `querySelector`.
+ *
+ * @param {Element|String} [context=document]
+ * A DOM element within which to query. Can also be a selector
+ * string in which case the first matching element will be used
+ * as context. If missing (or no element matches selector), falls
+ * back to `document`.
+ *
+ * @return {Element|null}
+ * The element that was found or null.
+ */
+var $ = exports.$ = createQuerier('querySelector');
+
+/**
+ * Finds a all DOM elements matching `selector` within the optional
+ * `context` of another DOM element (defaulting to `document`).
+ *
+ * @param {string} selector
+ * A valid CSS selector, which will be passed to `querySelectorAll`.
+ *
+ * @param {Element|String} [context=document]
+ * A DOM element within which to query. Can also be a selector
+ * string in which case the first matching element will be used
+ * as context. If missing (or no element matches selector), falls
+ * back to `document`.
+ *
+ * @return {NodeList}
+ * A element list of elements that were found. Will be empty if none were found.
+ *
+ */
+var $$ = exports.$$ = createQuerier('querySelectorAll');