(function e(t, n, r) {
    function s(o, u) {
        if (!n[o]) {
            if (!t[o]) {
                var a = typeof require == "function" && require;
                if (!u && a) return a(o, !0);
                if (i) return i(o, !0);
                var f = new Error("Cannot find module '" + o + "'");
                throw f.code = "MODULE_NOT_FOUND", f
            }
            var l = n[o] = {
                exports: {}
            };
            t[o][0].call(l.exports, function(e) {
                var n = t[o][1][e];
                return s(n ? n : e)
            }, l, l.exports, e, t, n, r)
        }
        return n[o].exports
    }
    var i = typeof require == "function" && require;
    for (var o = 0; o < r.length; o++) s(r[o]);
    return s
})({
    1: [function(require, module, exports) {
        "use strict";
        module.exports = {
            log: require("./ac-console/log")
        }
    }, {
        "./ac-console/log": 2
    }],
    2: [function(require, module, exports) {
        "use strict";
        var debugMessagingKey = "f7c9180f-5c45-47b4-8de4-428015f096c0";
        var allowDebugMessaging = !! function() {
            try {
                return window.localStorage.getItem(debugMessagingKey)
            } catch (err) {}
        }();
        module.exports = function log() {
            if (window.console && typeof console.log !== "undefined" && allowDebugMessaging) {
                console.log.apply(console, Array.prototype.slice.call(arguments, 0))
            }
        }
    }, {}],
    3: [function(require, module, exports) {
        "use strict";
        var addEventListenerUtil = require("./utils/addEventListener");
        var getEventType = require("./shared/getEventType");
        module.exports = function addEventListener(target, type, listener, useCapture) {
            type = getEventType(target, type);
            return addEventListenerUtil(target, type, listener, useCapture)
        }
    }, {
        "./shared/getEventType": 10,
        "./utils/addEventListener": 11
    }],
    4: [function(require, module, exports) {
        "use strict";
        var eventTypeAvailable = require("./utils/eventTypeAvailable");
        var camelCasedEventTypes = require("./shared/camelCasedEventTypes");
        var windowFallbackEventTypes = require("./shared/windowFallbackEventTypes");
        var prefixHelper = require("./shared/prefixHelper");
        var cache = {};
        module.exports = function getEventType(type, tagName) {
            var prefixedType;
            var tagNameCache;
            var i;
            tagName = tagName || "div";
            type = type.toLowerCase();
            if (!(tagName in cache)) {
                cache[tagName] = {}
            }
            tagNameCache = cache[tagName];
            if (type in tagNameCache) {
                return tagNameCache[type]
            }
            if (eventTypeAvailable(type, tagName)) {
                return tagNameCache[type] = type
            }
            if (type in camelCasedEventTypes) {
                for (i = 0; i < camelCasedEventTypes[type].length; i++) {
                    prefixedType = camelCasedEventTypes[type][i];
                    if (eventTypeAvailable(prefixedType.toLowerCase(), tagName)) {
                        return tagNameCache[type] = prefixedType
                    }
                }
            }
            for (i = 0; i < prefixHelper.evt.length; i++) {
                prefixedType = prefixHelper.evt[i] + type;
                if (eventTypeAvailable(prefixedType, tagName)) {
                    prefixHelper.reduce(i);
                    return tagNameCache[type] = prefixedType
                }
            }
            if (tagName !== "window" && windowFallbackEventTypes.indexOf(type)) {
                return tagNameCache[type] = getEventType(type, "window")
            }
            return tagNameCache[type] = false
        }
    }, {
        "./shared/camelCasedEventTypes": 5,
        "./shared/prefixHelper": 6,
        "./shared/windowFallbackEventTypes": 7,
        "./utils/eventTypeAvailable": 8
    }],
    5: [function(require, module, exports) {
        "use strict";
        module.exports = {
            transitionend: ["webkitTransitionEnd", "MSTransitionEnd"],
            animationstart: ["webkitAnimationStart", "MSAnimationStart"],
            animationend: ["webkitAnimationEnd", "MSAnimationEnd"],
            animationiteration: ["webkitAnimationIteration", "MSAnimationIteration"],
            fullscreenchange: ["MSFullscreenChange"],
            fullscreenerror: ["MSFullscreenError"]
        }
    }, {}],
    6: [function(require, module, exports) {
        "use strict";
        var CSS_PREFIXES = ["-webkit-", "-moz-", "-ms-"];
        var DOM_PREFIXES = ["Webkit", "Moz", "ms"];
        var EVT_PREFIXES = ["webkit", "moz", "ms"];
        var PrefixeHelper = function() {
            this.initialize()
        };
        var proto = PrefixeHelper.prototype;
        proto.initialize = function() {
            this.reduced = false;
            this.css = CSS_PREFIXES;
            this.dom = DOM_PREFIXES;
            this.evt = EVT_PREFIXES
        };
        proto.reduce = function(index) {
            if (!this.reduced) {
                this.reduced = true;
                this.css = [this.css[index]];
                this.dom = [this.dom[index]];
                this.evt = [this.evt[index]]
            }
        };
        module.exports = new PrefixeHelper
    }, {}],
    7: [function(require, module, exports) {
        "use strict";
        module.exports = ["transitionend", "animationstart", "animationend", "animationiteration"]
    }, {}],
    8: [function(require, module, exports) {
        "use strict";
        var testElements = {
            window: window,
            document: document
        };
        module.exports = function eventTypeAvailable(type, tagName) {
            var el;
            type = "on" + type;
            if (!(tagName in testElements)) {
                testElements[tagName] = document.createElement(tagName)
            }
            el = testElements[tagName];
            if (type in el) {
                return true
            }
            if ("setAttribute" in el) {
                el.setAttribute(type, "return;");
                return typeof el[type] === "function"
            }
            return false
        }
    }, {}],
    9: [function(require, module, exports) {
        "use strict";
        var removeEventListenerUtil = require("./utils/removeEventListener");
        var getEventType = require("./shared/getEventType");
        module.exports = function removeEventListener(target, type, listener, useCapture) {
            type = getEventType(target, type);
            return removeEventListenerUtil(target, type, listener, useCapture)
        }
    }, {
        "./shared/getEventType": 10,
        "./utils/removeEventListener": 12
    }],
    10: [function(require, module, exports) {
        "use strict";
        var getPrefixedEventType = require("@marcom/ac-prefixer/getEventType");
        module.exports = function getEventType(target, type) {
            var tagName;
            var prefixed;
            if ("tagName" in target) {
                tagName = target.tagName
            } else if (target === window) {
                tagName = "window"
            } else {
                tagName = "document"
            }
            prefixed = getPrefixedEventType(type, tagName);
            if (prefixed) {
                return prefixed
            }
            return type
        }
    }, {
        "@marcom/ac-prefixer/getEventType": 4
    }],
    11: [function(require, module, exports) {
        "use strict";
        module.exports = function addEventListener(target, type, listener, useCapture) {
            if (target.addEventListener) {
                target.addEventListener(type, listener, !!useCapture)
            } else {
                target.attachEvent("on" + type, listener)
            }
            return target
        }
    }, {}],
    12: [function(require, module, exports) {
        "use strict";
        module.exports = function removeEventListener(target, type, listener, useCapture) {
            if (target.removeEventListener) {
                target.removeEventListener(type, listener, !!useCapture)
            } else {
                target.detachEvent("on" + type, listener)
            }
            return target
        }
    }, {}],
    13: [function(require, module, exports) {
        "use strict";
        module.exports = {
            EventEmitterMicro: require("./ac-event-emitter-micro/EventEmitterMicro")
        }
    }, {
        "./ac-event-emitter-micro/EventEmitterMicro": 14
    }],
    14: [function(require, module, exports) {
        "use strict";

        function EventEmitterMicro() {
            this._events = {}
        }
        var proto = EventEmitterMicro.prototype;
        proto.on = function(eventName, callback) {
            this._events[eventName] = this._events[eventName] || [];
            this._events[eventName].unshift(callback)
        };
        proto.once = function(eventName, callback) {
            var that = this;

            function fn(data) {
                that.off(eventName, fn);
                if (data !== undefined) callback(data);
                else callback()
            }
            this.on(eventName, fn)
        };
        proto.off = function(eventName, callback) {
            if (!this.has(eventName)) return;
            if (arguments.length === 1) {
                this._events[eventName] = null;
                delete this._events[eventName];
                return
            }
            var index = this._events[eventName].indexOf(callback);
            if (index === -1) return;
            this._events[eventName].splice(index, 1)
        };
        proto.trigger = function(eventName, data) {
            if (!this.has(eventName)) return;
            for (var i = this._events[eventName].length - 1; i >= 0; i--) {
                if (data !== undefined) this._events[eventName][i](data);
                else this._events[eventName][i]()
            }
        };
        proto.has = function(eventName) {
            if (eventName in this._events === false || this._events[eventName].length === 0) {
                return false
            }
            return true
        };
        proto.destroy = function() {
            for (var eventName in this._events) {
                this._events[eventName] = null
            }
            this._events = null
        };
        module.exports = EventEmitterMicro
    }, {}],
    15: [function(require, module, exports) {
        "use strict";
        var F = function() {};
        module.exports = function create(proto) {
            if (arguments.length > 1) {
                throw new Error("Second argument not supported")
            }
            if (proto === null || typeof proto !== "object") {
                throw new TypeError("Object prototype may only be an Object.")
            }
            if (typeof Object.create === "function") {
                return Object.create(proto)
            } else {
                F.prototype = proto;
                return new F
            }
        }
    }, {}],
    16: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.forEach");
        var hasOwnProp = Object.prototype.hasOwnProperty;
        module.exports = function extend() {
            var args;
            var dest;
            if (arguments.length < 2) {
                args = [{}, arguments[0]]
            } else {
                args = [].slice.call(arguments)
            }
            dest = args.shift();
            args.forEach(function(source) {
                if (source != null) {
                    for (var property in source) {
                        if (hasOwnProp.call(source, property)) {
                            dest[property] = source[property]
                        }
                    }
                }
            });
            return dest
        }
    }, {
        "@marcom/ac-polyfills/Array/prototype.forEach": 387
    }],
    17: [function(require, module, exports) {
        "use strict";
        var ac_Analytics;
        var extend = require("@marcom/ac-object/extend");
        var create = require("@marcom/ac-object/create");
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var ac_querySelectorAll = require("@marcom/ac-dom-traversal/querySelectorAll");
        var ac_addEventListener = require("@marcom/ac-dom-events/addEventListener");
        var ac_removeEventListener = require("@marcom/ac-dom-events/removeEventListener");
        var ac_console = require("@marcom/ac-console");
        try {
            ac_Analytics = require("@marcom/ac-analytics")
        } catch (e) {
            ac_console.log(e.message)
        }
        var defaultOptions = {
            dataAttribute: "analytics-share",
            interactionEvents: ["click"],
            autoEnable: true
        };
        var AnalyticsShare = function(options) {
            options = options || {};
            this.options = extend(defaultOptions, options);
            EventEmitterMicro.call(this);
            this.elements = [];
            this.eventObserver = null;
            this.publishShareClick = this.publishShareClick.bind(this);
            if (this.options.autoEnable) {
                this.enable()
            }
        };
        var Super = EventEmitterMicro.prototype;
        var proto = AnalyticsShare.prototype = create(Super);
        proto.enable = function() {
            if (!ac_Analytics) {
                return false
            }
            this._createObserver();
            this.bindEventListener()
        };
        proto.disable = function() {
            if (!ac_Analytics) {
                return false
            }
            this.unbindEventListener()
        };
        proto.bindEventListener = function() {
            var length = 0;
            this.elements = this.populateElements();
            length = this.elements.length;
            for (var i = 0; i < length; i++) {
                ac_addEventListener(this.elements[i], "click", this.publishShareClick)
            }
        };
        proto.unbindEventListener = function() {
            var length = this.elements && this.elements.length ? this.elements.length : 0;
            for (var i = 0; i < length; i++) {
                ac_removeEventListener(this.elements[i], "click", this.publishShareClick)
            }
        };
        proto.populateElements = function() {
            return ac_querySelectorAll("[data-" + this.options.dataAttribute + "]", this.options.context || document)
        };
        proto.publishShareClick = function(e) {
            var targetEl = e.currentTarget;
            var data = this.parseDataAttribute(targetEl.getAttribute("data-" + this.options.dataAttribute));
            if (typeof data === "object") {
                if (!data.title) {
                    console.log("data-" + this.options.dataAttribute + " attribute must have a `title` property");
                    return false
                }
                this.trigger("click", data)
            }
        };
        proto.parseDataAttribute = function(dataAttrStr) {
            var data = {};
            try {
                data = JSON.parse(dataAttrStr)
            } catch (e) {
                console.log("data-" + this.options.dataAttribute + " must be a valid JSON string")
            }
            return data
        };
        proto.destroy = function() {
            this.disable();
            this.elements = [];
            this.eventObserver = null;
            this.publishShareClick = null;
            this.options = null
        };
        proto._createObserver = function() {
            if (!ac_Analytics || !ac_Analytics.observer || !ac_Analytics.observer.Event) {
                return false
            }
            this.eventObserver = new ac_Analytics.observer.Event(this, this.options)
        };
        module.exports = AnalyticsShare
    }, {
        "@marcom/ac-analytics": "@marcom/ac-analytics",
        "@marcom/ac-console": 1,
        "@marcom/ac-dom-events/addEventListener": 3,
        "@marcom/ac-dom-events/removeEventListener": 9,
        "@marcom/ac-dom-traversal/querySelectorAll": 39,
        "@marcom/ac-event-emitter-micro": 13,
        "@marcom/ac-object/create": 15,
        "@marcom/ac-object/extend": 16
    }],
    18: [function(require, module, exports) {
        "use strict";
        var AnalyticsShare = require("./../AnalyticsShare");
        module.exports = function(options) {
            return new AnalyticsShare(options)
        }
    }, {
        "./../AnalyticsShare": 17
    }],
    19: [function(require, module, exports) {
        "use strict";
        var BrowserPrefixed = function() {
            var cssPrefix = ["", "-webkit-", "-moz-", "-o-", "-ms-"];
            var transitionEndMap = {
                "animation-delay": "transitionend",
                "-o-animation-delay": "oTransitionEnd",
                "-moz-animation-delay": "transitionend",
                "-webkit-animation-delay": "webkitTransitionEnd",
                "-ms-animation-delay": "transitionend"
            };
            var animationStartMap = {
                "animation-delay": "animationstart",
                "-o-animation-delay": "oanimationstart",
                "-moz-animation-delay": "animationstart",
                "-webkit-animation-delay": "webkitAnimationStart",
                "-ms-animation-delay": "MSAnimationStart"
            };
            var animationIterationMap = {
                "animation-delay": "animationiteration",
                "-o-animation-delay": "oanimationiteration",
                "-moz-animation-delay": "animationiteration",
                "-webkit-animation-delay": "webkitAnimationIteration",
                "-ms-animation-delay": "MSAnimationIteration"
            };
            var animationEndMap = {
                "animation-delay": "animationend",
                "-o-animation-delay": "oanimationend",
                "-moz-animation-delay": "animationend",
                "-webkit-animation-delay": "webkitAnimationEnd",
                "-ms-animation-delay": "MSAnimationEnd"
            };
            var el = document.createElement("_");
            var cssPrefixes = ["", "-webkit-", "-moz-", "-o-", "-ms-"];

            function getStyleProp(propSuffix) {
                for (var i = 0; i < cssPrefixes.length; i++) {
                    var propName = cssPrefix[i] + propSuffix;
                    if (el.style[propName] !== undefined) {
                        return propName
                    }
                }
                return undefined
            }
            var cssFilterPrefix = ["-webkit-", "", "-moz-", "-o-", "-ms-"];

            function getFilterPrefix(propSuffix) {
                for (var i = 0; i < cssFilterPrefix.length; i++) {
                    var propName = cssFilterPrefix[i] + propSuffix;
                    if (el.style[propName] !== undefined) {
                        return propName
                    }
                }
                return undefined
            }
            return {
                filter: getFilterPrefix("filter"),
                transform: getStyleProp("transform"),
                transformOrigin: getStyleProp("transform-origin"),
                transition: getStyleProp("transition"),
                transitionDelay: getStyleProp("transition-delay"),
                transitionDuration: getStyleProp("transition-duration"),
                transitionProperty: getStyleProp("transition-property"),
                transitionTimingFunction: getStyleProp("transition-timing-function"),
                transitionEnd: transitionEndMap[getStyleProp("animation-delay")],
                animation: getStyleProp("animation"),
                animationDelay: getStyleProp("animation-delay"),
                animationDirection: getStyleProp("animation-direction"),
                animationDuration: getStyleProp("animation-duration"),
                animationFillMode: getStyleProp("animation-fill-mode"),
                animationIterationCount: getStyleProp("animation-iteration-count"),
                animationName: getStyleProp("animation-name"),
                animationTimingFunction: getStyleProp("animation-timing-function"),
                animationPlayState: getStyleProp("animation-play-state"),
                animationStart: animationStartMap[getStyleProp("animation-delay")],
                animationIteration: animationIterationMap[getStyleProp("animation-delay")],
                animationEnd: animationEndMap[getStyleProp("animation-delay")]
            }
        }();
        module.exports = BrowserPrefixed
    }, {}],
    20: [function(require, module, exports) {
        "use strict";
        module.exports = function getDimensions(el, rendered) {
            var rect;
            if (rendered) {
                rect = el.getBoundingClientRect();
                return {
                    width: rect.width,
                    height: rect.height
                }
            }
            return {
                width: el.offsetWidth,
                height: el.offsetHeight
            }
        }
    }, {}],
    21: [function(require, module, exports) {
        "use strict";
        var getDimensions = require("./getDimensions");
        var getScrollX = require("./getScrollX");
        var getScrollY = require("./getScrollY");
        module.exports = function getPagePosition(el, rendered) {
            var rect;
            var scrollX;
            var scrollY;
            var dimensions;
            if (rendered) {
                rect = el.getBoundingClientRect();
                scrollX = getScrollX();
                scrollY = getScrollY();
                return {
                    top: rect.top + scrollY,
                    right: rect.right + scrollX,
                    bottom: rect.bottom + scrollY,
                    left: rect.left + scrollX
                }
            }
            dimensions = getDimensions(el, rendered);
            rect = {
                top: el.offsetTop,
                left: el.offsetLeft,
                width: dimensions.width,
                height: dimensions.height
            };
            while (el = el.offsetParent) {
                rect.top += el.offsetTop;
                rect.left += el.offsetLeft
            }
            return {
                top: rect.top,
                right: rect.left + rect.width,
                bottom: rect.top + rect.height,
                left: rect.left
            }
        }
    }, {
        "./getDimensions": 20,
        "./getScrollX": 22,
        "./getScrollY": 23
    }],
    22: [function(require, module, exports) {
        "use strict";
        module.exports = function getScrollX(el) {
            el = el || window;
            if (el === window) {
                return window.scrollX || window.pageXOffset
            }
            return el.scrollLeft
        }
    }, {}],
    23: [function(require, module, exports) {
        "use strict";
        module.exports = function getScrollY(el) {
            el = el || window;
            if (el === window) {
                return window.scrollY || window.pageYOffset
            }
            return el.scrollTop
        }
    }, {}],
    24: [function(require, module, exports) {
        "use strict";
        module.exports = 8
    }, {}],
    25: [function(require, module, exports) {
        "use strict";
        module.exports = 11
    }, {}],
    26: [function(require, module, exports) {
        "use strict";
        module.exports = 9
    }, {}],
    27: [function(require, module, exports) {
        "use strict";
        module.exports = 1
    }, {}],
    28: [function(require, module, exports) {
        "use strict";
        module.exports = 3
    }, {}],
    29: [function(require, module, exports) {
        "use strict";
        var isNode = require("../isNode");
        module.exports = function isNodeType(node, nodeType) {
            if (!isNode(node)) {
                return false
            }
            if (typeof nodeType === "number") {
                return node.nodeType === nodeType
            }
            return nodeType.indexOf(node.nodeType) !== -1
        }
    }, {
        "../isNode": 33
    }],
    30: [function(require, module, exports) {
        "use strict";
        var isNodeType = require("./isNodeType");
        var COMMENT_NODE = require("../COMMENT_NODE");
        var DOCUMENT_FRAGMENT_NODE = require("../DOCUMENT_FRAGMENT_NODE");
        var ELEMENT_NODE = require("../ELEMENT_NODE");
        var TEXT_NODE = require("../TEXT_NODE");
        var VALID_INSERT_NODE = [ELEMENT_NODE, TEXT_NODE, COMMENT_NODE, DOCUMENT_FRAGMENT_NODE];
        var ERR_INVALID_INSERT_NODE = " must be an Element, TextNode, Comment, or Document Fragment";
        var VALID_CHILD_NODE = [ELEMENT_NODE, TEXT_NODE, COMMENT_NODE];
        var ERR_INVALID_CHILD_NODE = " must be an Element, TextNode, or Comment";
        var VALID_PARENT_NODE = [ELEMENT_NODE, DOCUMENT_FRAGMENT_NODE];
        var ERR_INVALID_PARENT_NODE = " must be an Element, or Document Fragment";
        var ERR_NO_PARENT_NODE = " must have a parentNode";
        module.exports = {
            parentNode: function(node, required, funcName, paramName) {
                paramName = paramName || "target";
                if ((node || required) && !isNodeType(node, VALID_PARENT_NODE)) {
                    throw new TypeError(funcName + ": " + paramName + ERR_INVALID_PARENT_NODE)
                }
            },
            childNode: function(node, required, funcName, paramName) {
                paramName = paramName || "target";
                if (!node && !required) {
                    return
                }
                if (!isNodeType(node, VALID_CHILD_NODE)) {
                    throw new TypeError(funcName + ": " + paramName + ERR_INVALID_CHILD_NODE)
                }
            },
            insertNode: function(node, required, funcName, paramName) {
                paramName = paramName || "node";
                if (!node && !required) {
                    return
                }
                if (!isNodeType(node, VALID_INSERT_NODE)) {
                    throw new TypeError(funcName + ": " + paramName + ERR_INVALID_INSERT_NODE)
                }
            },
            hasParentNode: function(node, funcName, paramName) {
                paramName = paramName || "target";
                if (!node.parentNode) {
                    throw new TypeError(funcName + ": " + paramName + ERR_NO_PARENT_NODE)
                }
            }
        }
    }, {
        "../COMMENT_NODE": 24,
        "../DOCUMENT_FRAGMENT_NODE": 25,
        "../ELEMENT_NODE": 27,
        "../TEXT_NODE": 28,
        "./isNodeType": 29
    }],
    31: [function(require, module, exports) {
        "use strict";
        var isNodeType = require("./internal/isNodeType");
        var DOCUMENT_FRAGMENT_NODE = require("./DOCUMENT_FRAGMENT_NODE");
        module.exports = function isDocumentFragment(obj) {
            return isNodeType(obj, DOCUMENT_FRAGMENT_NODE)
        }
    }, {
        "./DOCUMENT_FRAGMENT_NODE": 25,
        "./internal/isNodeType": 29
    }],
    32: [function(require, module, exports) {
        "use strict";
        var isNodeType = require("./internal/isNodeType");
        var ELEMENT_NODE = require("./ELEMENT_NODE");
        module.exports = function isElement(obj) {
            return isNodeType(obj, ELEMENT_NODE)
        }
    }, {
        "./ELEMENT_NODE": 27,
        "./internal/isNodeType": 29
    }],
    33: [function(require, module, exports) {
        "use strict";
        module.exports = function isNode(obj) {
            return !!(obj && obj.nodeType)
        }
    }, {}],
    34: [function(require, module, exports) {
        "use strict";
        var validate = require("./internal/validate");
        module.exports = function remove(node) {
            validate.childNode(node, true, "remove");
            if (!node.parentNode) {
                return node
            }
            return node.parentNode.removeChild(node)
        }
    }, {
        "./internal/validate": 30
    }],
    35: [function(require, module, exports) {
        "use strict";
        module.exports = window.Element ? function(proto) {
            return proto.matches || proto.matchesSelector || proto.webkitMatchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector
        }(Element.prototype) : null
    }, {}],
    36: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.indexOf");
        var isNode = require("@marcom/ac-dom-nodes/isNode");
        var COMMENT_NODE = require("@marcom/ac-dom-nodes/COMMENT_NODE");
        var DOCUMENT_FRAGMENT_NODE = require("@marcom/ac-dom-nodes/DOCUMENT_FRAGMENT_NODE");
        var DOCUMENT_NODE = require("@marcom/ac-dom-nodes/DOCUMENT_NODE");
        var ELEMENT_NODE = require("@marcom/ac-dom-nodes/ELEMENT_NODE");
        var TEXT_NODE = require("@marcom/ac-dom-nodes/TEXT_NODE");
        var isNodeType = function(node, nodeType) {
            if (!isNode(node)) {
                return false
            }
            if (typeof nodeType === "number") {
                return node.nodeType === nodeType
            }
            return nodeType.indexOf(node.nodeType) !== -1
        };
        var VALID_PARENT_NODE = [ELEMENT_NODE, DOCUMENT_NODE, DOCUMENT_FRAGMENT_NODE];
        var ERR_INVALID_PARENT_NODE = " must be an Element, Document, or Document Fragment";
        var VALID_CHILD_NODE = [ELEMENT_NODE, TEXT_NODE, COMMENT_NODE];
        var ERR_INVALID_CHILD_NODE = " must be an Element, TextNode, or Comment";
        var ERR_INVALID_SELECTOR = " must be a string";
        module.exports = {
            parentNode: function(node, required, funcName, paramName) {
                paramName = paramName || "node";
                if ((node || required) && !isNodeType(node, VALID_PARENT_NODE)) {
                    throw new TypeError(funcName + ": " + paramName + ERR_INVALID_PARENT_NODE)
                }
            },
            childNode: function(node, required, funcName, paramName) {
                paramName = paramName || "node";
                if (!node && !required) {
                    return
                }
                if (!isNodeType(node, VALID_CHILD_NODE)) {
                    throw new TypeError(funcName + ": " + paramName + ERR_INVALID_CHILD_NODE)
                }
            },
            selector: function(selector, required, funcName, paramName) {
                paramName = paramName || "selector";
                if ((selector || required) && typeof selector !== "string") {
                    throw new TypeError(funcName + ": " + paramName + ERR_INVALID_SELECTOR)
                }
            }
        }
    }, {
        "@marcom/ac-dom-nodes/COMMENT_NODE": 24,
        "@marcom/ac-dom-nodes/DOCUMENT_FRAGMENT_NODE": 25,
        "@marcom/ac-dom-nodes/DOCUMENT_NODE": 26,
        "@marcom/ac-dom-nodes/ELEMENT_NODE": 27,
        "@marcom/ac-dom-nodes/TEXT_NODE": 28,
        "@marcom/ac-dom-nodes/isNode": 33,
        "@marcom/ac-polyfills/Array/prototype.indexOf": 388
    }],
    37: [function(require, module, exports) {
        "use strict";
        var isElement = require("@marcom/ac-dom-nodes/isElement");
        var validate = require("./internal/validate");
        var nativeMatches = require("./internal/nativeMatches");
        var matchesSelectorShim = require("./shims/matchesSelector");
        module.exports = function matchesSelector(node, selector) {
            validate.selector(selector, true, "matchesSelector");
            if (!isElement(node)) {
                return false
            }
            if (!nativeMatches) {
                return matchesSelectorShim(node, selector)
            }
            return nativeMatches.call(node, selector)
        }
    }, {
        "./internal/nativeMatches": 35,
        "./internal/validate": 36,
        "./shims/matchesSelector": 40,
        "@marcom/ac-dom-nodes/isElement": 32
    }],
    38: [function(require, module, exports) {
        "use strict";
        var validate = require("./internal/validate");
        var querySelectorShim = require("./shims/querySelector");
        var querySelectorAvailable = "querySelector" in document;
        module.exports = function querySelector(selector, context) {
            context = context || document;
            validate.parentNode(context, true, "querySelector", "context");
            validate.selector(selector, true, "querySelector");
            if (!querySelectorAvailable) {
                return querySelectorShim(selector, context)
            }
            return context.querySelector(selector)
        }
    }, {
        "./internal/validate": 36,
        "./shims/querySelector": 41
    }],
    39: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.slice");
        var validate = require("./internal/validate");
        var querySelectorAllShim = require("./shims/querySelectorAll");
        var querySelectorAllAvailable = "querySelectorAll" in document;
        module.exports = function querySelectorAll(selector, context) {
            context = context || document;
            validate.parentNode(context, true, "querySelectorAll", "context");
            validate.selector(selector, true, "querySelectorAll");
            if (!querySelectorAllAvailable) {
                return querySelectorAllShim(selector, context)
            }
            return Array.prototype.slice.call(context.querySelectorAll(selector))
        }
    }, {
        "./internal/validate": 36,
        "./shims/querySelectorAll": 42,
        "@marcom/ac-polyfills/Array/prototype.slice": 390
    }],
    40: [function(require, module, exports) {
        "use strict";
        var querySelectorAll = require("../querySelectorAll");
        module.exports = function matchesSelector(node, selector) {
            var context = node.parentNode || document;
            var nodes = querySelectorAll(selector, context);
            var i;
            for (i = 0; i < nodes.length; i++) {
                if (nodes[i] === node) {
                    return true
                }
            }
            return false
        }
    }, {
        "../querySelectorAll": 39
    }],
    41: [function(require, module, exports) {
        "use strict";
        var querySelectorAll = require("./querySelectorAll");
        module.exports = function querySelector(selector, context) {
            var allResults = querySelectorAll(selector, context);
            return allResults.length ? allResults[0] : null
        }
    }, {
        "./querySelectorAll": 42
    }],
    42: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.indexOf");
        var isElement = require("@marcom/ac-dom-nodes/isElement");
        var isDocumentFragment = require("@marcom/ac-dom-nodes/isDocumentFragment");
        var removeElement = require("@marcom/ac-dom-nodes/remove");
        var COLLECTION_PREFIX = "_ac_qsa_";
        var isElementInContext = function(el, context) {
            var parent;
            if (context === document) {
                return true
            }
            parent = el;
            while ((parent = parent.parentNode) && isElement(parent)) {
                if (parent === context) {
                    return true
                }
            }
            return false
        };
        var recalcStyles = function(context) {
            if ("recalc" in context) {
                context.recalc(false)
            } else {
                document.recalc(false)
            }
            window.scrollBy(0, 0)
        };
        module.exports = function querySelectorAll(selector, context) {
            var style = document.createElement("style");
            var id = COLLECTION_PREFIX + (Math.random() + "").slice(-6);
            var els = [];
            var el;
            context = context || document;
            document[id] = [];
            if (isDocumentFragment(context)) {
                context.appendChild(style)
            } else {
                document.documentElement.firstChild.appendChild(style)
            }
            style.styleSheet.cssText = "*{display:recalc;}" + selector + '{ac-qsa:expression(document["' + id + '"] && document["' + id + '"].push(this));}';
            recalcStyles(context);
            while (document[id].length) {
                el = document[id].shift();
                el.style.removeAttribute("ac-qsa");
                if (els.indexOf(el) === -1 && isElementInContext(el, context)) {
                    els.push(el)
                }
            }
            document[id] = null;
            removeElement(style);
            recalcStyles(context);
            return els
        }
    }, {
        "@marcom/ac-dom-nodes/isDocumentFragment": 31,
        "@marcom/ac-dom-nodes/isElement": 32,
        "@marcom/ac-dom-nodes/remove": 34,
        "@marcom/ac-polyfills/Array/prototype.indexOf": 388
    }],
    43: [function(require, module, exports) {
        var Clock = require("./ac-clock/Clock"),
            ThrottledClock = require("./ac-clock/ThrottledClock"),
            sharedClockInstance = require("./ac-clock/sharedClockInstance");
        sharedClockInstance.Clock = Clock;
        sharedClockInstance.ThrottledClock = ThrottledClock;
        module.exports = sharedClockInstance
    }, {
        "./ac-clock/Clock": 44,
        "./ac-clock/ThrottledClock": 45,
        "./ac-clock/sharedClockInstance": 46
    }],
    44: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Function/prototype.bind");
        require("@marcom/ac-polyfills/requestAnimationFrame");
        var proto;
        var EventEmitter = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var pageLoadTime = (new Date).getTime();

        function Clock() {
            EventEmitter.call(this);
            this.lastFrameTime = null;
            this._animationFrame = null;
            this._active = false;
            this._startTime = null;
            this._boundOnAnimationFrame = this._onAnimationFrame.bind(this);
            this._getTime = Date.now || function() {
                return (new Date).getTime()
            }
        }
        proto = Clock.prototype = new EventEmitter(null);
        proto.start = function() {
            if (this._active) {
                return
            }
            this._tick()
        };
        proto.stop = function() {
            if (this._active) {
                window.cancelAnimationFrame(this._animationFrame)
            }
            this._animationFrame = null;
            this.lastFrameTime = null;
            this._active = false
        };
        proto.destroy = function() {
            this.stop();
            this.off();
            var i;
            for (i in this) {
                if (this.hasOwnProperty(i)) {
                    this[i] = null
                }
            }
        };
        proto.isRunning = function() {
            return this._active
        };
        proto._tick = function() {
            if (!this._active) {
                this._active = true
            }
            this._animationFrame = window.requestAnimationFrame(this._boundOnAnimationFrame)
        };
        proto._onAnimationFrame = function(time) {
            if (this.lastFrameTime === null) {
                this.lastFrameTime = time
            }
            var delta = time - this.lastFrameTime;
            var fps = 0;
            if (delta >= 1e3) {
                delta = 0
            }
            if (delta !== 0) {
                fps = 1e3 / delta
            }
            if (this._firstFrame === true) {
                delta = 0;
                this._firstFrame = false
            }
            if (fps === 0) {
                this._firstFrame = true
            } else {
                var data = {
                    time: time,
                    delta: delta,
                    fps: fps,
                    naturalFps: fps,
                    timeNow: this._getTime()
                };
                this.trigger("update", data);
                this.trigger("draw", data)
            }
            this._animationFrame = null;
            this.lastFrameTime = time;
            if (this._active !== false) {
                this._tick()
            } else {
                this.lastFrameTime = null
            }
        };
        module.exports = Clock
    }, {
        "@marcom/ac-event-emitter-micro": 92,
        "@marcom/ac-polyfills/Function/prototype.bind": 394,
        "@marcom/ac-polyfills/requestAnimationFrame": 401
    }],
    45: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/requestAnimationFrame");
        var proto;
        var sharedClockInstance = require("./sharedClockInstance"),
            EventEmitter = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;

        function ThrottledClock(fps, options) {
            if (fps === null) {
                return
            }
            EventEmitter.call(this);
            options = options || {};
            this._fps = fps || null;
            this._clock = options.clock || sharedClockInstance;
            this._lastThrottledTime = null;
            this._clockEvent = null;
            this._boundOnClockDraw = this._onClockDraw.bind(this);
            this._boundOnClockUpdate = this._onClockUpdate.bind(this);
            this._clock.on("update", this._boundOnClockUpdate)
        }
        proto = ThrottledClock.prototype = new EventEmitter(null);
        proto.setFps = function(fps) {
            this._fps = fps;
            return this
        };
        proto.getFps = function() {
            return this._fps
        };
        proto.start = function() {
            this._clock.start();
            return this
        };
        proto.stop = function() {
            this._clock.stop();
            return this
        };
        proto.isRunning = function() {
            return this._clock.isRunning()
        };
        proto.destroy = function() {
            this._clock.off("update", this._boundOnClockUpdate);
            this._clock.destroy.call(this)
        };
        proto._onClockUpdate = function(e) {
            if (this._lastThrottledTime === null) {
                this._lastThrottledTime = this._clock.lastFrameTime
            }
            var delta = e.time - this._lastThrottledTime;
            if (!this._fps) {
                throw new TypeError("FPS is not defined.")
            }
            if (Math.ceil(1e3 / delta) >= this._fps + 2) {
                return
            }
            this._clockEvent = e;
            this._clockEvent.delta = delta;
            this._clockEvent.fps = 1e3 / delta;
            this._lastThrottledTime = this._clockEvent.time;
            this._clock.once("draw", this._boundOnClockDraw);
            this.trigger("update", this._clockEvent)
        };
        proto._onClockDraw = function() {
            this.trigger("draw", this._clockEvent)
        };
        module.exports = ThrottledClock
    }, {
        "./sharedClockInstance": 46,
        "@marcom/ac-event-emitter-micro": 92,
        "@marcom/ac-polyfills/requestAnimationFrame": 401
    }],
    46: [function(require, module, exports) {
        "use strict";
        var Clock = require("./Clock");
        module.exports = new Clock
    }, {
        "./Clock": 44
    }],
    47: [function(require, module, exports) {
        "use strict";
        module.exports = {
            Clip: require("./ac-clip/Clip")
        }
    }, {
        "./ac-clip/Clip": 48
    }],
    48: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/isArray");
        var create = require("@marcom/ac-object/create");
        var createPredefined = require("@marcom/ac-easing").createPredefined;
        var Clock = require("@marcom/ac-clock");
        var Ease = require("@marcom/ac-easing").Ease;
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var DEFAULT_EASE = "ease";

        function Clip(target, duration, propsTo, options) {
            options = options || {};
            this._options = options;
            this._isYoyo = options.yoyo;
            this._direction = 1;
            this._timeScale = 1;
            this._loop = options.loop || 0;
            this._loopCount = 0;
            this._target = target;
            this.duration(duration);
            this._delay = (options.delay || 0) * 1e3;
            this._remainingDelay = this._delay;
            this._progress = 0;
            this._clock = options.clock || Clock;
            this._playing = false;
            this._getTime = Date.now || function() {
                return (new Date).getTime()
            };
            this._propsTo = propsTo || {};
            this._propsFrom = options.propsFrom || {};
            this._onStart = options.onStart || null;
            this._onUpdate = options.onUpdate || null;
            this._onDraw = options.onDraw || null;
            this._onComplete = options.onComplete || null;
            var ease = options.ease || DEFAULT_EASE;
            this._ease = typeof ease === "function" ? new Ease(ease) : createPredefined(ease);
            this._start = this._start.bind(this);
            this._update = this._update.bind(this);
            this._draw = this._draw.bind(this);
            this._isPrepared = false;
            Clip._add(this);
            EventEmitterMicro.call(this)
        }
        var proto = Clip.prototype = create(EventEmitterMicro.prototype);
        Clip.COMPLETE = "complete";
        Clip.PAUSE = "pause";
        Clip.PLAY = "play";
        proto.play = function() {
            if (!this._playing) {
                this._playing = true;
                if (this._delay === 0 || this._remainingDelay === 0) {
                    this._start()
                } else {
                    if (!this._isPrepared) {
                        this._setDiff();
                        this._updateProps()
                    }
                    this._startTimeout = setTimeout(this._start, this._remainingDelay / this._timeScale);
                    this._delayStart = this._getTime()
                }
            }
            return this
        };
        proto.pause = function() {
            if (this._playing) {
                if (this._startTimeout) {
                    this._remainingDelay = this._getTime() - this._delayStart;
                    clearTimeout(this._startTimeout)
                }
                this._stop();
                this.trigger(Clip.PAUSE, this)
            }
            return this
        };
        proto.destroy = function() {
            this.pause();
            this._options = null;
            this._target = null;
            this._storeTarget = null;
            this._ease = null;
            this._clock = null;
            this._propsTo = null;
            this._propsFrom = null;
            this._storePropsTo = null;
            this._storePropsFrom = null;
            this._propsDiff = null;
            this._propsEase = null;
            this._onStart = null;
            this._onUpdate = null;
            this._onDraw = null;
            this._onComplete = null;
            Clip._remove(this);
            EventEmitterMicro.prototype.destroy.call(this);
            return this
        };
        proto.reset = function() {
            if (!this._isPrepared) {
                return
            }
            this._stop();
            this._resetLoop(this._target, this._storeTarget);
            this._direction = 1;
            this._loop = this._options.loop || 0;
            this._loopCount = 0;
            this._propsFrom = this._storePropsFrom;
            this._propsTo = this._storePropsTo;
            this._progress = 0;
            this._setStartTime();
            if (this._onUpdate) {
                this._onUpdate.call(this, this)
            }
            if (this._onDraw) {
                this._onDraw.call(this, this)
            }
            return this
        };
        proto.playing = function() {
            return this._playing
        };
        proto.target = function() {
            return this._target
        };
        proto.duration = function(duration) {
            if (duration !== undefined) {
                this._duration = duration;
                this._durationMs = duration * 1e3 / this._timeScale;
                if (this._playing) {
                    this._setStartTime()
                }
            }
            return this._duration
        };
        proto.timeScale = function(timeScale) {
            if (timeScale !== undefined) {
                this._timeScale = timeScale;
                this.duration(this._duration)
            }
            return this._timeScale
        };
        proto.currentTime = function(time) {
            if (time !== undefined) {
                return this.progress(time / this._duration) * this._duration
            }
            return this.progress() * this._duration
        };
        proto.progress = function(progress) {
            if (progress !== undefined) {
                this._progress = Math.min(1, Math.max(0, progress));
                this._setStartTime();
                if (!this._isPrepared) {
                    this._setDiff()
                }
                if (this._playing && progress === 1) {
                    this._completeProps();
                    if (this._onUpdate) {
                        this._onUpdate.call(this, this)
                    }
                    if (this._onDraw) {
                        this._onDraw.call(this, this)
                    }
                    this._complete()
                } else {
                    this._updateProps();
                    if (this._onUpdate) {
                        this._onUpdate.call(this, this)
                    }
                    if (this._onDraw) {
                        this._onDraw.call(this, this)
                    }
                }
            }
            return this._progress
        };
        proto._resetLoop = function(target, stored) {
            var prop;
            for (prop in stored) {
                if (stored.hasOwnProperty(prop)) {
                    if (stored[prop] !== null) {
                        if (typeof stored[prop] === "object") {
                            this._resetLoop(target[prop], stored[prop])
                        } else {
                            target[prop] = stored[prop]
                        }
                    }
                }
            }
        };
        proto._cloneObjects = function() {
            var cloneTarget = {};
            var clonePropsTo = {};
            var clonePropsFrom = {};
            this._cloneObjectsLoop(this._target, this._propsTo, this._propsFrom, cloneTarget, clonePropsTo, clonePropsFrom);
            return {
                target: cloneTarget,
                propsTo: clonePropsTo,
                propsFrom: clonePropsFrom
            }
        };
        proto._cloneObjectsLoop = function(target, to, from, cloneTarget, clonePropsTo, clonePropsFrom) {
            var type;
            var prop;
            for (prop in from) {
                if (from.hasOwnProperty(prop) && to[prop] === undefined && target[prop] !== undefined) {
                    cloneTarget[prop] = target[prop];
                    clonePropsTo[prop] = target[prop];
                    clonePropsFrom[prop] = from[prop]
                }
            }
            for (prop in to) {
                if (target.hasOwnProperty(prop)) {
                    type = typeof target[prop];
                    if (target[prop] !== null && type === "object") {
                        if (Array.isArray(target[prop])) {
                            cloneTarget[prop] = [];
                            clonePropsTo[prop] = [];
                            clonePropsFrom[prop] = []
                        } else {
                            cloneTarget[prop] = {};
                            clonePropsTo[prop] = {};
                            clonePropsFrom[prop] = {}
                        }
                        this._cloneObjectsLoop(target[prop], to[prop] || {}, from[prop] || {}, cloneTarget[prop], clonePropsTo[prop], clonePropsFrom[prop])
                    } else if (to[prop] !== null && type === "number") {
                        cloneTarget[prop] = target[prop];
                        clonePropsTo[prop] = to[prop];
                        if (from && from[prop] !== undefined) {
                            clonePropsFrom[prop] = from[prop]
                        }
                    }
                }
            }
        };
        proto._prepareProperties = function() {
            if (!this._isPrepared) {
                var clones = this._cloneObjects();
                this._storeTarget = clones.target;
                this._propsTo = clones.propsTo;
                this._storePropsTo = this._propsTo;
                this._propsFrom = clones.propsFrom;
                this._storePropsFrom = this._propsFrom;
                this._isPrepared = true
            }
        };
        proto._setStartTime = function() {
            this._startTime = this._getTime() - this.progress() * this._durationMs
        };
        proto._setDiff = function() {
            if (!this._isPrepared) {
                this._prepareProperties()
            }
            this._propsDiff = {};
            this._setDiffLoop(this._propsTo, this._propsFrom, this._target, this._propsDiff)
        };
        proto._setDiffLoop = function(to, from, target, diff) {
            var type;
            var prop;
            for (prop in to) {
                if (to.hasOwnProperty(prop)) {
                    type = typeof to[prop];
                    if (to[prop] !== null && type === "object") {
                        from[prop] = from[prop] || {};
                        diff[prop] = diff[prop] || {};
                        this._setDiffLoop(to[prop], from[prop], target[prop], diff[prop])
                    } else if (type === "number" && target[prop] !== undefined) {
                        if (from[prop] !== undefined) {
                            target[prop] = from[prop]
                        } else {
                            from[prop] = target[prop]
                        }
                        diff[prop] = to[prop] - target[prop]
                    } else {
                        to[prop] = null;
                        from[prop] = null
                    }
                }
            }
        };
        proto._start = function() {
            this._startTimeout = null;
            this._remainingDelay = 0;
            this._setStartTime();
            this._clock.on("update", this._update);
            this._clock.on("draw", this._draw);
            if (!this._clock.isRunning()) {
                this._clock.start()
            }
            this._setDiff();
            this._playing = true;
            this._running = true;
            if (this._onStart) {
                this._onStart.call(this, this)
            }
            this.trigger(Clip.PLAY, this)
        };
        proto._stop = function() {
            this._playing = false;
            this._running = false;
            this._clock.off("update", this._update);
            this._clock.off("draw", this._draw)
        };
        proto._updateProps = function() {
            var eased;
            if (this._direction === 1) {
                eased = this._ease.getValue(this._progress)
            } else {
                eased = 1 - this._ease.getValue(1 - this._progress)
            }
            this._updatePropsLoop(this._propsTo, this._propsFrom, this._target, this._propsDiff, eased)
        };
        proto._updatePropsLoop = function(to, from, target, diff, eased) {
            var prop;
            for (prop in to) {
                if (to.hasOwnProperty(prop) && to[prop] !== null) {
                    if (typeof to[prop] !== "number") {
                        this._updatePropsLoop(to[prop], from[prop], target[prop], diff[prop], eased)
                    } else {
                        target[prop] = from[prop] + diff[prop] * eased
                    }
                }
            }
        };
        proto._completeProps = function() {
            this._completePropsLoop(this._propsTo, this._target)
        };
        proto._completePropsLoop = function(to, target) {
            var prop;
            for (prop in to) {
                if (to.hasOwnProperty(prop) && to[prop] !== null) {
                    if (typeof to[prop] !== "number") {
                        this._completePropsLoop(to[prop], target[prop])
                    } else {
                        target[prop] = to[prop]
                    }
                }
            }
        };
        proto._complete = function() {
            if (this._isYoyo && (this._loop > 0 && this._loopCount <= this._loop || this._loop === 0 && this._loopCount === 0)) {
                this._propsFrom = this._direction === 1 ? this._storePropsTo : this._storePropsFrom;
                this._propsTo = this._direction === 1 ? this._storePropsFrom : this._storePropsTo;
                this._direction *= -1;
                if (this._direction === -1) {
                    ++this._loopCount
                }
                this.progress(0);
                this._start()
            } else if (this._loopCount < this._loop) {
                ++this._loopCount;
                this.progress(0);
                this._start()
            } else {
                this.trigger(Clip.COMPLETE, this);
                if (this._onComplete) {
                    this._onComplete.call(this, this)
                }
                if (this._options && this._options.destroyOnComplete) {
                    this.destroy()
                }
            }
        };
        proto._update = function(evt) {
            if (this._running) {
                this._progress = (evt.timeNow - this._startTime) / this._durationMs;
                if (this._progress >= 1) {
                    this._progress = 1;
                    this._running = false;
                    this._completeProps()
                } else {
                    this._updateProps()
                }
                if (this._onUpdate) {
                    this._onUpdate.call(this, this)
                }
            }
        };
        proto._draw = function(evt) {
            if (this._onDraw) {
                this._onDraw.call(this, this)
            }
            if (!this._running) {
                this._stop();
                if (this._progress === 1) {
                    this._complete()
                }
            }
        };
        Clip._instantiate = function() {
            this._clips = [];
            return this
        };
        Clip._add = function(clip) {
            this._clips.push(clip)
        };
        Clip._remove = function(clip) {
            var index = this._clips.indexOf(clip);
            if (index > -1) {
                this._clips.splice(index, 1)
            }
        };
        Clip.getAll = function(target) {
            if (target !== undefined) {
                var clips = [];
                var i = this._clips.length;
                while (i--) {
                    if (this._clips[i].target() === target) {
                        clips.push(this._clips[i])
                    }
                }
                return clips
            }
            return Array.prototype.slice.call(this._clips)
        };
        Clip.destroyAll = function(target) {
            var clips = this.getAll(target);
            if (this._clips.length === clips.length) {
                this._clips = []
            }
            var i = clips.length;
            while (i--) {
                clips[i].destroy()
            }
            return clips
        };
        Clip.to = function(target, duration, propsTo, options) {
            options = options || {};
            if (options.destroyOnComplete === undefined) {
                options.destroyOnComplete = true
            }
            return new Clip(target, duration, propsTo, options).play()
        };
        Clip.from = function(target, duration, propsFrom, options) {
            options = options || {};
            options.propsFrom = propsFrom;
            if (options.destroyOnComplete === undefined) {
                options.destroyOnComplete = true
            }
            return new Clip(target, duration, options.propsTo, options).play()
        };
        module.exports = Clip._instantiate()
    }, {
        "@marcom/ac-clock": 43,
        "@marcom/ac-easing": 84,
        "@marcom/ac-event-emitter-micro": 92,
        "@marcom/ac-object/create": 95,
        "@marcom/ac-polyfills/Array/isArray": 384
    }],
    49: [function(require, module, exports) {
        "use strict";
        var Color = require("./ac-color/Color");
        Color.decimalToHex = require("./ac-color/static/decimalToHex");
        Color.hexToDecimal = require("./ac-color/static/hexToDecimal");
        Color.hexToRgb = require("./ac-color/static/hexToRgb");
        Color.isColor = require("./ac-color/static/isColor");
        Color.isHex = require("./ac-color/static/isHex");
        Color.isRgb = require("./ac-color/static/isRgb");
        Color.isRgba = require("./ac-color/static/isRgba");
        Color.mixColors = require("./ac-color/static/mixColors");
        Color.rgbaToArray = require("./ac-color/static/rgbaToArray");
        Color.rgbToArray = require("./ac-color/static/rgbToArray");
        Color.rgbToDecimal = require("./ac-color/static/rgbToDecimal");
        Color.rgbToHex = require("./ac-color/static/rgbToHex");
        Color.rgbToHsl = require("./ac-color/static/rgbToHsl");
        Color.rgbToHsv = require("./ac-color/static/rgbToHsv");
        Color.rgbaToObject = require("./ac-color/static/rgbaToObject");
        Color.rgbToObject = require("./ac-color/static/rgbToObject");
        Color.shortToLongHex = require("./ac-color/static/shortToLongHex");
        module.exports = {
            Color: Color
        }
    }, {
        "./ac-color/Color": 50,
        "./ac-color/static/decimalToHex": 52,
        "./ac-color/static/hexToDecimal": 53,
        "./ac-color/static/hexToRgb": 54,
        "./ac-color/static/isColor": 55,
        "./ac-color/static/isHex": 56,
        "./ac-color/static/isRgb": 57,
        "./ac-color/static/isRgba": 58,
        "./ac-color/static/mixColors": 59,
        "./ac-color/static/rgbToArray": 60,
        "./ac-color/static/rgbToDecimal": 61,
        "./ac-color/static/rgbToHex": 62,
        "./ac-color/static/rgbToHsl": 63,
        "./ac-color/static/rgbToHsv": 64,
        "./ac-color/static/rgbToObject": 65,
        "./ac-color/static/rgbaToArray": 66,
        "./ac-color/static/rgbaToObject": 67,
        "./ac-color/static/shortToLongHex": 68
    }],
    50: [function(require, module, exports) {
        "use strict";
        var cssColorNames = require("./helpers/cssColorNames");
        var hexToRgb = require("./static/hexToRgb");
        var isColor = require("./static/isColor");
        var isHex = require("./static/isHex");
        var isRgba = require("./static/isRgba");
        var mixColors = require("./static/mixColors");
        var rgbaToArray = require("./static/rgbaToArray");
        var rgbToArray = require("./static/rgbToArray");
        var rgbToDecimal = require("./static/rgbToDecimal");
        var rgbToHex = require("./static/rgbToHex");
        var rgbaToObject = require("./static/rgbaToObject");
        var rgbToObject = require("./static/rgbToObject");
        var shortToLongHex = require("./static/shortToLongHex");

        function Color(color) {
            if (!isColor(color) && !cssColorNames.nameToRgbObject[color]) {
                throw new Error(color + " is not a supported color.")
            }
            this._setColor(color)
        }
        var proto = Color.prototype;
        proto._setColor = function(color) {
            this._color = {};
            if (isHex(color)) {
                this._color.hex = shortToLongHex(color);
                this._color.rgb = {
                    color: hexToRgb(color)
                }
            } else if (isRgba(color)) {
                this._color.rgba = {
                    color: color
                };
                var rgbaObject = this.rgbaObject();
                this._color.rgb = {
                    color: "rgb(" + rgbaObject.r + ", " + rgbaObject.g + ", " + rgbaObject.b + ")"
                }
            } else if (cssColorNames.nameToRgbObject[color]) {
                var rgbObject = cssColorNames.nameToRgbObject[color];
                this._color.rgb = {
                    object: rgbObject,
                    color: "rgb(" + rgbObject.r + ", " + rgbObject.g + ", " + rgbObject.b + ")"
                }
            } else {
                this._color.rgb = {
                    color: color
                }
            }
        };
        proto.rgb = function() {
            return this._color.rgb.color
        };
        proto.rgba = function() {
            if (this._color.rgba === undefined) {
                var rgbObject = this.rgbObject();
                this._color.rgba = {
                    color: "rgba(" + rgbObject.r + ", " + rgbObject.g + ", " + rgbObject.b + ", 1)"
                }
            }
            return this._color.rgba.color
        };
        proto.hex = function() {
            if (this._color.hex === undefined) {
                this._color.hex = rgbToHex.apply(this, this.rgbArray())
            }
            return this._color.hex
        };
        proto.decimal = function() {
            if (this._color.decimal === undefined) {
                this._color.decimal = rgbToDecimal(this.rgb())
            }
            return this._color.decimal
        };
        proto.cssName = function() {
            return cssColorNames.rgbToName[this.rgb()] || null
        };
        proto.rgbArray = function() {
            if (this._color.rgb.array === undefined) {
                this._color.rgb.array = rgbToArray(this.rgb())
            }
            return this._color.rgb.array
        };
        proto.rgbaArray = function() {
            if (this._color.rgba === undefined) {
                this.rgba()
            }
            if (this._color.rgba.array === undefined) {
                this._color.rgba.array = rgbaToArray(this.rgba())
            }
            return this._color.rgba.array
        };
        proto.rgbObject = function() {
            if (this._color.rgb.object === undefined) {
                this._color.rgb.object = rgbToObject(this.rgb())
            }
            return this._color.rgb.object
        };
        proto.rgbaObject = function() {
            if (this._color.rgba === undefined) {
                this.rgba()
            }
            if (this._color.rgba.object === undefined) {
                this._color.rgba.object = rgbaToObject(this.rgba())
            }
            return this._color.rgba.object
        };
        proto.getRed = function() {
            return this.rgbObject().r
        };
        proto.getGreen = function() {
            return this.rgbObject().g
        };
        proto.getBlue = function() {
            return this.rgbObject().b
        };
        proto.getAlpha = function() {
            if (this._color.rgba === undefined) {
                return 1
            }
            return this.rgbaObject().a
        };
        proto.setRed = function(red) {
            if (red !== this.getRed()) {
                this._setColor("rgba(" + red + ", " + this.getGreen() + ", " + this.getBlue() + ", " + this.getAlpha() + ")")
            }
            return this.rgbObject().r
        };
        proto.setGreen = function(green) {
            if (green !== this.getGreen()) {
                this._setColor("rgba(" + this.getRed() + ", " + green + ", " + this.getBlue() + ", " + this.getAlpha() + ")")
            }
            return this.rgbObject().g
        };
        proto.setBlue = function(blue) {
            if (blue !== this.getBlue()) {
                this._setColor("rgba(" + this.getRed() + ", " + this.getGreen() + ", " + blue + ", " + this.getAlpha() + ")")
            }
            return this.rgbObject().b
        };
        proto.setAlpha = function(alpha) {
            if (alpha !== this.getAlpha()) {
                this._setColor("rgba(" + this.getRed() + ", " + this.getGreen() + ", " + this.getBlue() + ", " + alpha + ")")
            }
            return this.rgbaObject().a
        };
        proto.mix = function(color, percent) {
            var rgbObject = rgbToObject(mixColors(this.rgb(), color, percent));
            this._setColor("rgba(" + rgbObject.r + ", " + rgbObject.g + ", " + rgbObject.b + ", " + this.getAlpha() + ")");
            return this.rgb()
        };
        proto.clone = function() {
            return new Color(this.rgb())
        };
        module.exports = Color
    }, {
        "./helpers/cssColorNames": 51,
        "./static/hexToRgb": 54,
        "./static/isColor": 55,
        "./static/isHex": 56,
        "./static/isRgba": 58,
        "./static/mixColors": 59,
        "./static/rgbToArray": 60,
        "./static/rgbToDecimal": 61,
        "./static/rgbToHex": 62,
        "./static/rgbToObject": 65,
        "./static/rgbaToArray": 66,
        "./static/rgbaToObject": 67,
        "./static/shortToLongHex": 68
    }],
    51: [function(require, module, exports) {
        "use strict";
        var rgbToName = {
            "rgb(240, 248, 255)": "aliceblue",
            "rgb(250, 235, 215)": "antiquewhite",
            "rgb(0, 0, 0)": "black",
            "rgb(0, 0, 255)": "blue",
            "rgb(0, 255, 255)": "cyan",
            "rgb(0, 0, 139)": "darkblue",
            "rgb(0, 139, 139)": "darkcyan",
            "rgb(0, 100, 0)": "darkgreen",
            "rgb(0, 206, 209)": "darkturquoise",
            "rgb(0, 191, 255)": "deepskyblue",
            "rgb(0, 128, 0)": "green",
            "rgb(0, 255, 0)": "lime",
            "rgb(0, 0, 205)": "mediumblue",
            "rgb(0, 250, 154)": "mediumspringgreen",
            "rgb(0, 0, 128)": "navy",
            "rgb(0, 255, 127)": "springgreen",
            "rgb(0, 128, 128)": "teal",
            "rgb(25, 25, 112)": "midnightblue",
            "rgb(30, 144, 255)": "dodgerblue",
            "rgb(32, 178, 170)": "lightseagreen",
            "rgb(34, 139, 34)": "forestgreen",
            "rgb(46, 139, 87)": "seagreen",
            "rgb(47, 79, 79)": "darkslategray",
            "rgb(50, 205, 50)": "limegreen",
            "rgb(60, 179, 113)": "mediumseagreen",
            "rgb(64, 224, 208)": "turquoise",
            "rgb(65, 105, 225)": "royalblue",
            "rgb(70, 130, 180)": "steelblue",
            "rgb(72, 61, 139)": "darkslateblue",
            "rgb(72, 209, 204)": "mediumturquoise",
            "rgb(75, 0, 130)": "indigo",
            "rgb(85, 107, 47)": "darkolivegreen",
            "rgb(95, 158, 160)": "cadetblue",
            "rgb(100, 149, 237)": "cornflowerblue",
            "rgb(102, 205, 170)": "mediumaquamarine",
            "rgb(105, 105, 105)": "dimgray",
            "rgb(106, 90, 205)": "slateblue",
            "rgb(107, 142, 35)": "olivedrab",
            "rgb(112, 128, 144)": "slategray",
            "rgb(119, 136, 153)": "lightslategray",
            "rgb(123, 104, 238)": "mediumslateblue",
            "rgb(124, 252, 0)": "lawngreen",
            "rgb(127, 255, 212)": "aquamarine",
            "rgb(127, 255, 0)": "chartreuse",
            "rgb(128, 128, 128)": "gray",
            "rgb(128, 0, 0)": "maroon",
            "rgb(128, 128, 0)": "olive",
            "rgb(128, 0, 128)": "purple",
            "rgb(135, 206, 250)": "lightskyblue",
            "rgb(135, 206, 235)": "skyblue",
            "rgb(138, 43, 226)": "blueviolet",
            "rgb(139, 0, 139)": "darkmagenta",
            "rgb(139, 0, 0)": "darkred",
            "rgb(139, 69, 19)": "saddlebrown",
            "rgb(143, 188, 143)": "darkseagreen",
            "rgb(144, 238, 144)": "lightgreen",
            "rgb(147, 112, 219)": "mediumpurple",
            "rgb(148, 0, 211)": "darkviolet",
            "rgb(152, 251, 152)": "palegreen",
            "rgb(153, 50, 204)": "darkorchid",
            "rgb(154, 205, 50)": "yellowgreen",
            "rgb(160, 82, 45)": "sienna",
            "rgb(165, 42, 42)": "brown",
            "rgb(169, 169, 169)": "darkgray",
            "rgb(173, 255, 47)": "greenyellow",
            "rgb(173, 216, 230)": "lightblue",
            "rgb(175, 238, 238)": "paleturquoise",
            "rgb(176, 196, 222)": "lightsteelblue",
            "rgb(176, 224, 230)": "powderblue",
            "rgb(178, 34, 34)": "firebrick",
            "rgb(184, 134, 11)": "darkgoldenrod",
            "rgb(186, 85, 211)": "mediumorchid",
            "rgb(188, 143, 143)": "rosybrown",
            "rgb(189, 183, 107)": "darkkhaki",
            "rgb(192, 192, 192)": "silver",
            "rgb(199, 21, 133)": "mediumvioletred",
            "rgb(205, 92, 92)": "indianred",
            "rgb(205, 133, 63)": "peru",
            "rgb(210, 105, 30)": "chocolate",
            "rgb(210, 180, 140)": "tan",
            "rgb(211, 211, 211)": "lightgray",
            "rgb(216, 191, 216)": "thistle",
            "rgb(218, 165, 32)": "goldenrod",
            "rgb(218, 112, 214)": "orchid",
            "rgb(219, 112, 147)": "palevioletred",
            "rgb(220, 20, 60)": "crimson",
            "rgb(220, 220, 220)": "gainsboro",
            "rgb(221, 160, 221)": "plum",
            "rgb(222, 184, 135)": "burlywood",
            "rgb(224, 255, 255)": "lightcyan",
            "rgb(230, 230, 250)": "lavender",
            "rgb(233, 150, 122)": "darksalmon",
            "rgb(238, 232, 170)": "palegoldenrod",
            "rgb(238, 130, 238)": "violet",
            "rgb(240, 255, 255)": "azure",
            "rgb(240, 255, 240)": "honeydew",
            "rgb(240, 230, 140)": "khaki",
            "rgb(240, 128, 128)": "lightcoral",
            "rgb(244, 164, 96)": "sandybrown",
            "rgb(245, 245, 220)": "beige",
            "rgb(245, 255, 250)": "mintcream",
            "rgb(245, 222, 179)": "wheat",
            "rgb(245, 245, 245)": "whitesmoke",
            "rgb(248, 248, 255)": "ghostwhite",
            "rgb(250, 250, 210)": "lightgoldenrodyellow",
            "rgb(250, 240, 230)": "linen",
            "rgb(250, 128, 114)": "salmon",
            "rgb(253, 245, 230)": "oldlace",
            "rgb(255, 228, 196)": "bisque",
            "rgb(255, 235, 205)": "blanchedalmond",
            "rgb(255, 127, 80)": "coral",
            "rgb(255, 248, 220)": "cornsilk",
            "rgb(255, 140, 0)": "darkorange",
            "rgb(255, 20, 147)": "deeppink",
            "rgb(255, 250, 240)": "floralwhite",
            "rgb(255, 215, 0)": "gold",
            "rgb(255, 105, 180)": "hotpink",
            "rgb(255, 255, 240)": "ivory",
            "rgb(255, 240, 245)": "lavenderblush",
            "rgb(255, 250, 205)": "lemonchiffon",
            "rgb(255, 182, 193)": "lightpink",
            "rgb(255, 160, 122)": "lightsalmon",
            "rgb(255, 255, 224)": "lightyellow",
            "rgb(255, 0, 255)": "magenta",
            "rgb(255, 228, 225)": "mistyrose",
            "rgb(255, 228, 181)": "moccasin",
            "rgb(255, 222, 173)": "navajowhite",
            "rgb(255, 165, 0)": "orange",
            "rgb(255, 69, 0)": "orangered",
            "rgb(255, 239, 213)": "papayawhip",
            "rgb(255, 218, 185)": "peachpuff",
            "rgb(255, 192, 203)": "pink",
            "rgb(255, 0, 0)": "red",
            "rgb(255, 245, 238)": "seashell",
            "rgb(255, 250, 250)": "snow",
            "rgb(255, 99, 71)": "tomato",
            "rgb(255, 255, 255)": "white",
            "rgb(255, 255, 0)": "yellow",
            "rgb(102, 51, 153)": "rebeccapurple"
        };
        var nameToRgbObject = {
            aqua: {
                r: 0,
                g: 255,
                b: 255
            },
            aliceblue: {
                r: 240,
                g: 248,
                b: 255
            },
            antiquewhite: {
                r: 250,
                g: 235,
                b: 215
            },
            black: {
                r: 0,
                g: 0,
                b: 0
            },
            blue: {
                r: 0,
                g: 0,
                b: 255
            },
            cyan: {
                r: 0,
                g: 255,
                b: 255
            },
            darkblue: {
                r: 0,
                g: 0,
                b: 139
            },
            darkcyan: {
                r: 0,
                g: 139,
                b: 139
            },
            darkgreen: {
                r: 0,
                g: 100,
                b: 0
            },
            darkturquoise: {
                r: 0,
                g: 206,
                b: 209
            },
            deepskyblue: {
                r: 0,
                g: 191,
                b: 255
            },
            green: {
                r: 0,
                g: 128,
                b: 0
            },
            lime: {
                r: 0,
                g: 255,
                b: 0
            },
            mediumblue: {
                r: 0,
                g: 0,
                b: 205
            },
            mediumspringgreen: {
                r: 0,
                g: 250,
                b: 154
            },
            navy: {
                r: 0,
                g: 0,
                b: 128
            },
            springgreen: {
                r: 0,
                g: 255,
                b: 127
            },
            teal: {
                r: 0,
                g: 128,
                b: 128
            },
            midnightblue: {
                r: 25,
                g: 25,
                b: 112
            },
            dodgerblue: {
                r: 30,
                g: 144,
                b: 255
            },
            lightseagreen: {
                r: 32,
                g: 178,
                b: 170
            },
            forestgreen: {
                r: 34,
                g: 139,
                b: 34
            },
            seagreen: {
                r: 46,
                g: 139,
                b: 87
            },
            darkslategray: {
                r: 47,
                g: 79,
                b: 79
            },
            darkslategrey: {
                r: 47,
                g: 79,
                b: 79
            },
            limegreen: {
                r: 50,
                g: 205,
                b: 50
            },
            mediumseagreen: {
                r: 60,
                g: 179,
                b: 113
            },
            turquoise: {
                r: 64,
                g: 224,
                b: 208
            },
            royalblue: {
                r: 65,
                g: 105,
                b: 225
            },
            steelblue: {
                r: 70,
                g: 130,
                b: 180
            },
            darkslateblue: {
                r: 72,
                g: 61,
                b: 139
            },
            mediumturquoise: {
                r: 72,
                g: 209,
                b: 204
            },
            indigo: {
                r: 75,
                g: 0,
                b: 130
            },
            darkolivegreen: {
                r: 85,
                g: 107,
                b: 47
            },
            cadetblue: {
                r: 95,
                g: 158,
                b: 160
            },
            cornflowerblue: {
                r: 100,
                g: 149,
                b: 237
            },
            mediumaquamarine: {
                r: 102,
                g: 205,
                b: 170
            },
            dimgray: {
                r: 105,
                g: 105,
                b: 105
            },
            dimgrey: {
                r: 105,
                g: 105,
                b: 105
            },
            slateblue: {
                r: 106,
                g: 90,
                b: 205
            },
            olivedrab: {
                r: 107,
                g: 142,
                b: 35
            },
            slategray: {
                r: 112,
                g: 128,
                b: 144
            },
            slategrey: {
                r: 112,
                g: 128,
                b: 144
            },
            lightslategray: {
                r: 119,
                g: 136,
                b: 153
            },
            lightslategrey: {
                r: 119,
                g: 136,
                b: 153
            },
            mediumslateblue: {
                r: 123,
                g: 104,
                b: 238
            },
            lawngreen: {
                r: 124,
                g: 252,
                b: 0
            },
            aquamarine: {
                r: 127,
                g: 255,
                b: 212
            },
            chartreuse: {
                r: 127,
                g: 255,
                b: 0
            },
            gray: {
                r: 128,
                g: 128,
                b: 128
            },
            grey: {
                r: 128,
                g: 128,
                b: 128
            },
            maroon: {
                r: 128,
                g: 0,
                b: 0
            },
            olive: {
                r: 128,
                g: 128,
                b: 0
            },
            purple: {
                r: 128,
                g: 0,
                b: 128
            },
            lightskyblue: {
                r: 135,
                g: 206,
                b: 250
            },
            skyblue: {
                r: 135,
                g: 206,
                b: 235
            },
            blueviolet: {
                r: 138,
                g: 43,
                b: 226
            },
            darkmagenta: {
                r: 139,
                g: 0,
                b: 139
            },
            darkred: {
                r: 139,
                g: 0,
                b: 0
            },
            saddlebrown: {
                r: 139,
                g: 69,
                b: 19
            },
            darkseagreen: {
                r: 143,
                g: 188,
                b: 143
            },
            lightgreen: {
                r: 144,
                g: 238,
                b: 144
            },
            mediumpurple: {
                r: 147,
                g: 112,
                b: 219
            },
            darkviolet: {
                r: 148,
                g: 0,
                b: 211
            },
            palegreen: {
                r: 152,
                g: 251,
                b: 152
            },
            darkorchid: {
                r: 153,
                g: 50,
                b: 204
            },
            yellowgreen: {
                r: 154,
                g: 205,
                b: 50
            },
            sienna: {
                r: 160,
                g: 82,
                b: 45
            },
            brown: {
                r: 165,
                g: 42,
                b: 42
            },
            darkgray: {
                r: 169,
                g: 169,
                b: 169
            },
            darkgrey: {
                r: 169,
                g: 169,
                b: 169
            },
            greenyellow: {
                r: 173,
                g: 255,
                b: 47
            },
            lightblue: {
                r: 173,
                g: 216,
                b: 230
            },
            paleturquoise: {
                r: 175,
                g: 238,
                b: 238
            },
            lightsteelblue: {
                r: 176,
                g: 196,
                b: 222
            },
            powderblue: {
                r: 176,
                g: 224,
                b: 230
            },
            firebrick: {
                r: 178,
                g: 34,
                b: 34
            },
            darkgoldenrod: {
                r: 184,
                g: 134,
                b: 11
            },
            mediumorchid: {
                r: 186,
                g: 85,
                b: 211
            },
            rosybrown: {
                r: 188,
                g: 143,
                b: 143
            },
            darkkhaki: {
                r: 189,
                g: 183,
                b: 107
            },
            silver: {
                r: 192,
                g: 192,
                b: 192
            },
            mediumvioletred: {
                r: 199,
                g: 21,
                b: 133
            },
            indianred: {
                r: 205,
                g: 92,
                b: 92
            },
            peru: {
                r: 205,
                g: 133,
                b: 63
            },
            chocolate: {
                r: 210,
                g: 105,
                b: 30
            },
            tan: {
                r: 210,
                g: 180,
                b: 140
            },
            lightgray: {
                r: 211,
                g: 211,
                b: 211
            },
            lightgrey: {
                r: 211,
                g: 211,
                b: 211
            },
            thistle: {
                r: 216,
                g: 191,
                b: 216
            },
            goldenrod: {
                r: 218,
                g: 165,
                b: 32
            },
            orchid: {
                r: 218,
                g: 112,
                b: 214
            },
            palevioletred: {
                r: 219,
                g: 112,
                b: 147
            },
            crimson: {
                r: 220,
                g: 20,
                b: 60
            },
            gainsboro: {
                r: 220,
                g: 220,
                b: 220
            },
            plum: {
                r: 221,
                g: 160,
                b: 221
            },
            burlywood: {
                r: 222,
                g: 184,
                b: 135
            },
            lightcyan: {
                r: 224,
                g: 255,
                b: 255
            },
            lavender: {
                r: 230,
                g: 230,
                b: 250
            },
            darksalmon: {
                r: 233,
                g: 150,
                b: 122
            },
            palegoldenrod: {
                r: 238,
                g: 232,
                b: 170
            },
            violet: {
                r: 238,
                g: 130,
                b: 238
            },
            azure: {
                r: 240,
                g: 255,
                b: 255
            },
            honeydew: {
                r: 240,
                g: 255,
                b: 240
            },
            khaki: {
                r: 240,
                g: 230,
                b: 140
            },
            lightcoral: {
                r: 240,
                g: 128,
                b: 128
            },
            sandybrown: {
                r: 244,
                g: 164,
                b: 96
            },
            beige: {
                r: 245,
                g: 245,
                b: 220
            },
            mintcream: {
                r: 245,
                g: 255,
                b: 250
            },
            wheat: {
                r: 245,
                g: 222,
                b: 179
            },
            whitesmoke: {
                r: 245,
                g: 245,
                b: 245
            },
            ghostwhite: {
                r: 248,
                g: 248,
                b: 255
            },
            lightgoldenrodyellow: {
                r: 250,
                g: 250,
                b: 210
            },
            linen: {
                r: 250,
                g: 240,
                b: 230
            },
            salmon: {
                r: 250,
                g: 128,
                b: 114
            },
            oldlace: {
                r: 253,
                g: 245,
                b: 230
            },
            bisque: {
                r: 255,
                g: 228,
                b: 196
            },
            blanchedalmond: {
                r: 255,
                g: 235,
                b: 205
            },
            coral: {
                r: 255,
                g: 127,
                b: 80
            },
            cornsilk: {
                r: 255,
                g: 248,
                b: 220
            },
            darkorange: {
                r: 255,
                g: 140,
                b: 0
            },
            deeppink: {
                r: 255,
                g: 20,
                b: 147
            },
            floralwhite: {
                r: 255,
                g: 250,
                b: 240
            },
            fuchsia: {
                r: 255,
                g: 0,
                b: 255
            },
            gold: {
                r: 255,
                g: 215,
                b: 0
            },
            hotpink: {
                r: 255,
                g: 105,
                b: 180
            },
            ivory: {
                r: 255,
                g: 255,
                b: 240
            },
            lavenderblush: {
                r: 255,
                g: 240,
                b: 245
            },
            lemonchiffon: {
                r: 255,
                g: 250,
                b: 205
            },
            lightpink: {
                r: 255,
                g: 182,
                b: 193
            },
            lightsalmon: {
                r: 255,
                g: 160,
                b: 122
            },
            lightyellow: {
                r: 255,
                g: 255,
                b: 224
            },
            magenta: {
                r: 255,
                g: 0,
                b: 255
            },
            mistyrose: {
                r: 255,
                g: 228,
                b: 225
            },
            moccasin: {
                r: 255,
                g: 228,
                b: 181
            },
            navajowhite: {
                r: 255,
                g: 222,
                b: 173
            },
            orange: {
                r: 255,
                g: 165,
                b: 0
            },
            orangered: {
                r: 255,
                g: 69,
                b: 0
            },
            papayawhip: {
                r: 255,
                g: 239,
                b: 213
            },
            peachpuff: {
                r: 255,
                g: 218,
                b: 185
            },
            pink: {
                r: 255,
                g: 192,
                b: 203
            },
            red: {
                r: 255,
                g: 0,
                b: 0
            },
            seashell: {
                r: 255,
                g: 245,
                b: 238
            },
            snow: {
                r: 255,
                g: 250,
                b: 250
            },
            tomato: {
                r: 255,
                g: 99,
                b: 71
            },
            white: {
                r: 255,
                g: 255,
                b: 255
            },
            yellow: {
                r: 255,
                g: 255,
                b: 0
            },
            rebeccapurple: {
                r: 102,
                g: 51,
                b: 153
            }
        };
        module.exports = {
            rgbToName: rgbToName,
            nameToRgbObject: nameToRgbObject
        }
    }, {}],
    52: [function(require, module, exports) {
        "use strict";
        module.exports = function decimalToHex(decimal) {
            return "#" + decimal.toString(16)
        }
    }, {}],
    53: [function(require, module, exports) {
        "use strict";
        module.exports = function hexToDecimal(hex) {
            return parseInt(hex.substr(1), 16)
        }
    }, {}],
    54: [function(require, module, exports) {
        "use strict";
        var shortToLongHex = require("./shortToLongHex");
        module.exports = function hexToRgb(hex) {
            hex = shortToLongHex(hex);
            var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
            return result ? "rgb(" + parseInt(result[1], 16) + ", " + parseInt(result[2], 16) + ", " + parseInt(result[3], 16) + ")" : null
        }
    }, {
        "./shortToLongHex": 68
    }],
    55: [function(require, module, exports) {
        "use strict";
        var isRgb = require("./isRgb");
        var isRgba = require("./isRgba");
        var isHex = require("./isHex");
        module.exports = function isColor(str) {
            return isHex(str) || isRgb(str) || isRgba(str)
        }
    }, {
        "./isHex": 56,
        "./isRgb": 57,
        "./isRgba": 58
    }],
    56: [function(require, module, exports) {
        "use strict";
        module.exports = function isHex(str) {
            var regex = /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i;
            return regex.test(str)
        }
    }, {}],
    57: [function(require, module, exports) {
        "use strict";
        module.exports = function isRgb(str) {
            var regex = /^rgb\(\s*([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5]),\s*([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5]),\s*([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])\s*\)$/;
            return regex.exec(str) !== null
        }
    }, {}],
    58: [function(require, module, exports) {
        "use strict";
        module.exports = function isRgba(str) {
            var regex = /^rgba\(\s*([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5]),\s*([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5]),\s*([01]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5]),\s*(0(\.\d+)?|1(\.0+)?)\s*\)$/;
            return regex.exec(str) !== null
        }
    }, {}],
    59: [function(require, module, exports) {
        "use strict";
        var isHex = require("./isHex");
        var hexToRgb = require("./hexToRgb");
        var rgbToObject = require("./rgbToObject");
        module.exports = function mixColors(from, to, percent) {
            from = isHex(from) ? hexToRgb(from) : from;
            to = isHex(to) ? hexToRgb(to) : to;
            from = rgbToObject(from);
            to = rgbToObject(to);
            var r = from.r + (to.r - from.r) * percent;
            var g = from.g + (to.g - from.g) * percent;
            var b = from.b + (to.b - from.b) * percent;
            return "rgb(" + Math.round(r) + ", " + Math.round(g) + ", " + Math.round(b) + ")"
        }
    }, {
        "./hexToRgb": 54,
        "./isHex": 56,
        "./rgbToObject": 65
    }],
    60: [function(require, module, exports) {
        "use strict";
        var rgbToObject = require("./rgbToObject");
        module.exports = function rgbToArray(rgb) {
            var o = rgbToObject(rgb);
            return [o.r, o.g, o.b]
        }
    }, {
        "./rgbToObject": 65
    }],
    61: [function(require, module, exports) {
        "use strict";
        var hexToDecimal = require("./hexToDecimal");
        var rgbToArray = require("./rgbToArray");
        var rgbToHex = require("./rgbToHex");
        module.exports = function rgbToDecimal(rgb) {
            var hex = rgbToHex.apply(this, rgbToArray(rgb));
            return hexToDecimal(hex)
        }
    }, {
        "./hexToDecimal": 53,
        "./rgbToArray": 60,
        "./rgbToHex": 62
    }],
    62: [function(require, module, exports) {
        "use strict";
        module.exports = function rgbToHex(r, g, b) {
            return "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)
        }
    }, {}],
    63: [function(require, module, exports) {
        "use strict";
        module.exports = function rgbToHsl(r, g, b) {
            if (arguments.length !== 3) {
                return false
            }
            r /= 255;
            g /= 255;
            b /= 255;
            var max = Math.max(r, g, b);
            var min = Math.min(r, g, b);
            var sum = max + min;
            var diff = max - min;
            var h;
            var s;
            var l = sum / 2;
            if (max === min) {
                h = s = 0
            } else {
                s = l > .5 ? diff / (2 - max - min) : diff / sum;
                switch (max) {
                    case r:
                        h = (g - b) / diff;
                        break;
                    case g:
                        h = 2 + (b - r) / diff;
                        break;
                    case b:
                        h = 4 + (r - g) / diff;
                        break
                }
                h *= 60;
                if (h < 0) {
                    h += 360
                }
            }
            return [h, Math.round(100 * s), Math.round(100 * l)]
        }
    }, {}],
    64: [function(require, module, exports) {
        "use strict";
        module.exports = function rgbToHsv(r, g, b) {
            if (arguments.length !== 3) {
                return false
            }
            var red = r / 255;
            var green = g / 255;
            var blue = b / 255;
            var max = Math.max(red, green, blue);
            var min = Math.min(red, green, blue);
            var h;
            var s;
            var v = max;
            var delta = max - min;
            s = max === 0 ? 0 : delta / max;
            if (max === min) {
                h = 0
            } else {
                switch (max) {
                    case red:
                        h = (green - blue) / delta + (green < blue ? 6 : 0);
                        break;
                    case green:
                        h = (blue - red) / delta + 2;
                        break;
                    case blue:
                        h = (red - green) / delta + 4;
                        break
                }
                h /= 6
            }
            return [Math.round(360 * h), Math.round(100 * s), Math.round(100 * v)]
        }
    }, {}],
    65: [function(require, module, exports) {
        "use strict";
        module.exports = function rgbToObject(rgb) {
            var regex = /rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)/;
            var match = regex.exec(rgb);
            return {
                r: Number(match[1]),
                g: Number(match[2]),
                b: Number(match[3])
            }
        }
    }, {}],
    66: [function(require, module, exports) {
        "use strict";
        var rgbaToObject = require("./rgbaToObject");
        module.exports = function rgbaToArray(rgba) {
            var o = rgbaToObject(rgba);
            return [o.r, o.g, o.b, o.a]
        }
    }, {
        "./rgbaToObject": 67
    }],
    67: [function(require, module, exports) {
        "use strict";
        module.exports = function rgbaToObject(rgba) {
            var regex = /rgba\(\s*(\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3}),\s*(0(\.\d+)?|1(\.0+)?)\s*\)/;
            var match = regex.exec(rgba);
            return {
                r: Number(match[1]),
                g: Number(match[2]),
                b: Number(match[3]),
                a: Number(match[4])
            }
        }
    }, {}],
    68: [function(require, module, exports) {
        "use strict";
        module.exports = function shortToLongHex(hex) {
            var shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
            hex = hex.replace(shorthandRegex, function(m, r, g, b) {
                return "#" + r + r + g + g + b + b
            });
            return hex
        }
    }, {}],
    69: [function(require, module, exports) {
        "use strict";
        var getBoundingClientRect = require("./utils/getBoundingClientRect");
        module.exports = function getDimensions(el, rendered) {
            var rect;
            if (rendered) {
                rect = getBoundingClientRect(el);
                return {
                    width: rect.width,
                    height: rect.height
                }
            }
            return {
                width: el.offsetWidth,
                height: el.offsetHeight
            }
        }
    }, {
        "./utils/getBoundingClientRect": 70
    }],
    70: [function(require, module, exports) {
        "use strict";
        module.exports = function getBoundingClientRect(el) {
            var rect = el.getBoundingClientRect();
            return {
                top: rect.top,
                right: rect.right,
                bottom: rect.bottom,
                left: rect.left,
                width: rect.width || rect.right - rect.left,
                height: rect.height || rect.bottom - rect.top
            }
        }
    }, {}],
    71: [function(require, module, exports) {
        "use strict";
        var cache = require("./shared/stylePropertyCache");
        var getStyleProperty = require("./getStyleProperty");
        var getStyleValue = require("./getStyleValue");
        module.exports = function getStyleCSS(property, value) {
            var css;
            property = getStyleProperty(property);
            if (!property) {
                return false
            }
            css = cache[property].css;
            if (typeof value !== "undefined") {
                value = getStyleValue(property, value);
                if (value === false) {
                    return false
                }
                css += ":" + value + ";"
            }
            return css
        }
    }, {
        "./getStyleProperty": 72,
        "./getStyleValue": 73,
        "./shared/stylePropertyCache": 76
    }],
    72: [function(require, module, exports) {
        "use strict";
        var cache = require("./shared/stylePropertyCache");
        var getStyleTestElement = require("./shared/getStyleTestElement");
        var toCSS = require("./utils/toCSS");
        var toDOM = require("./utils/toDOM");
        var prefixHelper = require("./shared/prefixHelper");
        var memoizeStyleProperty = function(property, prefixed) {
            var cssProperty = toCSS(property);
            var cssPrefixed = prefixed === false ? false : toCSS(prefixed);
            cache[property] = cache[prefixed] = cache[cssProperty] = cache[cssPrefixed] = {
                dom: prefixed,
                css: cssPrefixed
            };
            return prefixed
        };
        module.exports = function getStyleProperty(property) {
            var properties;
            var ucProperty;
            var el;
            var i;
            property += "";
            if (property in cache) {
                return cache[property].dom
            }
            el = getStyleTestElement();
            property = toDOM(property);
            ucProperty = property.charAt(0).toUpperCase() + property.substring(1);
            if (property === "filter") {
                properties = ["WebkitFilter", "filter"]
            } else {
                properties = (property + " " + prefixHelper.dom.join(ucProperty + " ") + ucProperty).split(" ")
            }
            for (i = 0; i < properties.length; i++) {
                if (typeof el.style[properties[i]] !== "undefined") {
                    if (i !== 0) {
                        prefixHelper.reduce(i - 1)
                    }
                    return memoizeStyleProperty(property, properties[i])
                }
            }
            return memoizeStyleProperty(property, false)
        }
    }, {
        "./shared/getStyleTestElement": 74,
        "./shared/prefixHelper": 75,
        "./shared/stylePropertyCache": 76,
        "./utils/toCSS": 79,
        "./utils/toDOM": 80
    }],
    73: [function(require, module, exports) {
        "use strict";
        var getStyleProperty = require("./getStyleProperty");
        var styleValueAvailable = require("./shared/styleValueAvailable");
        var prefixHelper = require("./shared/prefixHelper");
        var stylePropertyCache = require("./shared/stylePropertyCache");
        var styleValueCache = {};
        var RE_CSS_FUNCTION_PARAMS = /(\([^\)]+\))/gi;
        var RE_CSS_VALUES = /([^ ,;\(]+(\([^\)]+\))?)/gi;
        module.exports = function getStyleValue(property, value) {
            var cssProperty;
            value += "";
            property = getStyleProperty(property);
            if (!property) {
                return false
            }
            if (styleValueAvailable(property, value)) {
                return value
            }
            cssProperty = stylePropertyCache[property].css;
            value = value.replace(RE_CSS_VALUES, function(match) {
                var values;
                var valueKey;
                var key;
                var i;
                if (match[0] === "#" || !isNaN(match[0])) {
                    return match
                }
                valueKey = match.replace(RE_CSS_FUNCTION_PARAMS, "");
                key = cssProperty + ":" + valueKey;
                if (key in styleValueCache) {
                    if (styleValueCache[key] === false) {
                        return ""
                    }
                    return match.replace(valueKey, styleValueCache[key])
                }
                values = prefixHelper.css.map(function(prefix) {
                    return prefix + match
                });
                values = [match].concat(values);
                for (i = 0; i < values.length; i++) {
                    if (styleValueAvailable(property, values[i])) {
                        if (i !== 0) {
                            prefixHelper.reduce(i - 1)
                        }
                        styleValueCache[key] = values[i].replace(RE_CSS_FUNCTION_PARAMS, "");
                        return values[i]
                    }
                }
                styleValueCache[key] = false;
                return ""
            });
            value = value.trim();
            return value === "" ? false : value
        }
    }, {
        "./getStyleProperty": 72,
        "./shared/prefixHelper": 75,
        "./shared/stylePropertyCache": 76,
        "./shared/styleValueAvailable": 77
    }],
    74: [function(require, module, exports) {
        "use strict";
        var el;
        module.exports = function getStyleTestElement() {
            if (!el) {
                el = document.createElement("_")
            } else {
                el.style.cssText = "";
                el.removeAttribute("style")
            }
            return el
        };
        module.exports.resetElement = function() {
            el = null
        }
    }, {}],
    75: [function(require, module, exports) {
        arguments[4][6][0].apply(exports, arguments)
    }, {
        dup: 6
    }],
    76: [function(require, module, exports) {
        "use strict";
        module.exports = {}
    }, {}],
    77: [function(require, module, exports) {
        "use strict";
        var cache = require("./stylePropertyCache");
        var getStyleTestElement = require("./getStyleTestElement");
        var flagsSet = false;
        var supportsAvailable;
        var invalidStyleThrowsError;
        var prepareFlags = function() {
            var el;
            if (!flagsSet) {
                flagsSet = true;
                supportsAvailable = "CSS" in window && "supports" in window.CSS;
                invalidStyleThrowsError = false;
                el = getStyleTestElement();
                try {
                    el.style.width = "invalid"
                } catch (e) {
                    invalidStyleThrowsError = true
                }
            }
        };
        module.exports = function styleValueAvailable(property, value) {
            var before;
            var el;
            prepareFlags();
            if (supportsAvailable) {
                property = cache[property].css;
                return CSS.supports(property, value)
            }
            el = getStyleTestElement();
            before = el.style[property];
            if (invalidStyleThrowsError) {
                try {
                    el.style[property] = value
                } catch (e) {
                    return false
                }
            } else {
                el.style[property] = value
            }
            return el.style[property] && el.style[property] !== before
        };
        module.exports.resetFlags = function() {
            flagsSet = false
        }
    }, {
        "./getStyleTestElement": 74,
        "./stylePropertyCache": 76
    }],
    78: [function(require, module, exports) {
        "use strict";
        var RE_PREFIXES = /(-webkit-|-moz-|-ms-)|^(webkit|moz|ms)/gi;
        module.exports = function stripPrefixes(str) {
            str = String.prototype.replace.call(str, RE_PREFIXES, "");
            return str.charAt(0).toLowerCase() + str.substring(1)
        }
    }, {}],
    79: [function(require, module, exports) {
        "use strict";
        var RE_DOM_PREFIXES = /^(webkit|moz|ms)/gi;
        module.exports = function toCSS(str) {
            var i;
            if (str.toLowerCase() === "cssfloat") {
                return "float"
            }
            if (RE_DOM_PREFIXES.test(str)) {
                str = "-" + str
            }
            return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase()
        }
    }, {}],
    80: [function(require, module, exports) {
        "use strict";
        var RE_CSS_WORD = /-([a-z])/g;
        module.exports = function toDOM(str) {
            var i;
            if (str.toLowerCase() === "float") {
                return "cssFloat"
            }
            str = str.replace(RE_CSS_WORD, function(str, m1) {
                return m1.toUpperCase()
            });
            if (str.substr(0, 2) === "Ms") {
                str = "ms" + str.substring(2)
            }
            return str
        }
    }, {}],
    81: [function(require, module, exports) {
        "use strict";
        var getStyleProperty = require("@marcom/ac-prefixer/getStyleProperty");
        var stripPrefixes = require("@marcom/ac-prefixer/stripPrefixes");
        module.exports = function getStyle() {
            var properties = Array.prototype.slice.call(arguments);
            var target = properties.shift(properties);
            var computed = window.getComputedStyle(target);
            var styles = {};
            var property;
            var prefixed;
            var value;
            var i;
            if (typeof properties[0] !== "string") {
                properties = properties[0]
            }
            for (i = 0; i < properties.length; i++) {
                property = properties[i];
                prefixed = getStyleProperty(property);
                if (prefixed) {
                    property = stripPrefixes(prefixed);
                    value = computed[prefixed];
                    if (!value || value === "auto") {
                        value = null
                    }
                    if (value) {
                        value = stripPrefixes(value)
                    }
                } else {
                    value = null
                }
                styles[property] = value
            }
            return styles
        }
    }, {
        "@marcom/ac-prefixer/getStyleProperty": 72,
        "@marcom/ac-prefixer/stripPrefixes": 78
    }],
    82: [function(require, module, exports) {
        "use strict";
        module.exports = function normalizeValue(value) {
            var combined;
            var partials;
            var i;
            if (!value && value !== 0) {
                return ""
            }
            if (Array.isArray(value)) {
                return value + ""
            }
            if (typeof value === "object") {
                combined = "";
                partials = Object.keys(value);
                for (i = 0; i < partials.length; i++) {
                    combined += partials[i] + "(" + value[partials[i]] + ") "
                }
                return combined.trim()
            }
            return value
        }
    }, {}],
    83: [function(require, module, exports) {
        "use strict";
        var getStyleCSS = require("@marcom/ac-prefixer/getStyleCSS");
        var getStyleProperty = require("@marcom/ac-prefixer/getStyleProperty");
        var normalizeValue = require("./internal/normalizeValue");
        module.exports = function setStyle(target, styles) {
            var cssText = "";
            var cssRule;
            var property;
            var domProperty;
            var value;
            var targetCSSText;
            if (typeof styles !== "object") {
                throw new TypeError("setStyle: styles must be an Object")
            }
            for (property in styles) {
                value = normalizeValue(styles[property]);
                if (!value && value !== 0) {
                    domProperty = getStyleProperty(property);
                    if ("removeAttribute" in target.style) {
                        target.style.removeAttribute(domProperty)
                    } else {
                        target.style[domProperty] = ""
                    }
                } else {
                    cssRule = getStyleCSS(property, value);
                    if (cssRule !== false) {
                        cssText += " " + cssRule
                    }
                }
            }
            if (cssText.length) {
                targetCSSText = target.style.cssText;
                if (targetCSSText.charAt(targetCSSText.length - 1) !== ";") {
                    targetCSSText += ";"
                }
                targetCSSText += cssText;
                target.style.cssText = targetCSSText
            }
            return target
        }
    }, {
        "./internal/normalizeValue": 82,
        "@marcom/ac-prefixer/getStyleCSS": 71,
        "@marcom/ac-prefixer/getStyleProperty": 72
    }],
    84: [function(require, module, exports) {
        "use strict";
        module.exports = {
            createBezier: require("./ac-easing/createBezier"),
            createPredefined: require("./ac-easing/createPredefined"),
            createStep: require("./ac-easing/createStep"),
            Ease: require("./ac-easing/Ease")
        }
    }, {
        "./ac-easing/Ease": 85,
        "./ac-easing/createBezier": 86,
        "./ac-easing/createPredefined": 87,
        "./ac-easing/createStep": 88
    }],
    85: [function(require, module, exports) {
        "use strict";
        var ERR_FUNCTION_REQUIRE = "Ease expects an easing function.";

        function Ease(func, cssString) {
            if (typeof func !== "function") {
                throw new TypeError(ERR_FUNCTION_REQUIRE)
            }
            this.easingFunction = func;
            this.cssString = cssString || null
        }
        var proto = Ease.prototype;
        proto.getValue = function(value) {
            return this.easingFunction(value, 0, 1, 1)
        };
        module.exports = Ease
    }, {}],
    86: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.every");
        var Ease = require("./Ease");
        var KeySpline = require("./helpers/KeySpline");
        var ERR_BEZIER_VALUES = "Bezier curve expects exactly four (4) numbers. Given: ";
        module.exports = function createBezier(x1, y1, x2, y2) {
            var pts = Array.prototype.slice.call(arguments);
            var allNums = pts.every(function(pt) {
                return typeof pt === "number"
            });
            if (pts.length !== 4 || !allNums) {
                throw new TypeError(ERR_BEZIER_VALUES + pts)
            }
            var keySpline = new KeySpline(x1, y1, x2, y2);
            var easingFn = function(time, begin, change, duration) {
                return keySpline.get(time / duration) * change + begin
            };
            var cssString = "cubic-bezier(" + pts.join(", ") + ")";
            return new Ease(easingFn, cssString)
        }
    }, {
        "./Ease": 85,
        "./helpers/KeySpline": 89,
        "@marcom/ac-polyfills/Array/prototype.every": 385
    }],
    87: [function(require, module, exports) {
        "use strict";
        var createStep = require("./createStep");
        var cssAliases = require("./helpers/cssAliases");
        var easingFunctions = require("./helpers/easingFunctions");
        var Ease = require("./Ease");
        var ERR_PREDEFINED = 'Easing function "%TYPE%" not recognized among the following: ' + Object.keys(easingFunctions).join(", ");
        module.exports = function createPredefined(type) {
            var easingFn;
            if (type === "step-start") {
                return createStep(1, "start")
            } else if (type === "step-end") {
                return createStep(1, "end")
            } else {
                easingFn = easingFunctions[type]
            }
            if (!easingFn) {
                throw new Error(ERR_PREDEFINED.replace("%TYPE%", type))
            }
            return new Ease(easingFn, cssAliases[type])
        }
    }, {
        "./Ease": 85,
        "./createStep": 88,
        "./helpers/cssAliases": 90,
        "./helpers/easingFunctions": 91
    }],
    88: [function(require, module, exports) {
        "use strict";
        var Ease = require("./Ease");
        var ERR_STEP_TYPE = "Step function expects a numeric value greater than zero. Given: ";
        var ERR_STEP_DIRECTION = 'Step function direction must be either "start" or "end" (default). Given: ';
        module.exports = function createStep(steps, direction) {
            direction = direction || "end";
            if (typeof steps !== "number" || steps < 1) {
                throw new TypeError(ERR_STEP_TYPE + steps)
            }
            if (direction !== "start" && direction !== "end") {
                throw new TypeError(ERR_STEP_DIRECTION + direction)
            }
            var easingFn = function(time, begin, change, duration) {
                var length = change / steps;
                var step = Math[direction === "start" ? "floor" : "ceil"](time / duration * steps);
                return begin + length * step
            };
            var cssString = "steps(" + steps + ", " + direction + ")";
            return new Ease(easingFn, cssString)
        }
    }, {
        "./Ease": 85
    }],
    89: [function(require, module, exports) {
        function KeySpline(mX1, mY1, mX2, mY2) {
            this.get = function(aX) {
                if (mX1 === mY1 && mX2 === mY2) {
                    return aX
                }
                return CalcBezier(GetTForX(aX), mY1, mY2)
            };

            function A(aA1, aA2) {
                return 1 - 3 * aA2 + 3 * aA1
            }

            function B(aA1, aA2) {
                return 3 * aA2 - 6 * aA1
            }

            function C(aA1) {
                return 3 * aA1
            }

            function CalcBezier(aT, aA1, aA2) {
                return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT
            }

            function GetSlope(aT, aA1, aA2) {
                return 3 * A(aA1, aA2) * aT * aT + 2 * B(aA1, aA2) * aT + C(aA1)
            }

            function GetTForX(aX) {
                var aGuessT = aX;
                for (var i = 0; i < 4; ++i) {
                    var currentSlope = GetSlope(aGuessT, mX1, mX2);
                    if (currentSlope === 0) {
                        return aGuessT
                    }
                    var currentX = CalcBezier(aGuessT, mX1, mX2) - aX;
                    aGuessT -= currentX / currentSlope
                }
                return aGuessT
            }
        }
        module.exports = KeySpline
    }, {}],
    90: [function(require, module, exports) {
        "use strict";
        var aliases = {
            linear: "cubic-bezier(0, 0, 1, 1)",
            ease: "cubic-bezier(0.25, 0.1, 0.25, 1)",
            "ease-in": "cubic-bezier(0.42, 0, 1, 1)",
            "ease-out": "cubic-bezier(0, 0, 0.58, 1)",
            "ease-in-out": "cubic-bezier(0.42, 0, 0.58, 1)",
            "ease-in-cubic": "cubic-bezier(0.55, 0.055, 0.675, 0.19)",
            "ease-out-cubic": "cubic-bezier(0.215, 0.61, 0.355, 1)",
            "ease-in-out-cubic": "cubic-bezier(0.645, 0.045, 0.355, 1)",
            "ease-in-quad": "cubic-bezier(0.55, 0.085, 0.68, 0.53)",
            "ease-out-quad": "cubic-bezier(0.25, 0.46, 0.45, 0.94)",
            "ease-in-out-quad": "cubic-bezier(0.455, 0.03, 0.515, 0.955)",
            "ease-in-quart": "cubic-bezier(0.895, 0.03, 0.685, 0.22)",
            "ease-out-quart": "cubic-bezier(0.165, 0.84, 0.44, 1)",
            "ease-in-out-quart": "cubic-bezier(0.77, 0, 0.175, 1)",
            "ease-in-quint": "cubic-bezier(0.755, 0.05, 0.855, 0.06)",
            "ease-out-quint": "cubic-bezier(0.23, 1, 0.32, 1)",
            "ease-in-out-quint": "cubic-bezier(0.86, 0, 0.07, 1)",
            "ease-in-sine": "cubic-bezier(0.47, 0, 0.745, 0.715)",
            "ease-out-sine": "cubic-bezier(0.39, 0.575, 0.565, 1)",
            "ease-in-out-sine": "cubic-bezier(0.445, 0.05, 0.55, 0.95)",
            "ease-in-expo": "cubic-bezier(0.95, 0.05, 0.795, 0.035)",
            "ease-out-expo": "cubic-bezier(0.19, 1, 0.22, 1)",
            "ease-in-out-expo": "cubic-bezier(1, 0, 0, 1)",
            "ease-in-circ": "cubic-bezier(0.6, 0.04, 0.98, 0.335)",
            "ease-out-circ": "cubic-bezier(0.075, 0.82, 0.165, 1)",
            "ease-in-out-circ": "cubic-bezier(0.785, 0.135, 0.15, 0.86)",
            "ease-in-back": "cubic-bezier(0.6, -0.28, 0.735, 0.045)",
            "ease-out-back": "cubic-bezier(0.175, 0.885, 0.32, 1.275)",
            "ease-in-out-back": "cubic-bezier(0.68, -0.55, 0.265, 1.55)"
        };
        aliases["easeIn"] = aliases["ease-in"];
        aliases["easeOut"] = aliases["ease-out"];
        aliases["easeInOut"] = aliases["ease-in-out"];
        aliases["easeInCubic"] = aliases["ease-in-cubic"];
        aliases["easeOutCubic"] = aliases["ease-out-cubic"];
        aliases["easeInOutCubic"] = aliases["ease-in-out-cubic"];
        aliases["easeInQuad"] = aliases["ease-in-quad"];
        aliases["easeOutQuad"] = aliases["ease-out-quad"];
        aliases["easeInOutQuad"] = aliases["ease-in-out-quad"];
        aliases["easeInQuart"] = aliases["ease-in-quart"];
        aliases["easeOutQuart"] = aliases["ease-out-quart"];
        aliases["easeInOutQuart"] = aliases["ease-in-out-quart"];
        aliases["easeInQuint"] = aliases["ease-in-quint"];
        aliases["easeOutQuint"] = aliases["ease-out-quint"];
        aliases["easeInOutQuint"] = aliases["ease-in-out-quint"];
        aliases["easeInSine"] = aliases["ease-in-sine"];
        aliases["easeOutSine"] = aliases["ease-out-sine"];
        aliases["easeInOutSine"] = aliases["ease-in-out-sine"];
        aliases["easeInExpo"] = aliases["ease-in-expo"];
        aliases["easeOutExpo"] = aliases["ease-out-expo"];
        aliases["easeInOutExpo"] = aliases["ease-in-out-expo"];
        aliases["easeInCirc"] = aliases["ease-in-circ"];
        aliases["easeOutCirc"] = aliases["ease-out-circ"];
        aliases["easeInOutCirc"] = aliases["ease-in-out-circ"];
        aliases["easeInBack"] = aliases["ease-in-back"];
        aliases["easeOutBack"] = aliases["ease-out-back"];
        aliases["easeInOutBack"] = aliases["ease-in-out-back"];
        module.exports = aliases
    }, {}],
    91: [function(require, module, exports) {
        "use strict";
        var createBezier = require("../createBezier");
        var ease = createBezier(.25, .1, .25, 1).easingFunction;
        var easeIn = createBezier(.42, 0, 1, 1).easingFunction;
        var easeOut = createBezier(0, 0, .58, 1).easingFunction;
        var easeInOut = createBezier(.42, 0, .58, 1).easingFunction;
        var linear = function(time, begin, change, duration) {
            return change * time / duration + begin
        };
        var easeInQuad = function(time, begin, change, duration) {
            return change * (time /= duration) * time + begin
        };
        var easeOutQuad = function(time, begin, change, duration) {
            return -change * (time /= duration) * (time - 2) + begin
        };
        var easeInOutQuad = function(time, begin, change, duration) {
            if ((time /= duration / 2) < 1) {
                return change / 2 * time * time + begin
            }
            return -change / 2 * (--time * (time - 2) - 1) + begin
        };
        var easeInCubic = function(time, begin, change, duration) {
            return change * (time /= duration) * time * time + begin
        };
        var easeOutCubic = function(time, begin, change, duration) {
            return change * ((time = time / duration - 1) * time * time + 1) + begin
        };
        var easeInOutCubic = function(time, begin, change, duration) {
            if ((time /= duration / 2) < 1) {
                return change / 2 * time * time * time + begin
            }
            return change / 2 * ((time -= 2) * time * time + 2) + begin
        };
        var easeInQuart = function(time, begin, change, duration) {
            return change * (time /= duration) * time * time * time + begin
        };
        var easeOutQuart = function(time, begin, change, duration) {
            return -change * ((time = time / duration - 1) * time * time * time - 1) + begin
        };
        var easeInOutQuart = function(time, begin, change, duration) {
            if ((time /= duration / 2) < 1) {
                return change / 2 * time * time * time * time + begin
            }
            return -change / 2 * ((time -= 2) * time * time * time - 2) + begin
        };
        var easeInQuint = function(time, begin, change, duration) {
            return change * (time /= duration) * time * time * time * time + begin
        };
        var easeOutQuint = function(time, begin, change, duration) {
            return change * ((time = time / duration - 1) * time * time * time * time + 1) + begin
        };
        var easeInOutQuint = function(time, begin, change, duration) {
            if ((time /= duration / 2) < 1) {
                return change / 2 * time * time * time * time * time + begin
            }
            return change / 2 * ((time -= 2) * time * time * time * time + 2) + begin
        };
        var easeInSine = function(time, begin, change, duration) {
            return -change * Math.cos(time / duration * (Math.PI / 2)) + change + begin
        };
        var easeOutSine = function(time, begin, change, duration) {
            return change * Math.sin(time / duration * (Math.PI / 2)) + begin
        };
        var easeInOutSine = function(time, begin, change, duration) {
            return -change / 2 * (Math.cos(Math.PI * time / duration) - 1) + begin
        };
        var easeInExpo = function(time, begin, change, duration) {
            return time === 0 ? begin : change * Math.pow(2, 10 * (time / duration - 1)) + begin
        };
        var easeOutExpo = function(time, begin, change, duration) {
            return time === duration ? begin + change : change * (-Math.pow(2, -10 * time / duration) + 1) + begin
        };
        var easeInOutExpo = function(time, begin, change, duration) {
            if (time === 0) {
                return begin
            } else if (time === duration) {
                return begin + change
            } else if ((time /= duration / 2) < 1) {
                return change / 2 * Math.pow(2, 10 * (time - 1)) + begin
            }
            return change / 2 * (-Math.pow(2, -10 * --time) + 2) + begin
        };
        var easeInCirc = function(time, begin, change, duration) {
            return -change * (Math.sqrt(1 - (time /= duration) * time) - 1) + begin
        };
        var easeOutCirc = function(time, begin, change, duration) {
            return change * Math.sqrt(1 - (time = time / duration - 1) * time) + begin
        };
        var easeInOutCirc = function(time, begin, change, duration) {
            if ((time /= duration / 2) < 1) {
                return -change / 2 * (Math.sqrt(1 - time * time) - 1) + begin
            }
            return change / 2 * (Math.sqrt(1 - (time -= 2) * time) + 1) + begin
        };
        var easeInElastic = function(time, begin, change, duration) {
            var shootover = 1.70158;
            var period = 0;
            var amplitude = change;
            if (time === 0) {
                return begin
            } else if ((time /= duration) === 1) {
                return begin + change
            }
            if (!period) {
                period = duration * .3
            }
            if (amplitude < Math.abs(change)) {
                amplitude = change;
                shootover = period / 4
            } else {
                shootover = period / (2 * Math.PI) * Math.asin(change / amplitude)
            }
            return -(amplitude * Math.pow(2, 10 * (time -= 1)) * Math.sin((time * duration - shootover) * (2 * Math.PI) / period)) + begin
        };
        var easeOutElastic = function(time, begin, change, duration) {
            var shootover = 1.70158;
            var period = 0;
            var amplitude = change;
            if (time === 0) {
                return begin
            } else if ((time /= duration) === 1) {
                return begin + change
            }
            if (!period) {
                period = duration * .3
            }
            if (amplitude < Math.abs(change)) {
                amplitude = change;
                shootover = period / 4
            } else {
                shootover = period / (2 * Math.PI) * Math.asin(change / amplitude)
            }
            return amplitude * Math.pow(2, -10 * time) * Math.sin((time * duration - shootover) * (2 * Math.PI) / period) + change + begin
        };
        var easeInOutElastic = function(time, begin, change, duration) {
            var shootover = 1.70158;
            var period = 0;
            var amplitude = change;
            if (time === 0) {
                return begin
            } else if ((time /= duration / 2) === 2) {
                return begin + change
            }
            if (!period) {
                period = duration * (.3 * 1.5)
            }
            if (amplitude < Math.abs(change)) {
                amplitude = change;
                shootover = period / 4
            } else {
                shootover = period / (2 * Math.PI) * Math.asin(change / amplitude)
            }
            if (time < 1) {
                return -.5 * (amplitude * Math.pow(2, 10 * (time -= 1)) * Math.sin((time * duration - shootover) * (2 * Math.PI) / period)) + begin
            }
            return amplitude * Math.pow(2, -10 * (time -= 1)) * Math.sin((time * duration - shootover) * (2 * Math.PI) / period) * .5 + change + begin
        };
        var easeInBack = function(time, begin, change, duration, shootover) {
            if (shootover === undefined) {
                shootover = 1.70158
            }
            return change * (time /= duration) * time * ((shootover + 1) * time - shootover) + begin
        };
        var easeOutBack = function(time, begin, change, duration, shootover) {
            if (shootover === undefined) {
                shootover = 1.70158
            }
            return change * ((time = time / duration - 1) * time * ((shootover + 1) * time + shootover) + 1) + begin
        };
        var easeInOutBack = function(time, begin, change, duration, shootover) {
            if (shootover === undefined) {
                shootover = 1.70158
            }
            if ((time /= duration / 2) < 1) {
                return change / 2 * (time * time * (((shootover *= 1.525) + 1) * time - shootover)) + begin
            }
            return change / 2 * ((time -= 2) * time * (((shootover *= 1.525) + 1) * time + shootover) + 2) + begin
        };
        var easeOutBounce = function(time, begin, change, duration) {
            if ((time /= duration) < 1 / 2.75) {
                return change * (7.5625 * time * time) + begin
            } else if (time < 2 / 2.75) {
                return change * (7.5625 * (time -= 1.5 / 2.75) * time + .75) + begin
            } else if (time < 2.5 / 2.75) {
                return change * (7.5625 * (time -= 2.25 / 2.75) * time + .9375) + begin
            }
            return change * (7.5625 * (time -= 2.625 / 2.75) * time + .984375) + begin
        };
        var easeInBounce = function(time, begin, change, duration) {
            return change - easeOutBounce(duration - time, 0, change, duration) + begin
        };
        var easeInOutBounce = function(time, begin, change, duration) {
            if (time < duration / 2) {
                return easeInBounce(time * 2, 0, change, duration) * .5 + begin
            }
            return easeOutBounce(time * 2 - duration, 0, change, duration) * .5 + change * .5 + begin
        };
        module.exports = {
            linear: linear,
            ease: ease,
            easeIn: easeIn,
            "ease-in": easeIn,
            easeOut: easeOut,
            "ease-out": easeOut,
            easeInOut: easeInOut,
            "ease-in-out": easeInOut,
            easeInCubic: easeInCubic,
            "ease-in-cubic": easeInCubic,
            easeOutCubic: easeOutCubic,
            "ease-out-cubic": easeOutCubic,
            easeInOutCubic: easeInOutCubic,
            "ease-in-out-cubic": easeInOutCubic,
            easeInQuad: easeInQuad,
            "ease-in-quad": easeInQuad,
            easeOutQuad: easeOutQuad,
            "ease-out-quad": easeOutQuad,
            easeInOutQuad: easeInOutQuad,
            "ease-in-out-quad": easeInOutQuad,
            easeInQuart: easeInQuart,
            "ease-in-quart": easeInQuart,
            easeOutQuart: easeOutQuart,
            "ease-out-quart": easeOutQuart,
            easeInOutQuart: easeInOutQuart,
            "ease-in-out-quart": easeInOutQuart,
            easeInQuint: easeInQuint,
            "ease-in-quint": easeInQuint,
            easeOutQuint: easeOutQuint,
            "ease-out-quint": easeOutQuint,
            easeInOutQuint: easeInOutQuint,
            "ease-in-out-quint": easeInOutQuint,
            easeInSine: easeInSine,
            "ease-in-sine": easeInSine,
            easeOutSine: easeOutSine,
            "ease-out-sine": easeOutSine,
            easeInOutSine: easeInOutSine,
            "ease-in-out-sine": easeInOutSine,
            easeInExpo: easeInExpo,
            "ease-in-expo": easeInExpo,
            easeOutExpo: easeOutExpo,
            "ease-out-expo": easeOutExpo,
            easeInOutExpo: easeInOutExpo,
            "ease-in-out-expo": easeInOutExpo,
            easeInCirc: easeInCirc,
            "ease-in-circ": easeInCirc,
            easeOutCirc: easeOutCirc,
            "ease-out-circ": easeOutCirc,
            easeInOutCirc: easeInOutCirc,
            "ease-in-out-circ": easeInOutCirc,
            easeInBack: easeInBack,
            "ease-in-back": easeInBack,
            easeOutBack: easeOutBack,
            "ease-out-back": easeOutBack,
            easeInOutBack: easeInOutBack,
            "ease-in-out-back": easeInOutBack,
            easeInElastic: easeInElastic,
            "ease-in-elastic": easeInElastic,
            easeOutElastic: easeOutElastic,
            "ease-out-elastic": easeOutElastic,
            easeInOutElastic: easeInOutElastic,
            "ease-in-out-elastic": easeInOutElastic,
            easeInBounce: easeInBounce,
            "ease-in-bounce": easeInBounce,
            easeOutBounce: easeOutBounce,
            "ease-out-bounce": easeOutBounce,
            easeInOutBounce: easeInOutBounce,
            "ease-in-out-bounce": easeInOutBounce
        }
    }, {
        "../createBezier": 86
    }],
    92: [function(require, module, exports) {
        "use strict";
        module.exports = {
            EventEmitterMicro: require("./ac-event-emitter-micro/EventEmitterMicro")
        }
    }, {
        "./ac-event-emitter-micro/EventEmitterMicro": 93
    }],
    93: [function(require, module, exports) {
        "use strict";

        function EventEmitterMicro() {
            this._events = {}
        }
        var proto = EventEmitterMicro.prototype;
        proto.on = function(eventName, callback) {
            this._events[eventName] = this._events[eventName] || [];
            this._events[eventName].unshift(callback)
        };
        proto.once = function(eventName, callback) {
            var that = this;

            function fn(data) {
                that.off(eventName, fn);
                if (data !== undefined) callback(data);
                else callback()
            }
            this.on(eventName, fn)
        };
        proto.off = function(eventName, callback) {
            if (!this.has(eventName)) return;
            var index = this._events[eventName].indexOf(callback);
            if (index === -1) return;
            this._events[eventName].splice(index, 1)
        };
        proto.trigger = function(eventName, data) {
            if (!this.has(eventName)) return;
            for (var i = this._events[eventName].length - 1; i >= 0; i--) {
                if (data !== undefined) this._events[eventName][i](data);
                else this._events[eventName][i]()
            }
        };
        proto.has = function(eventName) {
            if (eventName in this._events === false || this._events[eventName].length === 0) {
                return false
            }
            return true
        };
        proto.destroy = function() {
            for (var eventName in this._events) {
                this._events[eventName] = null
            }
            this._events = null
        };
        module.exports = EventEmitterMicro
    }, {}],
    94: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/isArray");
        var extend = require("./extend");
        var hasOwnProp = Object.prototype.hasOwnProperty;
        var deepClone = function(dest, source) {
            var prop;
            for (prop in source) {
                if (hasOwnProp.call(source, prop)) {
                    if (source[prop] === null) {
                        dest[prop] = null
                    } else if (typeof source[prop] === "object") {
                        dest[prop] = Array.isArray(source[prop]) ? [] : {};
                        deepClone(dest[prop], source[prop])
                    } else {
                        dest[prop] = source[prop]
                    }
                }
            }
            return dest
        };
        module.exports = function clone(object, deep) {
            if (deep) {
                return deepClone({}, object)
            }
            return extend({}, object)
        }
    }, {
        "./extend": 96,
        "@marcom/ac-polyfills/Array/isArray": 384
    }],
    95: [function(require, module, exports) {
        arguments[4][15][0].apply(exports, arguments)
    }, {
        dup: 15
    }],
    96: [function(require, module, exports) {
        arguments[4][16][0].apply(exports, arguments)
    }, {
        "@marcom/ac-polyfills/Array/prototype.forEach": 387,
        dup: 16
    }],
    97: [function(require, module, exports) {
        "use strict";
        module.exports = {
            PageVisibilityManager: require("./ac-page-visibility/PageVisibilityManager")
        }
    }, {
        "./ac-page-visibility/PageVisibilityManager": 98
    }],
    98: [function(require, module, exports) {
        "use strict";
        var create = require("@marcom/ac-object/create");
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;

        function PageVisibilityManager() {
            if (typeof document.addEventListener === "undefined") {
                return
            }
            var visibilityChange;
            if (typeof document.hidden !== "undefined") {
                this._hidden = "hidden";
                visibilityChange = "visibilitychange"
            } else if (typeof document.mozHidden !== "undefined") {
                this._hidden = "mozHidden";
                visibilityChange = "mozvisibilitychange"
            } else if (typeof document.msHidden !== "undefined") {
                this._hidden = "msHidden";
                visibilityChange = "msvisibilitychange"
            } else if (typeof document.webkitHidden !== "undefined") {
                this._hidden = "webkitHidden";
                visibilityChange = "webkitvisibilitychange"
            }
            if (typeof document[this._hidden] === "undefined") {
                this.isHidden = false
            } else {
                this.isHidden = document[this._hidden]
            }
            if (visibilityChange) {
                document.addEventListener(visibilityChange, this._handleVisibilityChange.bind(this), false)
            }
            EventEmitterMicro.call(this)
        }
        var proto = PageVisibilityManager.prototype = create(EventEmitterMicro.prototype);
        proto.CHANGED = "changed";
        proto._handleVisibilityChange = function(evt) {
            this.isHidden = document[this._hidden];
            this.trigger(this.CHANGED, {
                isHidden: this.isHidden
            })
        };
        module.exports = new PageVisibilityManager
    }, {
        "@marcom/ac-event-emitter-micro": 92,
        "@marcom/ac-object/create": 95
    }],
    99: [function(require, module, exports) {
        module.exports = clone;

        function clone(a) {
            var out = new Float32Array(16);
            out[0] = a[0];
            out[1] = a[1];
            out[2] = a[2];
            out[3] = a[3];
            out[4] = a[4];
            out[5] = a[5];
            out[6] = a[6];
            out[7] = a[7];
            out[8] = a[8];
            out[9] = a[9];
            out[10] = a[10];
            out[11] = a[11];
            out[12] = a[12];
            out[13] = a[13];
            out[14] = a[14];
            out[15] = a[15];
            return out
        }
    }, {}],
    100: [function(require, module, exports) {
        module.exports = create;

        function create() {
            var out = new Float32Array(16);
            out[0] = 1;
            out[1] = 0;
            out[2] = 0;
            out[3] = 0;
            out[4] = 0;
            out[5] = 1;
            out[6] = 0;
            out[7] = 0;
            out[8] = 0;
            out[9] = 0;
            out[10] = 1;
            out[11] = 0;
            out[12] = 0;
            out[13] = 0;
            out[14] = 0;
            out[15] = 1;
            return out
        }
    }, {}],
    101: [function(require, module, exports) {
        module.exports = fromRotationTranslation;

        function fromRotationTranslation(out, q, v) {
            var x = q[0],
                y = q[1],
                z = q[2],
                w = q[3],
                x2 = x + x,
                y2 = y + y,
                z2 = z + z,
                xx = x * x2,
                xy = x * y2,
                xz = x * z2,
                yy = y * y2,
                yz = y * z2,
                zz = z * z2,
                wx = w * x2,
                wy = w * y2,
                wz = w * z2;
            out[0] = 1 - (yy + zz);
            out[1] = xy + wz;
            out[2] = xz - wy;
            out[3] = 0;
            out[4] = xy - wz;
            out[5] = 1 - (xx + zz);
            out[6] = yz + wx;
            out[7] = 0;
            out[8] = xz + wy;
            out[9] = yz - wx;
            out[10] = 1 - (xx + yy);
            out[11] = 0;
            out[12] = v[0];
            out[13] = v[1];
            out[14] = v[2];
            out[15] = 1;
            return out
        }
    }, {}],
    102: [function(require, module, exports) {
        module.exports = identity;

        function identity(out) {
            out[0] = 1;
            out[1] = 0;
            out[2] = 0;
            out[3] = 0;
            out[4] = 0;
            out[5] = 1;
            out[6] = 0;
            out[7] = 0;
            out[8] = 0;
            out[9] = 0;
            out[10] = 1;
            out[11] = 0;
            out[12] = 0;
            out[13] = 0;
            out[14] = 0;
            out[15] = 1;
            return out
        }
    }, {}],
    103: [function(require, module, exports) {
        module.exports = invert;

        function invert(out, a) {
            var a00 = a[0],
                a01 = a[1],
                a02 = a[2],
                a03 = a[3],
                a10 = a[4],
                a11 = a[5],
                a12 = a[6],
                a13 = a[7],
                a20 = a[8],
                a21 = a[9],
                a22 = a[10],
                a23 = a[11],
                a30 = a[12],
                a31 = a[13],
                a32 = a[14],
                a33 = a[15],
                b00 = a00 * a11 - a01 * a10,
                b01 = a00 * a12 - a02 * a10,
                b02 = a00 * a13 - a03 * a10,
                b03 = a01 * a12 - a02 * a11,
                b04 = a01 * a13 - a03 * a11,
                b05 = a02 * a13 - a03 * a12,
                b06 = a20 * a31 - a21 * a30,
                b07 = a20 * a32 - a22 * a30,
                b08 = a20 * a33 - a23 * a30,
                b09 = a21 * a32 - a22 * a31,
                b10 = a21 * a33 - a23 * a31,
                b11 = a22 * a33 - a23 * a32,
                det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
            if (!det) {
                return null
            }
            det = 1 / det;
            out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
            out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
            out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
            out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
            out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
            out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
            out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
            out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
            out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
            out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
            out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
            out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
            out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
            out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
            out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
            out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
            return out
        }
    }, {}],
    104: [function(require, module, exports) {
        module.exports = multiply;

        function multiply(out, a, b) {
            var a00 = a[0],
                a01 = a[1],
                a02 = a[2],
                a03 = a[3],
                a10 = a[4],
                a11 = a[5],
                a12 = a[6],
                a13 = a[7],
                a20 = a[8],
                a21 = a[9],
                a22 = a[10],
                a23 = a[11],
                a30 = a[12],
                a31 = a[13],
                a32 = a[14],
                a33 = a[15];
            var b0 = b[0],
                b1 = b[1],
                b2 = b[2],
                b3 = b[3];
            out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
            out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
            out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
            out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
            b0 = b[4];
            b1 = b[5];
            b2 = b[6];
            b3 = b[7];
            out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
            out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
            out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
            out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
            b0 = b[8];
            b1 = b[9];
            b2 = b[10];
            b3 = b[11];
            out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
            out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
            out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
            out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
            b0 = b[12];
            b1 = b[13];
            b2 = b[14];
            b3 = b[15];
            out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
            out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
            out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
            out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
            return out
        }
    }, {}],
    105: [function(require, module, exports) {
        module.exports = rotate;

        function rotate(out, a, rad, axis) {
            var x = axis[0],
                y = axis[1],
                z = axis[2],
                len = Math.sqrt(x * x + y * y + z * z),
                s, c, t, a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23, b00, b01, b02, b10, b11, b12, b20, b21, b22;
            if (Math.abs(len) < 1e-6) {
                return null
            }
            len = 1 / len;
            x *= len;
            y *= len;
            z *= len;
            s = Math.sin(rad);
            c = Math.cos(rad);
            t = 1 - c;
            a00 = a[0];
            a01 = a[1];
            a02 = a[2];
            a03 = a[3];
            a10 = a[4];
            a11 = a[5];
            a12 = a[6];
            a13 = a[7];
            a20 = a[8];
            a21 = a[9];
            a22 = a[10];
            a23 = a[11];
            b00 = x * x * t + c;
            b01 = y * x * t + z * s;
            b02 = z * x * t - y * s;
            b10 = x * y * t - z * s;
            b11 = y * y * t + c;
            b12 = z * y * t + x * s;
            b20 = x * z * t + y * s;
            b21 = y * z * t - x * s;
            b22 = z * z * t + c;
            out[0] = a00 * b00 + a10 * b01 + a20 * b02;
            out[1] = a01 * b00 + a11 * b01 + a21 * b02;
            out[2] = a02 * b00 + a12 * b01 + a22 * b02;
            out[3] = a03 * b00 + a13 * b01 + a23 * b02;
            out[4] = a00 * b10 + a10 * b11 + a20 * b12;
            out[5] = a01 * b10 + a11 * b11 + a21 * b12;
            out[6] = a02 * b10 + a12 * b11 + a22 * b12;
            out[7] = a03 * b10 + a13 * b11 + a23 * b12;
            out[8] = a00 * b20 + a10 * b21 + a20 * b22;
            out[9] = a01 * b20 + a11 * b21 + a21 * b22;
            out[10] = a02 * b20 + a12 * b21 + a22 * b22;
            out[11] = a03 * b20 + a13 * b21 + a23 * b22;
            if (a !== out) {
                out[12] = a[12];
                out[13] = a[13];
                out[14] = a[14];
                out[15] = a[15]
            }
            return out
        }
    }, {}],
    106: [function(require, module, exports) {
        module.exports = rotateX;

        function rotateX(out, a, rad) {
            var s = Math.sin(rad),
                c = Math.cos(rad),
                a10 = a[4],
                a11 = a[5],
                a12 = a[6],
                a13 = a[7],
                a20 = a[8],
                a21 = a[9],
                a22 = a[10],
                a23 = a[11];
            if (a !== out) {
                out[0] = a[0];
                out[1] = a[1];
                out[2] = a[2];
                out[3] = a[3];
                out[12] = a[12];
                out[13] = a[13];
                out[14] = a[14];
                out[15] = a[15]
            }
            out[4] = a10 * c + a20 * s;
            out[5] = a11 * c + a21 * s;
            out[6] = a12 * c + a22 * s;
            out[7] = a13 * c + a23 * s;
            out[8] = a20 * c - a10 * s;
            out[9] = a21 * c - a11 * s;
            out[10] = a22 * c - a12 * s;
            out[11] = a23 * c - a13 * s;
            return out
        }
    }, {}],
    107: [function(require, module, exports) {
        module.exports = rotateY;

        function rotateY(out, a, rad) {
            var s = Math.sin(rad),
                c = Math.cos(rad),
                a00 = a[0],
                a01 = a[1],
                a02 = a[2],
                a03 = a[3],
                a20 = a[8],
                a21 = a[9],
                a22 = a[10],
                a23 = a[11];
            if (a !== out) {
                out[4] = a[4];
                out[5] = a[5];
                out[6] = a[6];
                out[7] = a[7];
                out[12] = a[12];
                out[13] = a[13];
                out[14] = a[14];
                out[15] = a[15]
            }
            out[0] = a00 * c - a20 * s;
            out[1] = a01 * c - a21 * s;
            out[2] = a02 * c - a22 * s;
            out[3] = a03 * c - a23 * s;
            out[8] = a00 * s + a20 * c;
            out[9] = a01 * s + a21 * c;
            out[10] = a02 * s + a22 * c;
            out[11] = a03 * s + a23 * c;
            return out
        }
    }, {}],
    108: [function(require, module, exports) {
        module.exports = rotateZ;

        function rotateZ(out, a, rad) {
            var s = Math.sin(rad),
                c = Math.cos(rad),
                a00 = a[0],
                a01 = a[1],
                a02 = a[2],
                a03 = a[3],
                a10 = a[4],
                a11 = a[5],
                a12 = a[6],
                a13 = a[7];
            if (a !== out) {
                out[8] = a[8];
                out[9] = a[9];
                out[10] = a[10];
                out[11] = a[11];
                out[12] = a[12];
                out[13] = a[13];
                out[14] = a[14];
                out[15] = a[15]
            }
            out[0] = a00 * c + a10 * s;
            out[1] = a01 * c + a11 * s;
            out[2] = a02 * c + a12 * s;
            out[3] = a03 * c + a13 * s;
            out[4] = a10 * c - a00 * s;
            out[5] = a11 * c - a01 * s;
            out[6] = a12 * c - a02 * s;
            out[7] = a13 * c - a03 * s;
            return out
        }
    }, {}],
    109: [function(require, module, exports) {
        module.exports = scale;

        function scale(out, a, v) {
            var x = v[0],
                y = v[1],
                z = v[2];
            out[0] = a[0] * x;
            out[1] = a[1] * x;
            out[2] = a[2] * x;
            out[3] = a[3] * x;
            out[4] = a[4] * y;
            out[5] = a[5] * y;
            out[6] = a[6] * y;
            out[7] = a[7] * y;
            out[8] = a[8] * z;
            out[9] = a[9] * z;
            out[10] = a[10] * z;
            out[11] = a[11] * z;
            out[12] = a[12];
            out[13] = a[13];
            out[14] = a[14];
            out[15] = a[15];
            return out
        }
    }, {}],
    110: [function(require, module, exports) {
        module.exports = translate;

        function translate(out, a, v) {
            var x = v[0],
                y = v[1],
                z = v[2],
                a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23;
            if (a === out) {
                out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];
                out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];
                out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];
                out[15] = a[3] * x + a[7] * y + a[11] * z + a[15]
            } else {
                a00 = a[0];
                a01 = a[1];
                a02 = a[2];
                a03 = a[3];
                a10 = a[4];
                a11 = a[5];
                a12 = a[6];
                a13 = a[7];
                a20 = a[8];
                a21 = a[9];
                a22 = a[10];
                a23 = a[11];
                out[0] = a00;
                out[1] = a01;
                out[2] = a02;
                out[3] = a03;
                out[4] = a10;
                out[5] = a11;
                out[6] = a12;
                out[7] = a13;
                out[8] = a20;
                out[9] = a21;
                out[10] = a22;
                out[11] = a23;
                out[12] = a00 * x + a10 * y + a20 * z + a[12];
                out[13] = a01 * x + a11 * y + a21 * z + a[13];
                out[14] = a02 * x + a12 * y + a22 * z + a[14];
                out[15] = a03 * x + a13 * y + a23 * z + a[15]
            }
            return out
        }
    }, {}],
    111: [function(require, module, exports) {
        module.exports = transpose;

        function transpose(out, a) {
            if (out === a) {
                var a01 = a[1],
                    a02 = a[2],
                    a03 = a[3],
                    a12 = a[6],
                    a13 = a[7],
                    a23 = a[11];
                out[1] = a[4];
                out[2] = a[8];
                out[3] = a[12];
                out[4] = a01;
                out[6] = a[9];
                out[7] = a[13];
                out[8] = a02;
                out[9] = a12;
                out[11] = a[14];
                out[12] = a03;
                out[13] = a13;
                out[14] = a23
            } else {
                out[0] = a[0];
                out[1] = a[4];
                out[2] = a[8];
                out[3] = a[12];
                out[4] = a[1];
                out[5] = a[5];
                out[6] = a[9];
                out[7] = a[13];
                out[8] = a[2];
                out[9] = a[6];
                out[10] = a[10];
                out[11] = a[14];
                out[12] = a[3];
                out[13] = a[7];
                out[14] = a[11];
                out[15] = a[15]
            }
            return out
        }
    }, {}],
    112: [function(require, module, exports) {
        module.exports = create;

        function create() {
            var out = new Float32Array(3);
            out[0] = 0;
            out[1] = 0;
            out[2] = 0;
            return out
        }
    }, {}],
    113: [function(require, module, exports) {
        module.exports = cross;

        function cross(out, a, b) {
            var ax = a[0],
                ay = a[1],
                az = a[2],
                bx = b[0],
                by = b[1],
                bz = b[2];
            out[0] = ay * bz - az * by;
            out[1] = az * bx - ax * bz;
            out[2] = ax * by - ay * bx;
            return out
        }
    }, {}],
    114: [function(require, module, exports) {
        module.exports = dot;

        function dot(a, b) {
            return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
        }
    }, {}],
    115: [function(require, module, exports) {
        module.exports = fromValues;

        function fromValues(x, y, z) {
            var out = new Float32Array(3);
            out[0] = x;
            out[1] = y;
            out[2] = z;
            return out
        }
    }, {}],
    116: [function(require, module, exports) {
        module.exports = length;

        function length(a) {
            var x = a[0],
                y = a[1],
                z = a[2];
            return Math.sqrt(x * x + y * y + z * z)
        }
    }, {}],
    117: [function(require, module, exports) {
        module.exports = normalize;

        function normalize(out, a) {
            var x = a[0],
                y = a[1],
                z = a[2];
            var len = x * x + y * y + z * z;
            if (len > 0) {
                len = 1 / Math.sqrt(len);
                out[0] = a[0] * len;
                out[1] = a[1] * len;
                out[2] = a[2] * len
            }
            return out
        }
    }, {}],
    118: [function(require, module, exports) {
        module.exports = create;

        function create() {
            var out = new Float32Array(4);
            out[0] = 0;
            out[1] = 0;
            out[2] = 0;
            out[3] = 0;
            return out
        }
    }, {}],
    119: [function(require, module, exports) {
        module.exports = fromValues;

        function fromValues(x, y, z, w) {
            var out = new Float32Array(4);
            out[0] = x;
            out[1] = y;
            out[2] = z;
            out[3] = w;
            return out
        }
    }, {}],
    120: [function(require, module, exports) {
        module.exports = transformMat4;

        function transformMat4(out, a, m) {
            var x = a[0],
                y = a[1],
                z = a[2],
                w = a[3];
            out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;
            out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;
            out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;
            out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;
            return out
        }
    }, {}],
    121: [function(require, module, exports) {
        "use strict";
        module.exports = {
            Transform: require("./ac-transform/Transform")
        }
    }, {
        "./ac-transform/Transform": 122
    }],
    122: [function(require, module, exports) {
        "use strict";
        var mat4 = require("./gl-matrix/mat4");
        var vec3 = require("./gl-matrix/vec3");
        var vec4 = require("./gl-matrix/vec4");
        var degToRad = Math.PI / 180;
        var radToDeg = 180 / Math.PI;
        var m11 = 0,
            mA = 0,
            m12 = 1,
            mB = 1,
            m13 = 2,
            m14 = 3;
        var m21 = 4,
            mC = 4,
            m22 = 5,
            mD = 5,
            m23 = 6,
            m24 = 7;
        var m31 = 8,
            m32 = 9,
            m33 = 10,
            m34 = 11;
        var m41 = 12,
            mE = 12,
            m42 = 13,
            mF = 13,
            m43 = 14,
            m44 = 15;

        function Transform() {
            this.m = mat4.create()
        }
        var proto = Transform.prototype;
        proto.rotateX = function(deg) {
            var rad = degToRad * deg;
            mat4.rotateX(this.m, this.m, rad);
            return this
        };
        proto.rotateY = function(deg) {
            var rad = degToRad * deg;
            mat4.rotateY(this.m, this.m, rad);
            return this
        };
        proto.rotateZ = function(deg) {
            var rad = degToRad * deg;
            mat4.rotateZ(this.m, this.m, rad);
            return this
        };
        proto.rotate = proto.rotateZ;
        proto.rotate3d = function(x, y, z, deg) {
            if (y === null || y === undefined) y = x;
            if (z === null || y === undefined) z = x;
            var rad = degToRad * deg;
            mat4.rotate(this.m, this.m, rad, [x, y, z]);
            return this
        };
        proto.rotateAxisAngle = proto.rotate3d;
        proto.scale = function(sx, sy) {
            sy = sy || sx;
            mat4.scale(this.m, this.m, [sx, sy, 1]);
            return this
        };
        proto.scaleX = function(sx) {
            mat4.scale(this.m, this.m, [sx, 1, 1]);
            return this
        };
        proto.scaleY = function(sy) {
            mat4.scale(this.m, this.m, [1, sy, 1]);
            return this
        };
        proto.scaleZ = function(sz) {
            mat4.scale(this.m, this.m, [1, 1, sz]);
            return this
        };
        proto.scale3d = function(sx, sy, sz) {
            mat4.scale(this.m, this.m, [sx, sy, sz]);
            return this
        };
        proto.skew = function(ax, ay) {
            if (ay === null || ay === undefined) {
                return this.skewX(ax)
            }
            ax = degToRad * ax;
            ay = degToRad * ay;
            var transform = mat4.create();
            transform[mC] = Math.tan(ax);
            transform[mB] = Math.tan(ay);
            mat4.multiply(this.m, this.m, transform);
            return this
        };
        proto.skewX = function(ax) {
            ax = degToRad * ax;
            var transform = mat4.create();
            transform[mC] = Math.tan(ax);
            mat4.multiply(this.m, this.m, transform);
            return this
        };
        proto.skewY = function(ay) {
            ay = degToRad * ay;
            var transform = mat4.create();
            transform[mB] = Math.tan(ay);
            mat4.multiply(this.m, this.m, transform);
            return this
        };
        proto.translate = function(tx, ty) {
            ty = ty || 0;
            mat4.translate(this.m, this.m, [tx, ty, 0]);
            return this
        };
        proto.translate3d = function(tx, ty, tz) {
            mat4.translate(this.m, this.m, [tx, ty, tz]);
            return this
        };
        proto.translateX = function(tx) {
            mat4.translate(this.m, this.m, [tx, 0, 0]);
            return this
        };
        proto.translateY = function(ty) {
            mat4.translate(this.m, this.m, [0, ty, 0]);
            return this
        };
        proto.translateZ = function(tz) {
            mat4.translate(this.m, this.m, [0, 0, tz]);
            return this
        };
        proto.perspective = function(depth) {
            var t = mat4.create();
            if (depth !== 0) {
                t[m34] = -1 / depth
            }
            mat4.multiply(this.m, this.m, t)
        };
        proto.inverse = function() {
            var t = this.clone();
            t.m = mat4.invert(t.m, this.m);
            return t
        };
        proto.reset = function() {
            mat4.identity(this.m);
            return this
        };
        proto.getTranslateXY = function() {
            var m = this.m;
            if (this.isAffine()) {
                return [m[mE], m[mF]]
            }
            return [m[m41], m[m42]]
        };
        proto.getTranslateXYZ = function() {
            var m = this.m;
            if (this.isAffine()) {
                return [m[mE], m[mF], 0]
            }
            return [m[m41], m[m42], m[m43]]
        };
        proto.getTranslateX = function() {
            var m = this.m;
            if (this.isAffine()) {
                return m[mE]
            }
            return m[m41]
        };
        proto.getTranslateY = function() {
            var m = this.m;
            if (this.isAffine()) {
                return m[mF]
            }
            return m[m42]
        };
        proto.getTranslateZ = function() {
            var m = this.m;
            if (this.isAffine()) {
                return 0
            }
            return m[m43]
        };
        proto.clone = function() {
            var t = new Transform;
            t.m = mat4.clone(this.m);
            return t
        };
        proto.toArray = function() {
            var m = this.m;
            if (this.isAffine()) {
                return [m[mA], m[mB], m[mC], m[mD], m[mE], m[mF]]
            }
            return [m[m11], m[m12], m[m13], m[m14], m[m21], m[m22], m[m23], m[m24], m[m31], m[m32], m[m33], m[m34], m[m41], m[m42], m[m43], m[m44]]
        };
        proto.fromArray = function(arr) {
            this.m = Array.prototype.slice.call(arr);
            return this
        };
        proto.setMatrixValue = function(string) {
            string = String(string).trim();
            var m = mat4.create();
            if (string === "none") {
                this.m = m;
                return this
            }
            var type = string.slice(0, string.indexOf("(")),
                parts, i;
            if (type === "matrix3d") {
                parts = string.slice(9, -1).split(",");
                for (i = 0; i < parts.length; i++) {
                    m[i] = parseFloat(parts[i])
                }
            } else if (type === "matrix") {
                parts = string.slice(7, -1).split(",");
                for (i = parts.length; i--;) parts[i] = parseFloat(parts[i]);
                m[m11] = parts[0];
                m[m12] = parts[1];
                m[m41] = parts[4];
                m[m21] = parts[2];
                m[m22] = parts[3];
                m[m42] = parts[5]
            } else {
                throw new TypeError("Invalid Matrix Value")
            }
            this.m = m;
            return this
        };
        var isZero = function(val) {
            return Math.abs(val) < 1e-4
        };
        proto.decompose = function(convertToDegrees) {
            convertToDegrees = convertToDegrees || false;
            var matrix = mat4.clone(this.m);
            var translation = vec3.create();
            var scale = vec3.create();
            var skew = vec3.create();
            var perspective = vec4.create();
            var quaternion = vec4.create();
            var eulerRotation = vec3.create();
            for (var i = 0; i < 16; i++) matrix[i] /= matrix[m44];
            var perspectiveMatrix = mat4.clone(matrix);
            perspectiveMatrix[m14] = 0;
            perspectiveMatrix[m24] = 0;
            perspectiveMatrix[m34] = 0;
            perspectiveMatrix[m44] = 1;
            var a03 = matrix[3],
                a13 = matrix[7],
                a23 = matrix[11],
                a30 = matrix[12],
                a31 = matrix[13],
                a32 = matrix[14],
                a33 = matrix[15];
            var rightHandSide = vec4.create();
            if (!isZero(matrix[m14]) || !isZero(matrix[m24]) || !isZero(matrix[m34])) {
                rightHandSide[0] = matrix[m14];
                rightHandSide[1] = matrix[m24];
                rightHandSide[2] = matrix[m34];
                rightHandSide[3] = matrix[m44];
                var inversePerspectiveMatrix = mat4.invert(mat4.create(), perspectiveMatrix);
                var transposedInversePerspectiveMatrix = mat4.transpose(mat4.create(), inversePerspectiveMatrix);
                perspective = vec4.transformMat4(perspective, rightHandSide, transposedInversePerspectiveMatrix)
            } else {
                perspective = vec4.fromValues(0, 0, 0, 1)
            }
            translation[0] = a30;
            translation[1] = a31;
            translation[2] = a32;
            var row = [vec3.create(), vec3.create(), vec3.create()];
            row[0][0] = matrix[0];
            row[0][1] = matrix[1];
            row[0][2] = matrix[2];
            row[1][0] = matrix[4];
            row[1][1] = matrix[5];
            row[1][2] = matrix[6];
            row[2][0] = matrix[8];
            row[2][1] = matrix[9];
            row[2][2] = matrix[10];
            scale[0] = vec3.length(row[0]);
            vec3.normalize(row[0], row[0]);
            skew[0] = vec3.dot(row[0], row[1]);
            row[1] = this._combine(row[1], row[0], 1, -skew[0]);
            scale[1] = vec3.length(row[1]);
            vec3.normalize(row[1], row[1]);
            skew[0] /= scale[1];
            skew[1] = vec3.dot(row[0], row[2]);
            row[2] = this._combine(row[2], row[0], 1, -skew[1]);
            skew[2] = vec3.dot(row[1], row[2]);
            row[2] = this._combine(row[2], row[1], 1, -skew[2]);
            scale[2] = vec3.length(row[2]);
            vec3.normalize(row[2], row[2]);
            skew[1] /= scale[2];
            skew[2] /= scale[2];
            var pdum3 = vec3.cross(vec3.create(), row[1], row[2]);
            if (vec3.dot(row[0], pdum3) < 0) {
                for (i = 0; i < 3; i++) {
                    scale[i] *= -1;
                    row[i][0] *= -1;
                    row[i][1] *= -1;
                    row[i][2] *= -1
                }
            }
            quaternion[0] = .5 * Math.sqrt(Math.max(1 + row[0][0] - row[1][1] - row[2][2], 0));
            quaternion[1] = .5 * Math.sqrt(Math.max(1 - row[0][0] + row[1][1] - row[2][2], 0));
            quaternion[2] = .5 * Math.sqrt(Math.max(1 - row[0][0] - row[1][1] + row[2][2], 0));
            quaternion[3] = .5 * Math.sqrt(Math.max(1 + row[0][0] + row[1][1] + row[2][2], 0));
            if (row[2][1] > row[1][2]) quaternion[0] = -quaternion[0];
            if (row[0][2] > row[2][0]) quaternion[1] = -quaternion[1];
            if (row[1][0] > row[0][1]) quaternion[2] = -quaternion[2];
            var axisAngle = vec4.fromValues(quaternion[0], quaternion[1], quaternion[2], 2 * Math.acos(quaternion[3]));
            var rotation = this._rotationFromQuat(quaternion);
            if (convertToDegrees) {
                skew[0] = Math.round(skew[0] * radToDeg * 100) / 100;
                skew[1] = Math.round(skew[1] * radToDeg * 100) / 100;
                skew[2] = Math.round(skew[2] * radToDeg * 100) / 100;
                rotation[0] = Math.round(rotation[0] * radToDeg * 100) / 100;
                rotation[1] = Math.round(rotation[1] * radToDeg * 100) / 100;
                rotation[2] = Math.round(rotation[2] * radToDeg * 100) / 100;
                axisAngle[3] = Math.round(axisAngle[3] * radToDeg * 100) / 100
            }
            return {
                translation: translation,
                scale: scale,
                skew: skew,
                perspective: perspective,
                quaternion: quaternion,
                eulerRotation: rotation,
                axisAngle: axisAngle
            }
        };
        proto.recompose = function(translation, scale, skew, perspective, quaternion) {
            translation = translation || vec3.create();
            scale = scale || vec3.create();
            skew = skew || vec3.create();
            perspective = perspective || vec4.create();
            quaternion = quaternion || vec4.create();
            var matrix = mat4.fromRotationTranslation(mat4.create(), quaternion, translation);
            matrix[m14] = perspective[0];
            matrix[m24] = perspective[1];
            matrix[m34] = perspective[2];
            matrix[m44] = perspective[3];
            var temp = mat4.create();
            if (skew[2] !== 0) {
                temp[m32] = skew[2];
                mat4.multiply(matrix, matrix, temp)
            }
            if (skew[1] !== 0) {
                temp[m32] = 0;
                temp[m31] = skew[1];
                mat4.multiply(matrix, matrix, temp)
            }
            if (skew[0]) {
                temp[m31] = 0;
                temp[4] = skew[0];
                mat4.multiply(matrix, matrix, temp)
            }
            mat4.scale(matrix, matrix, scale);
            this.m = matrix;
            return this
        };
        proto.isAffine = function() {
            return this.m[m13] === 0 && this.m[m14] === 0 && this.m[m23] === 0 && this.m[m24] === 0 && this.m[m31] === 0 && this.m[m32] === 0 && this.m[m33] === 1 && this.m[m34] === 0 && this.m[m43] === 0 && this.m[m44] === 1
        };
        proto.toString = function() {
            var m = this.m;
            if (this.isAffine()) {
                return "matrix(" + m[mA] + ", " + m[mB] + ", " + m[mC] + ", " + m[mD] + ", " + m[mE] + ", " + m[mF] + ")"
            }
            return "matrix3d(" + m[m11] + ", " + m[m12] + ", " + m[m13] + ", " + m[m14] + ", " + m[m21] + ", " + m[m22] + ", " + m[m23] + ", " + m[m24] + ", " + m[m31] + ", " + m[m32] + ", " + m[m33] + ", " + m[m34] + ", " + m[m41] + ", " + m[m42] + ", " + m[m43] + ", " + m[m44] + ")"
        };
        proto.toCSSString = proto.toString;
        proto._combine = function(A, B, ascl, bscl) {
            var result = vec3.create();
            result[0] = ascl * A[0] + bscl * B[0];
            result[1] = ascl * A[1] + bscl * B[1];
            result[2] = ascl * A[2] + bscl * B[2];
            return result
        };
        proto._matrix2dToMat4 = function(matrix) {
            var out = mat4.create();
            for (var i = 0; i < 4; i++) {
                for (var j = 0; j < 4; j++) {
                    out[i * 4 + j] = matrix[i][j]
                }
            }
            return out
        };
        proto._mat4ToMatrix2d = function(ref) {
            var matrix = [];
            for (var i = 0; i < 4; i++) {
                matrix[i] = [];
                for (var j = 0; j < 4; j++) {
                    matrix[i][j] = ref[i * 4 + j]
                }
            }
            return matrix
        };
        proto._rotationFromQuat = function(q) {
            var sqw = q[3] * q[3];
            var sqx = q[0] * q[0];
            var sqy = q[1] * q[1];
            var sqz = q[2] * q[2];
            var unit = sqx + sqy + sqz + sqw;
            var test = q[0] * q[1] + q[2] * q[3];
            var x, y, z;
            if (test > .499 * unit) {
                y = 2 * Math.atan2(q[0], q[3]);
                z = Math.PI / 2;
                x = 0;
                return vec3.fromValues(x, y, z)
            }
            if (test < -.499 * unit) {
                y = -2 * Math.atan2(q[0], q[3]);
                z = -Math.PI / 2;
                x = 0;
                return vec3.fromValues(x, y, z)
            }
            y = Math.atan2(2 * q[1] * q[3] - 2 * q[0] * q[2], sqx - sqy - sqz + sqw);
            z = Math.asin(2 * test / unit);
            x = Math.atan2(2 * q[0] * q[3] - 2 * q[1] * q[2], -sqx + sqy - sqz + sqw);
            return vec3.fromValues(x, y, z)
        };
        module.exports = Transform
    }, {
        "./gl-matrix/mat4": 123,
        "./gl-matrix/vec3": 124,
        "./gl-matrix/vec4": 125
    }],
    123: [function(require, module, exports) {
        var mat4 = {
            create: require("gl-mat4/create"),
            rotate: require("gl-mat4/rotate"),
            rotateX: require("gl-mat4/rotateX"),
            rotateY: require("gl-mat4/rotateY"),
            rotateZ: require("gl-mat4/rotateZ"),
            scale: require("gl-mat4/scale"),
            multiply: require("gl-mat4/multiply"),
            translate: require("gl-mat4/translate"),
            invert: require("gl-mat4/invert"),
            clone: require("gl-mat4/clone"),
            transpose: require("gl-mat4/transpose"),
            identity: require("gl-mat4/identity"),
            fromRotationTranslation: require("gl-mat4/fromRotationTranslation")
        };
        module.exports = mat4
    }, {
        "gl-mat4/clone": 99,
        "gl-mat4/create": 100,
        "gl-mat4/fromRotationTranslation": 101,
        "gl-mat4/identity": 102,
        "gl-mat4/invert": 103,
        "gl-mat4/multiply": 104,
        "gl-mat4/rotate": 105,
        "gl-mat4/rotateX": 106,
        "gl-mat4/rotateY": 107,
        "gl-mat4/rotateZ": 108,
        "gl-mat4/scale": 109,
        "gl-mat4/translate": 110,
        "gl-mat4/transpose": 111
    }],
    124: [function(require, module, exports) {
        var vec3 = {
            create: require("gl-vec3/create"),
            dot: require("gl-vec3/dot"),
            normalize: require("gl-vec3/normalize"),
            length: require("gl-vec3/length"),
            cross: require("gl-vec3/cross"),
            fromValues: require("gl-vec3/fromValues")
        };
        module.exports = vec3
    }, {
        "gl-vec3/create": 112,
        "gl-vec3/cross": 113,
        "gl-vec3/dot": 114,
        "gl-vec3/fromValues": 115,
        "gl-vec3/length": 116,
        "gl-vec3/normalize": 117
    }],
    125: [function(require, module, exports) {
        var vec4 = {
            create: require("gl-vec4/create"),
            transformMat4: require("gl-vec4/transformMat4"),
            fromValues: require("gl-vec4/fromValues")
        };
        module.exports = vec4
    }, {
        "gl-vec4/create": 118,
        "gl-vec4/fromValues": 119,
        "gl-vec4/transformMat4": 120
    }],
    126: [function(require, module, exports) {
        "use strict";
        require("./helpers/Float32Array");
        var transitionEnd = require("./helpers/transitionEnd");
        var Clip = require("@marcom/ac-clip").Clip;
        var ClipEasing = require("./clips/ClipEasing");
        var ClipInlineCss = require("./clips/ClipInlineCss");
        var ClipTransitionCss = require("./clips/ClipTransitionCss");

        function ClipFactory(target, duration, propsTo, options) {
            if (target.nodeType) {
                if (transitionEnd === undefined || options && options.inlineStyles) {
                    return new ClipInlineCss(target, duration, propsTo, options)
                }
                return new ClipTransitionCss(target, duration, propsTo, options)
            }
            return new ClipEasing(target, duration, propsTo, options)
        }
        for (var prop in Clip) {
            if (typeof Clip[prop] === "function" && prop.substr(0, 1) !== "_") {
                ClipFactory[prop] = Clip[prop].bind(Clip)
            }
        }
        ClipFactory.to = function(target, duration, propsTo, options) {
            options = options || {};
            if (options.destroyOnComplete === undefined) {
                options.destroyOnComplete = true
            }
            return new ClipFactory(target, duration, propsTo, options).play()
        };
        ClipFactory.from = function(target, duration, propsFrom, options) {
            options = options || {};
            options.propsFrom = propsFrom;
            if (options.destroyOnComplete === undefined) {
                options.destroyOnComplete = true
            }
            return new ClipFactory(target, duration, options.propsTo, options).play()
        };
        module.exports = ClipFactory
    }, {
        "./clips/ClipEasing": 129,
        "./clips/ClipInlineCss": 130,
        "./clips/ClipTransitionCss": 131,
        "./helpers/Float32Array": 134,
        "./helpers/transitionEnd": 143,
        "@marcom/ac-clip": 47
    }],
    127: [function(require, module, exports) {
        "use strict";
        module.exports = require("./timeline/Timeline")
    }, {
        "./timeline/Timeline": 145
    }],
    128: [function(require, module, exports) {
        "use strict";
        module.exports = {
            Clip: require("./Clip"),
            Timeline: require("./Timeline")
        }
    }, {
        "./Clip": 126,
        "./Timeline": 127
    }],
    129: [function(require, module, exports) {
        "use strict";
        var clone = require("@marcom/ac-object/clone");
        var create = require("@marcom/ac-object/create");
        var createPredefined = require("@marcom/ac-easing").createPredefined;
        var isCssCubicBezierString = require("../helpers/isCssCubicBezierString");
        var BezierCurveCssManager = require("../helpers/BezierCurveCssManager");
        var Clip = require("@marcom/ac-clip").Clip;
        var Ease = require("@marcom/ac-easing").Ease;

        function ClipEasing(target, duration, propsTo, options) {
            if (options && isCssCubicBezierString(options.ease)) {
                options.ease = BezierCurveCssManager.create(options.ease).toEasingFunction()
            }
            options = options || {};
            this._propsEase = options.propsEase || {};
            Clip.call(this, target, duration, propsTo, options)
        }
        var Super = Clip.prototype;
        var proto = ClipEasing.prototype = create(Super);
        proto.reset = function() {
            var returnValue = Super.reset.call(this);
            if (this._clips) {
                var i = this._clips.length;
                while (i--) {
                    this._clips[i].reset()
                }
            }
            return returnValue
        };
        proto.destroy = function() {
            if (this._clips) {
                var i = this._clips.length;
                while (i--) {
                    this._clips[i].destroy()
                }
                this._clips = null
            }
            this._eases = null;
            this._storeOnUpdate = null;
            return Super.destroy.call(this)
        };
        proto._prepareProperties = function() {
            var easeCount = 0;
            var groupsTo = {};
            var groupsFrom = {};
            var eases = {};
            var prop;
            var ease;
            if (this._propsEase) {
                for (prop in this._propsTo) {
                    if (this._propsTo.hasOwnProperty(prop)) {
                        ease = this._propsEase[prop];
                        if (isCssCubicBezierString(ease)) {
                            ease = BezierCurveCssManager.create(ease).toEasingFunction()
                        }
                        if (ease === undefined) {
                            if (groupsTo[this._ease] === undefined) {
                                groupsTo[this._ease] = {};
                                groupsFrom[this._ease] = {};
                                eases[this._ease] = this._ease.easingFunction;
                                easeCount++
                            }
                            groupsTo[this._ease][prop] = this._propsTo[prop];
                            groupsFrom[this._ease][prop] = this._propsFrom[prop]
                        } else if (typeof ease === "function") {
                            groupsTo[easeCount] = {};
                            groupsFrom[easeCount] = {};
                            groupsTo[easeCount][prop] = this._propsTo[prop];
                            groupsFrom[easeCount][prop] = this._propsFrom[prop];
                            eases[easeCount] = ease;
                            easeCount++
                        } else {
                            if (groupsTo[ease] === undefined) {
                                groupsTo[ease] = {};
                                groupsFrom[ease] = {};
                                eases[ease] = ease;
                                easeCount++
                            }
                            groupsTo[ease][prop] = this._propsTo[prop];
                            groupsFrom[ease][prop] = this._propsFrom[prop]
                        }
                    }
                }
                if (easeCount > 1) {
                    var optionsClone = clone(this._options || {}, true);
                    var duration = this._duration * .001;
                    this._storeOnUpdate = this._onUpdate;
                    this._onUpdate = this._onUpdateClips;
                    optionsClone.onStart = null;
                    optionsClone.onUpdate = null;
                    optionsClone.onDraw = null;
                    optionsClone.onComplete = null;
                    this._clips = [];
                    for (ease in groupsTo) {
                        if (groupsTo.hasOwnProperty(ease)) {
                            optionsClone.ease = eases[ease];
                            optionsClone.propsFrom = groupsFrom[ease];
                            this._clips.push(new Clip(this._target, duration, groupsTo[ease], optionsClone))
                        }
                    }
                    ease = "linear";
                    this._propsTo = {};
                    this._propsFrom = {}
                } else {
                    for (prop in eases) {
                        if (eases.hasOwnProperty(prop)) {
                            ease = eases[prop]
                        }
                    }
                }
                if (ease !== undefined) {
                    this._ease = typeof ease === "function" ? new Ease(ease) : createPredefined(ease)
                }
            }
            return Super._prepareProperties.call(this)
        };
        proto._onUpdateClips = function(clip) {
            var progress = this._direction === 1 ? clip.progress() : 1 - clip.progress();
            var i = this._clips.length;
            while (i--) {
                this._clips[i].progress(progress)
            }
            if (typeof this._storeOnUpdate === "function") {
                this._storeOnUpdate.call(this, this)
            }
        };
        module.exports = ClipEasing
    }, {
        "../helpers/BezierCurveCssManager": 133,
        "../helpers/isCssCubicBezierString": 139,
        "@marcom/ac-clip": 47,
        "@marcom/ac-easing": 84,
        "@marcom/ac-object/clone": 94,
        "@marcom/ac-object/create": 95
    }],
    130: [function(require, module, exports) {
        "use strict";
        var setStyle = require("@marcom/ac-dom-styles/setStyle");
        var convertToStyleObject = require("../helpers/convertToStyleObject");
        var convertToTransitionableObjects = require("../helpers/convertToTransitionableObjects");
        var create = require("@marcom/ac-object/create");
        var removeTransitions = require("../helpers/removeTransitions");
        var ClipEasing = require("./ClipEasing");

        function ClipInlineCss(target, duration, propsTo, options) {
            options = options || {};
            this._el = target;
            this._storeOnStart = options.onStart || null;
            this._storeOnDraw = options.onDraw || null;
            this._storeOnComplete = options.onComplete || null;
            options.onStart = this._onStart;
            options.onDraw = this._onDraw;
            options.onComplete = this._onComplete;
            ClipEasing.call(this, {}, duration, propsTo, options)
        }
        var Super = ClipEasing.prototype;
        var proto = ClipInlineCss.prototype = create(Super);
        proto.play = function() {
            var returnValue = Super.play.call(this);
            if (this._remainingDelay !== 0) {
                setStyle(this._el, convertToStyleObject(this._target))
            }
            return returnValue
        };
        proto.reset = function() {
            var returnValue = Super.reset.call(this);
            setStyle(this._el, convertToStyleObject(this._target));
            return returnValue
        };
        proto.destroy = function() {
            this._el = null;
            this._completeStyles = null;
            this._storeOnStart = null;
            this._storeOnDraw = null;
            this._storeOnComplete = null;
            return Super.destroy.call(this)
        };
        proto.target = function() {
            return this._el
        };
        proto._prepareProperties = function() {
            var converted = convertToTransitionableObjects(this._el, this._propsTo, this._propsFrom);
            this._target = converted.target;
            this._propsFrom = converted.propsFrom;
            this._propsTo = converted.propsTo;
            removeTransitions(this._el, this._target);
            var completeStyles = this._isYoyo ? this._propsFrom : this._propsTo;
            this._completeStyles = convertToStyleObject(completeStyles);
            if (this._options.removeStylesOnComplete !== undefined) {
                var prop;
                var removeStyles = this._options.removeStylesOnComplete;
                if (typeof removeStyles === "boolean" && removeStyles) {
                    for (prop in this._completeStyles) {
                        if (this._completeStyles.hasOwnProperty(prop)) {
                            this._completeStyles[prop] = null
                        }
                    }
                } else if (typeof removeStyles === "object" && removeStyles.length) {
                    var i = removeStyles.length;
                    while (i--) {
                        prop = removeStyles[i];
                        if (this._completeStyles.hasOwnProperty(prop)) {
                            this._completeStyles[prop] = null
                        }
                    }
                }
            }
            return Super._prepareProperties.call(this)
        };
        proto._onStart = function(clip) {
            if (this.playing() && this._direction === 1 && this._delay === 0) {
                setStyle(this._el, convertToStyleObject(this._propsFrom))
            }
            if (typeof this._storeOnStart === "function") {
                this._storeOnStart.call(this, this)
            }
        };
        proto._onDraw = function(clip) {
            setStyle(this._el, convertToStyleObject(this._target));
            if (typeof this._storeOnDraw === "function") {
                this._storeOnDraw.call(this, this)
            }
        };
        proto._onComplete = function(clip) {
            setStyle(this._el, this._completeStyles);
            if (typeof this._storeOnComplete === "function") {
                this._storeOnComplete.call(this, this)
            }
        };
        module.exports = ClipInlineCss
    }, {
        "../helpers/convertToStyleObject": 136,
        "../helpers/convertToTransitionableObjects": 137,
        "../helpers/removeTransitions": 140,
        "./ClipEasing": 129,
        "@marcom/ac-dom-styles/setStyle": 83,
        "@marcom/ac-object/create": 95
    }],
    131: [function(require, module, exports) {
        "use strict";
        var setStyle = require("@marcom/ac-dom-styles/setStyle");
        var getStyle = require("@marcom/ac-dom-styles/getStyle");
        var convertToStyleObject = require("../helpers/convertToStyleObject");
        var convertToTransitionableObjects = require("../helpers/convertToTransitionableObjects");
        var clone = require("@marcom/ac-object/clone");
        var create = require("@marcom/ac-object/create");
        var createPredefined = require("@marcom/ac-easing").createPredefined;
        var isCssCubicBezierString = require("../helpers/isCssCubicBezierString");
        var removeTransitions = require("../helpers/removeTransitions");
        var transitionEnd = require("../helpers/transitionEnd");
        var waitAnimationFrames = require("../helpers/waitAnimationFrames");
        var BezierCurveCssManager = require("../helpers/BezierCurveCssManager");
        var Clip = require("@marcom/ac-clip").Clip;
        var ClipEasing = require("./ClipEasing");
        var PageVisibilityManager = require("@marcom/ac-page-visibility").PageVisibilityManager;
        var DEFAULT_EASE = "ease";
        var ERROR_EASE_NOT_SUPPORTED = "%EASE% is not a supported predefined ease when transitioning with Elements " + "and CSS transition. If you need to use %EASE% then pass the inlineStyle:true option.";
        var ERROR_EASE_IS_FUNCTION = "Function eases are not supported when using CSS transitions with Elements. " + "Either use a cubic-bezier string (e.g. 'cubic-bezier(0, 0, 1, 1)' or pass the " + "inlineStyle option as `true` to render styles each frame instead of using CSS transitions.";

        function ClipTransitionCss(target, duration, propsTo, options) {
            options = options || {};
            this._el = target;
            this._storeEase = options.ease;
            if (typeof this._storeEase === "function") {
                throw new Error(ERROR_EASE_IS_FUNCTION)
            }
            this._storeOnStart = options.onStart || null;
            this._storeOnComplete = options.onComplete || null;
            options.onStart = this._onStart.bind(this);
            options.onComplete = this._onComplete.bind(this);
            this._stylesTo = clone(propsTo, true);
            this._stylesFrom = options.propsFrom ? clone(options.propsFrom, true) : {};
            this._propsEase = options.propsEase ? clone(options.propsEase, true) : {};
            if (isCssCubicBezierString(options.ease)) {
                options.ease = BezierCurveCssManager.create(options.ease).toEasingFunction()
            }
            Clip.call(this, {}, duration, {}, options);
            this._propsFrom = {}
        }
        var Super = Clip.prototype;
        var proto = ClipTransitionCss.prototype = create(Super);
        proto.play = function() {
            var returnValue = Super.play.call(this);
            if (this._direction === 1 && this.progress() === 0 && this._remainingDelay !== 0) {
                this._applyStyles(0, convertToStyleObject(this._stylesFrom))
            }
            return returnValue
        };
        proto.reset = function() {
            var returnValue = Super.reset.call(this);
            this._stylesClip.reset();
            this._applyStyles(0, convertToStyleObject(this._styles));
            return returnValue
        };
        proto.destroy = function() {
            PageVisibilityManager.off("changed", this._onVisibilityChanged);
            this._removeTransitionListener();
            this.off("pause", this._onPaused);
            this._onPaused();
            this._stylesClip.destroy();
            this._stylesClip = null;
            this._el = null;
            this._propsArray = null;
            this._styles = null;
            this._stylesFrom = null;
            this._stylesTo = null;
            this._completeStyles = null;
            this._storeOnStart = null;
            this._storeOnComplete = null;
            this._onTransitionEnded = null;
            return Super.destroy.call(this)
        };
        proto.target = function() {
            return this._el
        };
        proto.duration = function(duration) {
            var returnValue = Super.duration.call(this, duration);
            if (duration === undefined) {
                return returnValue
            }
            if (this.playing()) {
                this.progress(this._progress)
            }
            return returnValue
        };
        proto.progress = function(progress) {
            var returnValue = Super.progress.call(this, progress);
            if (progress === undefined) {
                return returnValue
            }
            progress = this._direction === 1 ? progress : 1 - progress;
            this._stylesClip.progress(progress);
            this._applyStyles(0, convertToStyleObject(this._styles));
            if (this.playing()) {
                this._isWaitingForStylesToBeApplied = true;
                waitAnimationFrames(this._setStylesAfterWaiting, 2)
            }
            return returnValue
        };
        proto._prepareProperties = function() {
            var converted = convertToTransitionableObjects(this._el, this._stylesTo, this._stylesFrom);
            this._styles = converted.target;
            this._stylesTo = converted.propsTo;
            this._stylesFrom = converted.propsFrom;
            var ease = this._storeEase || DEFAULT_EASE;
            this._eases = {};
            this._propsArray = [];
            var convertedEase;
            this._styleCompleteTo = convertToStyleObject(this._stylesTo);
            this._styleCompleteFrom = convertToStyleObject(this._stylesFrom);
            this._propsEaseKeys = {};
            var prop;
            for (prop in this._stylesTo) {
                if (this._stylesTo.hasOwnProperty(prop)) {
                    this._propsArray[this._propsArray.length] = prop;
                    if (this._propsEase[prop] === undefined) {
                        if (this._eases[ease] === undefined) {
                            convertedEase = this._convertEase(ease);
                            this._eases[ease] = convertedEase.css
                        }
                        this._propsEaseKeys[prop] = ease
                    } else if (this._eases[this._propsEase[prop]] === undefined) {
                        convertedEase = this._convertEase(this._propsEase[prop]);
                        this._eases[this._propsEase[prop]] = convertedEase.css;
                        this._propsEaseKeys[prop] = this._propsEase[prop];
                        this._propsEase[prop] = convertedEase.js
                    } else if (isCssCubicBezierString(this._propsEase[prop])) {
                        this._propsEaseKeys[prop] = this._propsEase[prop];
                        this._propsEase[prop] = this._eases[this._propsEase[prop]]["1"].toEasingFunction()
                    }
                }
            }
            this._onPaused = this._onPaused.bind(this);
            this.on("pause", this._onPaused);
            this._setOtherTransitions();
            this._currentTransitionStyles = this._otherTransitions;
            this._completeStyles = convertToStyleObject(this._isYoyo ? this._stylesFrom : this._stylesTo);
            if (this._options.removeStylesOnComplete !== undefined) {
                var removeStyles = this._options.removeStylesOnComplete;
                if (typeof removeStyles === "boolean" && removeStyles) {
                    for (prop in this._stylesTo) {
                        this._completeStyles[prop] = null
                    }
                } else if (typeof removeStyles === "object" && removeStyles.length) {
                    var i = removeStyles.length;
                    while (i--) {
                        this._completeStyles[removeStyles[i]] = null
                    }
                }
            }
            this._onTransitionEnded = this._onTransitionEnded.bind(this);
            this._setStylesAfterWaiting = this._setStylesAfterWaiting.bind(this);
            this._onVisibilityChanged = this._onVisibilityChanged.bind(this);
            PageVisibilityManager.on(PageVisibilityManager.CHANGED, this._onVisibilityChanged);
            this._stylesClip = new ClipEasing(this._styles, 1, this._stylesTo, {
                ease: this._options.ease,
                propsFrom: this._stylesFrom,
                propsEase: this._options.propsEase
            });
            Clip._remove(this._stylesClip);
            return Super._prepareProperties.call(this)
        };
        proto._convertEase = function(ease) {
            if (typeof ease === "function") {
                throw new Error(ERROR_EASE_IS_FUNCTION)
            }
            var bezierCurve;
            var jsEase;
            if (isCssCubicBezierString(ease)) {
                bezierCurve = BezierCurveCssManager.create(ease);
                jsEase = bezierCurve.toEasingFunction()
            } else {
                var predefinedEase = createPredefined(ease);
                if (predefinedEase.cssString === null) {
                    throw new Error(ERROR_EASE_NOT_SUPPORTED.replace(/%EASE%/g, ease))
                }
                bezierCurve = BezierCurveCssManager.create(predefinedEase.cssString);
                jsEase = ease
            }
            return {
                css: {
                    1: bezierCurve,
                    "-1": bezierCurve.reversed()
                },
                js: jsEase
            }
        };
        proto._complete = function() {
            if ((this._isWaitingForStylesToBeApplied || this._isTransitionEnded || !this._isListeningForTransitionEnd) && this.progress() === 1) {
                this._isWaitingForStylesToBeApplied = false;
                Super._complete.call(this)
            }
        };
        proto._onTransitionEnded = function() {
            this._isTransitionEnded = true;
            this._complete()
        };
        proto._addTransitionListener = function() {
            if (!this._isListeningForTransitionEnd && this._el && this._onTransitionEnded) {
                this._isListeningForTransitionEnd = true;
                this._isTransitionEnded = false;
                this._el.addEventListener(transitionEnd, this._onTransitionEnded)
            }
        };
        proto._removeTransitionListener = function() {
            if (this._isListeningForTransitionEnd && this._el && this._onTransitionEnded) {
                this._isListeningForTransitionEnd = false;
                this._isTransitionEnded = false;
                this._el.removeEventListener(transitionEnd, this._onTransitionEnded)
            }
        };
        proto._applyStyles = function(duration, styles) {
            if (duration > 0) {
                var transition = "";
                var eases = {};
                var prop;
                for (prop in this._eases) {
                    if (this._eases.hasOwnProperty(prop)) {
                        eases[prop] = this._eases[prop][this._direction].splitAt(this.progress()).toCSSString()
                    }
                }
                for (prop in this._stylesTo) {
                    if (this._stylesTo.hasOwnProperty(prop)) {
                        transition += prop + " " + duration + "ms " + eases[this._propsEaseKeys[prop]] + " 0ms, "
                    }
                }
                this._currentTransitionStyles = transition.substr(0, transition.length - 2);
                if (!this._doStylesMatchCurrentStyles(styles)) {
                    this._addTransitionListener()
                } else {
                    this._removeTransitionListener()
                }
            } else {
                this._currentTransitionStyles = "";
                this._removeTransitionListener()
            }
            styles["transition"] = this._getOtherClipTransitionStyles() + this._currentTransitionStyles;
            setStyle(this._el, styles)
        };
        proto._doStylesMatchCurrentStyles = function(newStyles) {
            var currentStyles = getStyle.apply(this, [this._el].concat([this._propsArray]));
            var style;
            for (style in newStyles) {
                if (newStyles.hasOwnProperty(style) && currentStyles.hasOwnProperty(style) && newStyles[style] !== currentStyles[style]) {
                    return false
                }
            }
            return true
        };
        proto._setStylesAfterWaiting = function() {
            this._isWaitingForStylesToBeApplied = false;
            if (this.playing()) {
                var duration = this._durationMs * (1 - this.progress());
                var styles = this._direction > 0 ? this._styleCompleteTo : this._styleCompleteFrom;
                this._applyStyles(duration, styles)
            }
        };
        proto._setOtherTransitions = function() {
            removeTransitions(this._el, this._stylesTo);
            var clips = Clip.getAll(this._el);
            var i = clips.length;
            while (i--) {
                if (clips[i] !== this && clips[i].playing() && clips[i]._otherTransitions && clips[i]._otherTransitions.length) {
                    this._otherTransitions = clips[i]._otherTransitions;
                    return
                }
            }
            this._otherTransitions = getStyle(this._el, "transition").transition;
            if (this._otherTransitions === null || this._otherTransitions === "all 0s ease 0s") {
                this._otherTransitions = ""
            }
        };
        proto._getTransitionStyles = function() {
            var transition = this._getOtherClipTransitionStyles();
            if (this._otherTransitions.length) {
                transition += this._otherTransitions
            } else if (transition.length) {
                transition = transition.substr(0, transition.length - 2)
            }
            return transition
        };
        proto._getOtherClipTransitionStyles = function() {
            var transition = "";
            var clips = Clip.getAll(this._el);
            var i = clips.length;
            while (i--) {
                if (clips[i] !== this && clips[i].playing() && clips[i]._currentTransitionStyles && clips[i]._currentTransitionStyles.length) {
                    transition += clips[i]._currentTransitionStyles + ", "
                }
            }
            return transition
        };
        proto._onVisibilityChanged = function(evt) {
            if (this.playing() && !evt.isHidden) {
                this._update({
                    timeNow: this._getTime()
                });
                var progress = this.progress();
                if (progress < 1) {
                    this.progress(progress)
                }
            }
        };
        proto._onPaused = function(clip) {
            var styles = getStyle.apply(this, [this._el].concat([this._propsArray]));
            styles["transition"] = this._getTransitionStyles();
            this._removeTransitionListener();
            setStyle(this._el, styles)
        };
        proto._onStart = function(clip) {
            var waitFrames = this._direction === 1 && this.progress() === 0 && this._delay === 0 ? 2 : 0;
            if (waitFrames) {
                this._isWaitingForStylesToBeApplied = true;
                this._applyStyles(0, this._styleCompleteFrom)
            }
            waitAnimationFrames(this._setStylesAfterWaiting, waitFrames);
            if (typeof this._storeOnStart === "function") {
                this._storeOnStart.call(this, this)
            }
        };
        proto._onComplete = function(clip) {
            this._removeTransitionListener();
            this._completeStyles["transition"] = this._getTransitionStyles();
            setStyle(this._el, this._completeStyles);
            if (typeof this._storeOnComplete === "function") {
                this._storeOnComplete.call(this, this)
            }
        };
        module.exports = ClipTransitionCss
    }, {
        "../helpers/BezierCurveCssManager": 133,
        "../helpers/convertToStyleObject": 136,
        "../helpers/convertToTransitionableObjects": 137,
        "../helpers/isCssCubicBezierString": 139,
        "../helpers/removeTransitions": 140,
        "../helpers/transitionEnd": 143,
        "../helpers/waitAnimationFrames": 144,
        "./ClipEasing": 129,
        "@marcom/ac-clip": 47,
        "@marcom/ac-dom-styles/getStyle": 81,
        "@marcom/ac-dom-styles/setStyle": 83,
        "@marcom/ac-easing": 84,
        "@marcom/ac-object/clone": 94,
        "@marcom/ac-object/create": 95,
        "@marcom/ac-page-visibility": 97
    }],
    132: [function(require, module, exports) {
        "use strict";
        var createBezier = require("@marcom/ac-easing").createBezier;

        function BezierCurveCss(curve, manager) {
            this.manager = manager;
            this.p1 = {
                x: curve[0],
                y: curve[1]
            };
            this.p2 = {
                x: curve[2],
                y: curve[3]
            };
            this._isLinear = this.p1.x === this.p1.y && this.p2.x === this.p2.y;
            this._cacheSplits = {}
        }
        var proto = BezierCurveCss.prototype;
        proto.splitAt = function(percent) {
            if (this._isLinear) {
                return this
            }
            percent = Math.round(percent * 40) / 40;
            if (percent === 0) {
                return this
            } else if (this._cacheSplits[percent] !== undefined) {
                return this._cacheSplits[percent]
            }
            var x = [this.p1.x, this.p2.x];
            var y = [this.p1.y, this.p2.y];
            var maxIterations = 0;
            var targetX = percent;
            var min = 0;
            var max = 1;
            var startX = this._getStartX(percent, x);
            while (targetX !== startX && maxIterations < 1e3) {
                if (targetX < startX) {
                    max = percent
                } else {
                    min = percent
                }
                percent = min + (max - min) * .5;
                startX = this._getStartX(percent, x);
                ++maxIterations
            }
            var split = this._splitBezier(percent, x, y);
            var normalized = this._normalize(split);
            var newBezierCurve = this.manager.create(normalized);
            this._cacheSplits[targetX] = newBezierCurve;
            return newBezierCurve
        };
        proto.reversed = function() {
            var arr = this.toArray();
            return this.manager.create([.5 - (arr[2] - .5), .5 - (arr[3] - .5), .5 - (arr[0] - .5), .5 - (arr[1] - .5)])
        };
        proto.toArray = function() {
            return [this.p1.x, this.p1.y, this.p2.x, this.p2.y]
        };
        proto.toCSSString = function() {
            return "cubic-bezier(" + this.p1.x + ", " + this.p1.y + ", " + this.p2.x + ", " + this.p2.y + ")"
        };
        proto.toEasingFunction = function() {
            return createBezier.apply(this, this.toArray()).easingFunction
        };
        proto._getStartX = function(p, x) {
            var cp = p - 1;
            var p2 = p * p;
            var cp2 = cp * cp;
            var p3 = p2 * p;
            return p3 - 3 * p2 * cp * x[1] + 3 * p * cp2 * x[0]
        };
        proto._splitBezier = function(p, x, y) {
            var cp = p - 1;
            var p2 = p * p;
            var cp2 = cp * cp;
            var p3 = p2 * p;
            return [p3 - 3 * p2 * cp * x[1] + 3 * p * cp2 * x[0], p3 - 3 * p2 * cp * y[1] + 3 * p * cp2 * y[0], p2 - 2 * p * cp * x[1] + cp2 * x[0], p2 - 2 * p * cp * y[1] + cp2 * y[0], p - cp * x[1], p - cp * y[1]]
        };
        proto._normalize = function(array) {
            return [(array[2] - array[0]) / (1 - array[0]), (array[3] - array[1]) / (1 - array[1]), (array[4] - array[0]) / (1 - array[0]), (array[5] - array[1]) / (1 - array[1])]
        };
        module.exports = BezierCurveCss
    }, {
        "@marcom/ac-easing": 84
    }],
    133: [function(require, module, exports) {
        "use strict";
        var BezierCurveCss = require("./BezierCurveCss");

        function BezierCurveCssManager() {
            this._instances = {}
        }
        var proto = BezierCurveCssManager.prototype;
        proto.create = function(curve) {
            var key;
            if (typeof curve === "string") {
                key = curve.replace(/ /g, "")
            } else {
                key = "cubic-bezier(" + curve.join(",") + ")"
            }
            if (this._instances[key] === undefined) {
                if (typeof curve === "string") {
                    curve = curve.match(/\d*\.?\d+/g);
                    var i = curve.length;
                    while (i--) {
                        curve[i] = Number(curve[i])
                    }
                }
                this._instances[key] = new BezierCurveCss(curve, this)
            }
            return this._instances[key]
        };
        module.exports = new BezierCurveCssManager
    }, {
        "./BezierCurveCss": 132
    }],
    134: [function(require, module, exports) {
        "use strict";
        if (typeof window.Float32Array === "undefined") {
            window.Float32Array = function() {}
        }
    }, {}],
    135: [function(require, module, exports) {
        "use strict";
        var getDimensions = require("@marcom/ac-dom-metrics/getDimensions");
        var splitUnits = require("./splitUnits");
        var percentagePropToDimention = {
            translateX: "width",
            translateY: "height"
        };

        function TransformMatrix(transform, el, styles) {
            this._transform = transform;
            var split;
            var value;
            var prop;
            for (prop in styles) {
                if (styles.hasOwnProperty(prop) && typeof this._transform[prop] === "function") {
                    split = splitUnits(styles[prop]);
                    if (split.unit === "%") {
                        value = this._convertPercentToPixelValue(prop, split.value, el)
                    } else {
                        value = split.value
                    }
                    this._transform[prop].call(this._transform, value)
                }
            }
        }
        var proto = TransformMatrix.prototype;
        proto._convertPercentToPixelValue = function(prop, value, el) {
            prop = percentagePropToDimention[prop];
            var dimentions = getDimensions(el);
            if (dimentions[prop]) {
                value *= .01;
                return dimentions[prop] * value
            }
            return value
        };
        proto.toArray = function() {
            return this._transform.toArray()
        };
        proto.toCSSString = function() {
            return this._transform.toCSSString()
        };
        module.exports = TransformMatrix
    }, {
        "./splitUnits": 141,
        "@marcom/ac-dom-metrics/getDimensions": 69
    }],
    136: [function(require, module, exports) {
        "use strict";
        module.exports = function convertToStyleObject(target) {
            var styles = {};
            var matrix;
            var prop;
            for (prop in target) {
                if (target.hasOwnProperty(prop) && target[prop] !== null) {
                    if (target[prop].isColor) {
                        if (target[prop].isRgb) {
                            styles[prop] = "rgb(" + Math.round(target[prop].r) + ", " + Math.round(target[prop].g) + ", " + Math.round(target[prop].b) + ")"
                        } else if (target[prop].isRgba) {
                            styles[prop] = "rgba(" + Math.round(target[prop].r) + ", " + Math.round(target[prop].g) + ", " + Math.round(target[prop].b) + ", " + target[prop].a + ")"
                        }
                    } else if (prop === "transform") {
                        matrix = target[prop].length === 6 ? "matrix" : "matrix3d";
                        styles[prop] = matrix + "(" + target[prop].join(",") + ")"
                    } else if (!target[prop].unit) {
                        styles[prop] = target[prop].value
                    } else {
                        styles[prop] = target[prop].value + target[prop].unit
                    }
                }
            }
            return styles
        }
    }, {}],
    137: [function(require, module, exports) {
        "use strict";
        var getStyle = require("@marcom/ac-dom-styles/getStyle");
        var clone = require("@marcom/ac-object/clone");
        var splitUnits = require("./splitUnits");
        var toCamCase = require("./toCamCase");
        var Color = require("@marcom/ac-color").Color;
        var cssPropertyAvailable = require("@marcom/ac-feature/cssPropertyAvailable");
        var Transform = require("@marcom/ac-transform").Transform;
        var TransformMatrix = require("./TransformMatrix");
        var toColorObject = function(color) {
            if (Color.isRgba(color)) {
                color = new Color(color).rgbaObject();
                color["isRgba"] = true
            } else {
                color = new Color(color).rgbObject();
                color["isRgb"] = true
            }
            color["isColor"] = true;
            return color
        };
        var convertRgbToRgbaObject = function(obj) {
            if (obj.isRgb) {
                obj.isRgb = false;
                obj.isRgba = true;
                obj.a = 1
            }
        };
        var standardizeColors = function(target, propsFrom, propsTo) {
            if (target.isRgba || propsFrom.isRgba || propsTo.isRgba) {
                convertRgbToRgbaObject(target);
                convertRgbToRgbaObject(propsFrom);
                convertRgbToRgbaObject(propsTo)
            }
        };
        var convertMatrixTo3d = function(matrix) {
            return [matrix[0], matrix[1], 0, 0, matrix[2], matrix[3], 0, 0, 0, 0, 1, 0, matrix[4], matrix[5], 0, 1]
        };
        var standardizeMatrices = function(target, propsFrom, propsTo) {
            if (target["transform"].length === 16 || propsFrom["transform"].length === 16 || propsTo["transform"].length === 16) {
                if (target["transform"].length === 6) {
                    target["transform"] = convertMatrixTo3d(target["transform"])
                }
                if (propsFrom["transform"].length === 6) {
                    propsFrom["transform"] = convertMatrixTo3d(propsFrom["transform"])
                }
                if (propsTo["transform"].length === 6) {
                    propsTo["transform"] = convertMatrixTo3d(propsTo["transform"])
                }
            }
        };
        module.exports = function convertToTransitionableObjects(el, propsTo, propsFrom) {
            var target = {};
            propsTo = clone(propsTo, true);
            propsFrom = clone(propsFrom, true);
            var style;
            var mTarget;
            var mTo;
            var mFrom;
            var isTransformSupported = cssPropertyAvailable("transform");
            var prop;
            for (prop in propsTo) {
                if (propsTo.hasOwnProperty(prop) && propsTo[prop] !== null) {
                    if (prop === "transform") {
                        if (isTransformSupported) {
                            mTarget = new Transform;
                            style = getStyle(el, "transform")["transform"] || "none";
                            mTarget.setMatrixValue(style);
                            mTo = new TransformMatrix(new Transform, el, propsTo[prop])
                        }
                        if (mTo && mTo.toCSSString() !== mTarget.toCSSString()) {
                            mFrom = new TransformMatrix(propsFrom[prop] ? new Transform : mTarget.clone(), el, propsFrom[prop]);
                            target[prop] = mTarget.toArray();
                            propsTo[prop] = mTo.toArray();
                            propsFrom[prop] = mFrom.toArray()
                        } else {
                            target[prop] = null;
                            propsTo[prop] = null
                        }
                    } else {
                        style = getStyle(el, prop)[toCamCase(prop)] || propsFrom[prop];
                        if (Color.isColor(style)) {
                            target[prop] = toColorObject(style);
                            propsFrom[prop] = propsFrom[prop] !== undefined ? toColorObject(propsFrom[prop]) : clone(target[prop], true);
                            propsTo[prop] = toColorObject(propsTo[prop])
                        } else {
                            target[prop] = splitUnits(style);
                            propsFrom[prop] = propsFrom[prop] !== undefined ? splitUnits(propsFrom[prop]) : clone(target[prop], true);
                            propsTo[prop] = splitUnits(propsTo[prop])
                        }
                    }
                }
            }
            for (prop in propsFrom) {
                if (propsFrom.hasOwnProperty(prop) && propsFrom[prop] !== null && (propsTo[prop] === undefined || propsTo[prop] === null)) {
                    if (prop === "transform") {
                        if (isTransformSupported) {
                            mTarget = new Transform;
                            mTarget.setMatrixValue(getComputedStyle(el).transform || getComputedStyle(el).webkitTransform || "none");
                            mFrom = new TransformMatrix(new Transform, el, propsFrom[prop])
                        }
                        if (mFrom && mFrom.toCSSString() !== mTarget.toCSSString()) {
                            mTo = new TransformMatrix(mTarget.clone());
                            target[prop] = mTarget.toArray();
                            propsTo[prop] = mTo.toArray();
                            propsFrom[prop] = mFrom.toArray()
                        } else {
                            target[prop] = null;
                            propsTo[prop] = null;
                            propsFrom[prop] = null
                        }
                    } else {
                        style = getStyle(el, prop)[toCamCase(prop)];
                        if (Color.isColor(style)) {
                            target[prop] = toColorObject(style);
                            propsTo[prop] = clone(target[prop], true);
                            propsFrom[prop] = toColorObject(propsFrom[prop])
                        } else {
                            target[prop] = splitUnits(style);
                            propsFrom[prop] = splitUnits(propsFrom[prop]);
                            propsTo[prop] = clone(target[prop], true)
                        }
                    }
                }
                if (target[prop] && target[prop].isColor) {
                    standardizeColors(target[prop], propsFrom[prop], propsTo[prop])
                }
            }
            if (target["transform"]) {
                standardizeMatrices(target, propsFrom, propsTo)
            }
            return {
                target: target,
                propsTo: propsTo,
                propsFrom: propsFrom
            }
        }
    }, {
        "./TransformMatrix": 135,
        "./splitUnits": 141,
        "./toCamCase": 142,
        "@marcom/ac-color": 49,
        "@marcom/ac-dom-styles/getStyle": 81,
        "@marcom/ac-feature/cssPropertyAvailable": 159,
        "@marcom/ac-object/clone": 94,
        "@marcom/ac-transform": 121
    }],
    138: [function(require, module, exports) {
        "use strict";
        module.exports = function getShorthandTransition(styles) {
            if (styles.transitionProperty) {
                var transition = "";
                var props = styles.transitionProperty.split(", ");
                var duration = styles.transitionDuration.split(", ");
                var ease = styles.transitionTimingFunction.replace(/\d+[,]+[\s]/gi, function(match) {
                    return match.substr(0, match.length - 1)
                }).split(", ");
                var delay = styles.transitionDelay.split(", ");
                var i = props.length;
                while (i--) {
                    transition += props[i] + " " + duration[i] + " " + ease[i] + " " + delay[i] + ", "
                }
                return transition.substr(0, transition.length - 2)
            }
            return false
        }
    }, {}],
    139: [function(require, module, exports) {
        "use strict";
        module.exports = function isCssCubicBezierString(str) {
            return typeof str === "string" && str.substr(0, 13) === "cubic-bezier("
        }
    }, {}],
    140: [function(require, module, exports) {
        "use strict";
        var setStyle = require("@marcom/ac-dom-styles/setStyle");
        var getStyle = require("@marcom/ac-dom-styles/getStyle");
        var getShorthandTransition = require("./getShorthandTransition");
        module.exports = function removeTransitions(el, propsTo) {
            var transition = getStyle(el, "transition", "transition-property", "transition-duration", "transition-timing-function", "transition-delay");
            transition = transition.transition || getShorthandTransition(transition);
            if (transition && transition.length) {
                transition = transition.split(",");
                var deleteCount = 0;
                var prop;
                var i = transition.length;
                while (i--) {
                    prop = transition[i].trim().split(" ")[0];
                    if (propsTo[prop] !== undefined) {
                        transition.splice(i, 1);
                        ++deleteCount
                    }
                }
                if (deleteCount) {
                    if (transition.length === 0) {
                        transition = ["all"]
                    }
                    setStyle(el, {
                        transition: transition.join(",").trim()
                    })
                }
            }
        }
    }, {
        "./getShorthandTransition": 138,
        "@marcom/ac-dom-styles/getStyle": 81,
        "@marcom/ac-dom-styles/setStyle": 83
    }],
    141: [function(require, module, exports) {
        "use strict";
        module.exports = function splitUnits(value) {
            value = String(value);
            if (value.indexOf(" ") > -1) {
                throw new Error("Shorthand CSS is not supported. Please use longhand CSS only.")
            }
            var regex = /(\d*\.?\d*)(.*)/;
            var multipler = 1;
            if (value && value.substr(0, 1) === "-") {
                value = value.substr(1);
                multipler = -1
            }
            var match = String(value).match(regex);
            return {
                value: Number(match[1]) * multipler,
                unit: match[2]
            }
        }
    }, {}],
    142: [function(require, module, exports) {
        "use strict";
        module.exports = function toCamCase(str) {
            var camelCaseReplace = function(match, group, offset, string) {
                return offset === 0 && string.substr(1, 3) !== "moz" ? group : group.toUpperCase()
            };
            return str.replace(/-(\w)/g, camelCaseReplace)
        }
    }, {}],
    143: [function(require, module, exports) {
        "use strict";
        var transitionEnd;
        module.exports = function transitionEndEvent() {
            if (transitionEnd) {
                return transitionEnd
            }
            var t;
            var el = document.createElement("fakeelement");
            var transitions = {
                transition: "transitionend",
                OTransition: "oTransitionEnd",
                MozTransition: "transitionend",
                WebkitTransition: "webkitTransitionEnd"
            };
            for (t in transitions) {
                if (el.style[t] !== undefined) {
                    transitionEnd = transitions[t];
                    return transitionEnd
                }
            }
        }()
    }, {}],
    144: [function(require, module, exports) {
        "use strict";
        var PageVisibilityManager = require("@marcom/ac-page-visibility").PageVisibilityManager;
        module.exports = function waitAnimationFrames(callback, frames) {
            if (frames) {
                var rAF = function(cb) {
                    if (PageVisibilityManager.isHidden) {
                        setTimeout(cb, 16)
                    } else {
                        window.requestAnimationFrame(cb)
                    }
                };
                var count = 0;
                var waitFunc = function() {
                    if (count === frames) {
                        callback.call(this)
                    } else {
                        ++count;
                        rAF(waitFunc)
                    }
                };
                waitFunc()
            } else {
                callback.call(this)
            }
        }
    }, {
        "@marcom/ac-page-visibility": 97
    }],
    145: [function(require, module, exports) {
        "use strict";
        var create = require("@marcom/ac-object/create");
        var Clip = require("@marcom/ac-clip").Clip;
        var TimelineClip = require("./TimelineClip");
        var TimelineCallback = require("./TimelineCallback");
        var TimelineItemList = require("./TimelineItemList");
        var superProto = Clip.prototype;

        function Timeline(options) {
            options = options || {};
            options.ease = options.ease || "linear";
            options.destroyOnComplete = false;
            this.options = options;
            Clip.call(this, {
                t: 0
            }, 0, {
                t: 1
            }, options);
            this._itemList = new TimelineItemList
        }
        var proto = Timeline.prototype = create(superProto);
        Timeline.prototype.constructor = Timeline;
        proto._update = function(evt) {
            superProto._update.call(this, evt);
            this._render()
        };
        proto.progress = function(progress) {
            superProto.progress.call(this, progress);
            if (progress !== undefined) {
                this._render()
            }
            return this._progress
        };
        proto._render = function() {
            if (this._itemList.length === 0) {
                return
            }
            var renderTime = this._target.t * this._duration;
            var aClip = this._itemList.head;
            var next = aClip;
            while (next) {
                next = aClip.next;
                var offsetTime = renderTime - aClip.position;
                aClip.currentTime(offsetTime);
                aClip = next
            }
        };
        proto.addClip = function(clip, position) {
            position = position === undefined ? this.duration() : position;
            var builtInDelay = clip._delay / 1e3;
            this._itemList.append(new TimelineClip(clip, position + builtInDelay));
            this._updateDuration()
        };
        proto.addCallback = function(fn, position) {
            position = position === undefined ? this.duration() : position;
            this._itemList.append(new TimelineCallback(fn, position));
            this._updateDuration()
        };
        proto.remove = function(clipOrFunction) {
            var item = this._itemList.getItem(clipOrFunction);
            if (item) {
                this._itemList.remove(item);
                this._updateDuration()
            }
        };
        proto._updateDuration = function() {
            var lastClip = this._itemList.head;
            var duration = lastClip.position + lastClip.duration();
            this._itemList.forEach(function(clip) {
                var newDuration = clip.position + clip.duration();
                if (newDuration >= duration) {
                    lastClip = clip;
                    duration = newDuration
                }
            });
            this.duration(duration)
        };
        proto.destroy = function() {
            var next = this._itemList.head;
            while (next) {
                var timelineClip = next;
                next = timelineClip.next;
                this._itemList.remove(timelineClip)
            }
            this._duration = 0;
            return superProto.destroy.call(this)
        };
        module.exports = Timeline
    }, {
        "./TimelineCallback": 146,
        "./TimelineClip": 147,
        "./TimelineItemList": 148,
        "@marcom/ac-clip": 47,
        "@marcom/ac-object/create": 95
    }],
    146: [function(require, module, exports) {
        "use strict";

        function TimelineCallback(fn, position) {
            this.callback = fn;
            this._delay = 0;
            this.position = position;
            this._hasTriggered = false;
            this.prev = null;
            this.next = null
        }
        var proto = TimelineCallback.prototype;
        proto.duration = function() {
            return 0
        };
        proto.currentTime = function(offsetTime) {
            if (offsetTime >= 0 && !this._hasTriggered) {
                this.callback();
                this._hasTriggered = true
            }
            if (offsetTime < 0 && this._hasTriggered) {
                this.callback();
                this._hasTriggered = false
            }
            return 0
        };
        module.exports = TimelineCallback
    }, {}],
    147: [function(require, module, exports) {
        "use strict";

        function TimelineClip(clip, position) {
            this.clip = clip;
            this.position = position;
            this.duration = this.clip.duration.bind(this.clip);
            this.lastProgress = -1;
            this.prev = null;
            this.next = null
        }
        var proto = TimelineClip.prototype;
        proto.currentTime = function(offsetTime) {
            var clampedProgress = Math.min(1, Math.max(0, offsetTime / this.clip._duration));
            if (clampedProgress !== clampedProgress) {
                clampedProgress = 1
            }
            if (this.lastProgress === clampedProgress) {
                return this.lastProgress
            }
            if (this.lastProgress === 0 || clampedProgress === 0 || this.lastProgress === -1) {
                if (this.clip._storeOnStart) {
                    this.clip._storeOnStart(this.clip)
                }
            }
            this.clip._playing = clampedProgress * this.clip._duration === this.clip._duration;
            this.lastProgress = this.clip.progress(clampedProgress);
            return this.lastProgress
        };
        proto.destroy = function() {
            this.clip.destroy();
            this.prev = null;
            this.next = null;
            this.duration = null
        };
        module.exports = TimelineClip
    }, {}],
    148: [function(require, module, exports) {
        "use strict";
        var TimelineClip = require("./TimelineClip");
        var TimelineCallback = require("./TimelineCallback");
        var TimelineItemList = function() {
            this.head = null;
            this.tail = null;
            this.length = 0
        };
        var proto = TimelineItemList.prototype;
        proto.append = function(clip) {
            clip.prev = null;
            clip.next = null;
            if (this.tail) {
                this.tail.next = clip;
                clip.prev = this.tail
            } else {
                this.head = clip
            }
            this.tail = clip;
            this.length++
        };
        proto.remove = function(clip) {
            if (clip === this.head) {
                this.head = this.head.next
            } else if (clip === this.tail) {
                this.tail = this.tail.prev
            }
            if (clip.prev) {
                clip.prev.next = clip.next
            }
            if (clip.next) {
                clip.next.prev = clip.prev
            }
            clip.next = clip.prev = null;
            if (this.head === null) {
                this.tail = null
            }
            this.length--
        };
        proto.getItem = function(clipOrFunction) {
            var next = this.head;
            while (next) {
                var item = next;
                if (item instanceof TimelineClip && item.clip === clipOrFunction || item instanceof TimelineCallback && item.callback === clipOrFunction) {
                    return item
                }
                next = item.next
            }
            return null
        };
        proto.forEach = function(callback) {
            var i = 0;
            var next = this.head;
            while (next) {
                var clip = next;
                callback(clip, i, this.length);
                next = clip.next
            }
        };
        proto.destroy = function() {
            while (this.head) {
                var item = this.head;
                this.remove(item);
                item.destroy()
            }
        };
        module.exports = TimelineItemList
    }, {
        "./TimelineCallback": 146,
        "./TimelineClip": 147
    }],
    149: [function(require, module, exports) {
        "use strict";
        var defaultHashFunction = function() {
            var key = "";
            var i;
            for (i = 0; i < arguments.length; i++) {
                if (i > 0) {
                    key += ","
                }
                key += arguments[i]
            }
            return key
        };
        module.exports = function memoize(func, hashFunction) {
            hashFunction = hashFunction || defaultHashFunction;
            var memoized = function() {
                var args = arguments;
                var key = hashFunction.apply(this, args);
                if (!(key in memoized.cache)) {
                    memoized.cache[key] = func.apply(this, args)
                }
                return memoized.cache[key]
            };
            memoized.cache = {};
            return memoized
        }
    }, {}],
    150: [function(require, module, exports) {
        "use strict";
        module.exports = function once(func) {
            var result;
            return function() {
                if (typeof result === "undefined") {
                    result = func.apply(this, arguments)
                }
                return result
            }
        }
    }, {}],
    151: [function(require, module, exports) {
        arguments[4][72][0].apply(exports, arguments)
    }, {
        "./shared/getStyleTestElement": 153,
        "./shared/prefixHelper": 154,
        "./shared/stylePropertyCache": 155,
        "./utils/toCSS": 157,
        "./utils/toDOM": 158,
        dup: 72
    }],
    152: [function(require, module, exports) {
        arguments[4][73][0].apply(exports, arguments)
    }, {
        "./getStyleProperty": 151,
        "./shared/prefixHelper": 154,
        "./shared/stylePropertyCache": 155,
        "./shared/styleValueAvailable": 156,
        dup: 73
    }],
    153: [function(require, module, exports) {
        arguments[4][74][0].apply(exports, arguments)
    }, {
        dup: 74
    }],
    154: [function(require, module, exports) {
        arguments[4][6][0].apply(exports, arguments)
    }, {
        dup: 6
    }],
    155: [function(require, module, exports) {
        arguments[4][76][0].apply(exports, arguments)
    }, {
        dup: 76
    }],
    156: [function(require, module, exports) {
        arguments[4][77][0].apply(exports, arguments)
    }, {
        "./getStyleTestElement": 153,
        "./stylePropertyCache": 155,
        dup: 77
    }],
    157: [function(require, module, exports) {
        arguments[4][79][0].apply(exports, arguments)
    }, {
        dup: 79
    }],
    158: [function(require, module, exports) {
        arguments[4][80][0].apply(exports, arguments)
    }, {
        dup: 80
    }],
    159: [function(require, module, exports) {
        "use strict";
        var getStyleValue = require("@marcom/ac-prefixer/getStyleValue");
        var getStyleProperty = require("@marcom/ac-prefixer/getStyleProperty");
        var memoize = require("@marcom/ac-function/memoize");

        function cssPropertyAvailable(property, value) {
            if (typeof value !== "undefined") {
                return !!getStyleValue(property, value)
            } else {
                return !!getStyleProperty(property)
            }
        }
        module.exports = memoize(cssPropertyAvailable);
        module.exports.original = cssPropertyAvailable
    }, {
        "@marcom/ac-function/memoize": 149,
        "@marcom/ac-prefixer/getStyleProperty": 151,
        "@marcom/ac-prefixer/getStyleValue": 152
    }],
    160: [function(require, module, exports) {
        "use strict";
        module.exports = {
            getWindow: function() {
                return window
            },
            getDocument: function() {
                return document
            },
            getNavigator: function() {
                return navigator
            }
        }
    }, {}],
    161: [function(require, module, exports) {
        "use strict";
        var touchAvailable = require("./touchAvailable").original;
        var globalsHelper = require("./helpers/globals");
        var once = require("@marcom/ac-function/once");

        function isDesktop() {
            var windowObj = globalsHelper.getWindow();
            return !touchAvailable() && !windowObj.orientation
        }
        module.exports = once(isDesktop);
        module.exports.original = isDesktop
    }, {
        "./helpers/globals": 160,
        "./touchAvailable": 166,
        "@marcom/ac-function/once": 150
    }],
    162: [function(require, module, exports) {
        "use strict";
        var isDesktop = require("./isDesktop").original;
        var isTablet = require("./isTablet").original;
        var once = require("@marcom/ac-function/once");

        function isHandheld() {
            return !isDesktop() && !isTablet()
        }
        module.exports = once(isHandheld);
        module.exports.original = isHandheld
    }, {
        "./isDesktop": 161,
        "./isTablet": 164,
        "@marcom/ac-function/once": 150
    }],
    163: [function(require, module, exports) {
        "use strict";
        var globalsHelper = require("./helpers/globals");
        module.exports = function isRetina() {
            var windowObj = globalsHelper.getWindow();
            return "devicePixelRatio" in windowObj && windowObj.devicePixelRatio >= 1.5
        }
    }, {
        "./helpers/globals": 160
    }],
    164: [function(require, module, exports) {
        "use strict";
        var isDesktop = require("./isDesktop").original;
        var globalsHelper = require("./helpers/globals");
        var once = require("@marcom/ac-function/once");
        var MIN_TABLET_WIDTH = 600;

        function isTablet() {
            var windowObj = globalsHelper.getWindow();
            var width = windowObj.screen.width;
            if (windowObj.orientation && windowObj.screen.height < width) {
                width = windowObj.screen.height
            }
            return !isDesktop() && width >= MIN_TABLET_WIDTH
        }
        module.exports = once(isTablet);
        module.exports.original = isTablet
    }, {
        "./helpers/globals": 160,
        "./isDesktop": 161,
        "@marcom/ac-function/once": 150
    }],
    165: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/matchMedia");
        var globalsHelper = require("./helpers/globals");
        var once = require("@marcom/ac-function/once");

        function mediaQueriesAvailable() {
            var windowObj = globalsHelper.getWindow();
            var mql = windowObj.matchMedia("only all");
            return !!(mql && mql.matches)
        }
        module.exports = once(mediaQueriesAvailable);
        module.exports.original = mediaQueriesAvailable
    }, {
        "./helpers/globals": 160,
        "@marcom/ac-function/once": 150,
        "@marcom/ac-polyfills/matchMedia": 399
    }],
    166: [function(require, module, exports) {
        "use strict";
        var globalsHelper = require("./helpers/globals");
        var once = require("@marcom/ac-function/once");

        function touchAvailable() {
            var windowObj = globalsHelper.getWindow();
            var documentObj = globalsHelper.getDocument();
            var navigatorObj = globalsHelper.getNavigator();
            return !!("ontouchstart" in windowObj || windowObj.DocumentTouch && documentObj instanceof windowObj.DocumentTouch || navigatorObj.maxTouchPoints > 0 || navigatorObj.msMaxTouchPoints > 0)
        }
        module.exports = once(touchAvailable);
        module.exports.original = touchAvailable
    }, {
        "./helpers/globals": 160,
        "@marcom/ac-function/once": 150
    }],
    167: [function(require, module, exports) {
        arguments[4][13][0].apply(exports, arguments)
    }, {
        "./ac-event-emitter-micro/EventEmitterMicro": 168,
        dup: 13
    }],
    168: [function(require, module, exports) {
        arguments[4][14][0].apply(exports, arguments)
    }, {
        dup: 14
    }],
    169: [function(require, module, exports) {
        "use strict";
        var TabManager = require("./helpers/TabManager");
        var hideSiblingElements = require("./helpers/hideSiblingElements");
        var showSiblingElements = require("./helpers/showSiblingElements");
        var CircularTab = function(parentElement) {
            this._tabbables = null;
            this._firstTabbableElement = null;
            this._lastTabbableElement = null;
            this._relatedTarget = null;
            this.el = parentElement;
            this._handleOnFocus = this._handleOnFocus.bind(this)
        };
        var proto = CircularTab.prototype;
        proto.start = function() {
            this.updateTabbables();
            hideSiblingElements(this.el);
            if (this._firstTabbableElement) {
                if (!this.el.contains(document.activeElement)) {
                    this._firstTabbableElement.focus()
                }
            } else {
                console.warn("this._firstTabbableElement is null, CircularTab needs at least one tabbable element.")
            }
            this._relatedTarget = document.activeElement;
            document.addEventListener("focus", this._handleOnFocus, true)
        };
        proto.stop = function() {
            showSiblingElements(this.el);
            document.removeEventListener("focus", this._handleOnFocus, true)
        };
        proto.updateTabbables = function() {
            this._tabbables = TabManager.getTabbableElements(this.el);
            this._firstTabbableElement = this._tabbables[0];
            this._lastTabbableElement = this._tabbables[this._tabbables.length - 1]
        };
        proto._handleOnFocus = function(e) {
            if (!this.el.contains(e.target)) {
                e.preventDefault();
                this.updateTabbables();
                if (this._relatedTarget === this._lastTabbableElement || this._relatedTarget === null) {
                    this._firstTabbableElement.focus();
                    this._relatedTarget = this._firstTabbableElement;
                    return
                }
                if (this._relatedTarget === this._firstTabbableElement) {
                    this._lastTabbableElement.focus();
                    this._relatedTarget = this._lastTabbableElement;
                    return
                }
            } else {
                this._relatedTarget = e.target
            }
        };
        proto.destroy = function() {
            this.stop();
            this.el = null;
            this._tabbables = null;
            this._firstTabbableElement = null;
            this._lastTabbableElement = null;
            this._relatedTarget = null;
            this._handleOnFocus = null
        };
        module.exports = CircularTab
    }, {
        "./helpers/TabManager": 170,
        "./helpers/hideSiblingElements": 172,
        "./helpers/showSiblingElements": 176
    }],
    170: [function(require, module, exports) {
        "use strict";
        var focusableElements = require("./../maps/focusableElement");
        var TabManager = function() {
            this.focusableSelectors = focusableElements.join(",")
        };
        var proto = TabManager.prototype;
        proto.isFocusableElement = function(element, allowDisplayNone, tabIndex) {
            if (!allowDisplayNone && !this._isDisplayed(element, allowDisplayNone)) {
                return false
            }
            var nodeName = element.nodeName.toLowerCase();
            var focusableElement = focusableElements.indexOf(nodeName) > -1;
            if (nodeName === "a") {
                return true
            }
            if (focusableElement) {
                return !element.disabled
            }
            if (!element.contentEditable) {
                return true
            }
            tabIndex = tabIndex || parseFloat(element.getAttribute("tabindex"));
            return !isNaN(tabIndex)
        };
        proto.isTabbableElement = function(element, allowDisplayNone) {
            if (!allowDisplayNone && !this._isDisplayed(element, allowDisplayNone)) {
                return false
            }
            var tabIndex = element.getAttribute("tabindex");
            tabIndex = parseFloat(tabIndex);
            if (!isNaN(tabIndex)) {
                return tabIndex >= 0
            } else {
                return this.isFocusableElement(element, allowDisplayNone, tabIndex)
            }
        };
        proto._isDisplayed = function(el) {
            var clientBounding = el.getBoundingClientRect();
            return clientBounding.top > 0 && clientBounding.left > 0 && clientBounding.width > 0 && clientBounding.height > 0
        };
        proto.getTabbableElements = function(parentElement, allowDisplayNone) {
            var elements = parentElement.querySelectorAll(this.focusableSelectors);
            var l = elements.length;
            var tabbableElements = [];
            for (var i = 0; i < l; i++) {
                if (this.isTabbableElement(elements[i], allowDisplayNone)) {
                    tabbableElements.push(elements[i])
                }
            }
            return tabbableElements
        };
        proto.getFocusableElements = function(parentElement, allowDisplayNone) {
            var elements = parentElement.querySelectorAll(this.focusableSelectors);
            var l = elements.length;
            var focusableElements = [];
            for (var i = 0; i < l; i++) {
                if (this.isFocusableElement(elements[i], allowDisplayNone)) {
                    focusableElements.push(elements[i])
                }
            }
            return focusableElements
        };
        module.exports = new TabManager
    }, {
        "./../maps/focusableElement": 178
    }],
    171: [function(require, module, exports) {
        "use strict";
        var setAttributes = require("./setAttributes");
        var aria = require("./../maps/ariaMap");
        var TabManager = require("./TabManager");
        var PREFIX = "data-original-";
        var TAB_INDEX = "tabindex";
        var setOrigValue = function(el, prop) {
            var originalValue = el.getAttribute(PREFIX + prop);
            if (!originalValue) {
                originalValue = el.getAttribute(prop) || "";
                setAttributes(el, PREFIX + prop, originalValue)
            }
        };
        module.exports = function hide(el) {
            if (TabManager.isFocusableElement(el)) {
                setOrigValue(el, TAB_INDEX);
                setAttributes(el, TAB_INDEX, -1)
            } else {
                var tabbables = TabManager.getTabbableElements(el, true);
                var i = tabbables.length;
                while (i--) {
                    setOrigValue(tabbables[i], TAB_INDEX);
                    setAttributes(tabbables[i], TAB_INDEX, -1)
                }
            }
            setOrigValue(el, aria.HIDDEN);
            setAttributes(el, aria.HIDDEN, true)
        }
    }, {
        "./../maps/ariaMap": 177,
        "./TabManager": 170,
        "./setAttributes": 174
    }],
    172: [function(require, module, exports) {
        "use strict";
        var hide = require("./hide");
        module.exports = function hideSiblingElements(el, ancestor) {
            ancestor = ancestor || document.body;
            var previousNode = el;
            var nextNode = el;
            while (previousNode = previousNode.previousElementSibling) {
                hide(previousNode)
            }
            while (nextNode = nextNode.nextElementSibling) {
                hide(nextNode)
            }
            if (el.parentElement && el.parentElement !== ancestor) {
                hideSiblingElements(el.parentElement)
            }
        }
    }, {
        "./hide": 171
    }],
    173: [function(require, module, exports) {
        "use strict";
        var removeSingleAttribute = function(item, attribute) {
            if (typeof attribute !== "string") {
                return
            }
            var attributeArray = attribute.split(/\s+/);
            for (var i = 0; i < attributeArray.length; i++) {
                if (item.getAttribute(attributeArray[i])) {
                    item.removeAttribute(attributeArray[i])
                }
            }
        };
        var removeAttributes = function(items, attributes) {
            if (items.length) {
                for (var i = 0; i < items.length; i++) {
                    removeSingleAttribute(items[i], attributes)
                }
            } else {
                removeSingleAttribute(items, attributes)
            }
        };
        module.exports = removeAttributes
    }, {}],
    174: [function(require, module, exports) {
        "use strict";
        var addSingleAttribute = function(item, attribute, value) {
            if (item && item.nodeType === 1) {
                item.setAttribute(attribute, value)
            }
        };
        var setAttributes = function(items, attribute, value) {
            if (typeof value !== "string") {
                value = value.toString()
            }
            if (!items) {
                return
            }
            if (items.length) {
                for (var i = 0; i < items.length; i++) {
                    addSingleAttribute(items[i], attribute, value)
                }
            } else {
                addSingleAttribute(items, attribute, value)
            }
        };
        module.exports = setAttributes
    }, {}],
    175: [function(require, module, exports) {
        "use strict";
        var removeAttributes = require("./removeAttributes");
        var setAttributes = require("./setAttributes");
        var aria = require("./../maps/ariaMap");
        var PREFIX = "data-original-";
        var TAB_INDEX = "tabindex";
        var checkOrigValue = function(el, prop) {
            var originalValue = el.getAttribute(PREFIX + prop);
            if (typeof originalValue === "string") {
                if (originalValue.length) {
                    setAttributes(el, prop, originalValue)
                } else {
                    removeAttributes(el, prop)
                }
                removeAttributes(el, PREFIX + prop)
            }
        };
        module.exports = function show(el) {
            removeAttributes(el, TAB_INDEX + " " + aria.HIDDEN);
            checkOrigValue(el, TAB_INDEX);
            checkOrigValue(el, aria.HIDDEN);
            var tabbables = el.querySelectorAll("[" + PREFIX + TAB_INDEX + "]");
            var i = tabbables.length;
            while (i--) {
                checkOrigValue(tabbables[i], TAB_INDEX)
            }
        }
    }, {
        "./../maps/ariaMap": 177,
        "./removeAttributes": 173,
        "./setAttributes": 174
    }],
    176: [function(require, module, exports) {
        "use strict";
        var show = require("./show");
        module.exports = function showSiblingElements(el, ancestor) {
            ancestor = ancestor || document.body;
            var previousNode = el;
            var nextNode = el;
            while (previousNode = previousNode.previousElementSibling) {
                show(previousNode)
            }
            while (nextNode = nextNode.nextElementSibling) {
                show(nextNode)
            }
            if (el.parentElement && el.parentElement !== ancestor) {
                showSiblingElements(el.parentElement)
            }
        }
    }, {
        "./show": 175
    }],
    177: [function(require, module, exports) {
        "use strict";
        module.exports = {
            AUTOCOMPLETE: "aria-autocomplete",
            CHECKED: "aria-checked",
            DISABLED: "aria-disabled",
            EXPANDED: "aria-expanded",
            HASPOPUP: "aria-haspopup",
            HIDDEN: "aria-hidden",
            INVALID: "aria-invalid",
            LABEL: "aria-label",
            LEVEL: "aria-level",
            MULTILINE: "aria-multiline",
            MULTISELECTABLE: "aria-multiselectable",
            ORIENTATION: "aria-orientation",
            PRESSED: "aria-pressed",
            READONLY: "aria-readonly",
            REQUIRED: "aria-required",
            SELECTED: "aria-selected",
            SORT: "aria-sort",
            VALUEMAX: "aria-valuemax",
            VALUEMIN: "aria-valuemin",
            VALUENOW: "aria-valuenow",
            VALUETEXT: "aria-valuetext",
            ATOMIC: "aria-atomic",
            BUSY: "aria-busy",
            LIVE: "aria-live",
            RELEVANT: "aria-relevant",
            DROPEFFECT: "aria-dropeffect",
            GRABBED: "aria-grabbed",
            ACTIVEDESCENDANT: "aria-activedescendant",
            CONTROLS: "aria-controls",
            DESCRIBEDBY: "aria-describedby",
            FLOWTO: "aria-flowto",
            LABELLEDBY: "aria-labelledby",
            OWNS: "aria-owns",
            POSINSET: "aria-posinset",
            SETSIZE: "aria-setsize"
        }
    }, {}],
    178: [function(require, module, exports) {
        "use strict";
        module.exports = ["input", "select", "textarea", "button", "optgroup", "option", "menuitem", "fieldset", "object", "a[href]", "*[tabindex]", "*[contenteditable]"]
    }, {}],
    179: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.slice");
        require("@marcom/ac-polyfills/Element/prototype.classList");
        var classNameAdd = require("./className/add");
        module.exports = function add() {
            var tokens = Array.prototype.slice.call(arguments);
            var el = tokens.shift(tokens);
            var i;
            if (el.classList && el.classList.add) {
                el.classList.add.apply(el.classList, tokens);
                return
            }
            for (i = 0; i < tokens.length; i++) {
                classNameAdd(el, tokens[i])
            }
        }
    }, {
        "./className/add": 180,
        "@marcom/ac-polyfills/Array/prototype.slice": 390,
        "@marcom/ac-polyfills/Element/prototype.classList": 393
    }],
    180: [function(require, module, exports) {
        "use strict";
        var classNameContains = require("./contains");
        module.exports = function add(el, token) {
            if (!classNameContains(el, token)) {
                el.className += " " + token
            }
        }
    }, {
        "./contains": 181
    }],
    181: [function(require, module, exports) {
        "use strict";
        var getTokenRegExp = require("./getTokenRegExp");
        module.exports = function classNameAdd(el, token) {
            return getTokenRegExp(token).test(el.className)
        }
    }, {
        "./getTokenRegExp": 182
    }],
    182: [function(require, module, exports) {
        "use strict";
        module.exports = function getTokenRegExp(token) {
            return new RegExp("(\\s|^)" + token + "(\\s|$)")
        }
    }, {}],
    183: [function(require, module, exports) {
        "use strict";
        var classNameContains = require("./contains");
        var getTokenRegExp = require("./getTokenRegExp");
        module.exports = function remove(el, token) {
            if (classNameContains(el, token)) {
                el.className = el.className.replace(getTokenRegExp(token), "$1").trim()
            }
        }
    }, {
        "./contains": 181,
        "./getTokenRegExp": 182
    }],
    184: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.slice");
        require("@marcom/ac-polyfills/Element/prototype.classList");
        var classNameRemove = require("./className/remove");
        module.exports = function remove() {
            var tokens = Array.prototype.slice.call(arguments);
            var el = tokens.shift(tokens);
            var i;
            if (el.classList && el.classList.remove) {
                el.classList.remove.apply(el.classList, tokens);
                return
            }
            for (i = 0; i < tokens.length; i++) {
                classNameRemove(el, tokens[i])
            }
        }
    }, {
        "./className/remove": 183,
        "@marcom/ac-polyfills/Array/prototype.slice": 390,
        "@marcom/ac-polyfills/Element/prototype.classList": 393
    }],
    185: [function(require, module, exports) {
        arguments[4][11][0].apply(exports, arguments)
    }, {
        dup: 11
    }],
    186: [function(require, module, exports) {
        arguments[4][12][0].apply(exports, arguments)
    }, {
        dup: 12
    }],
    187: [function(require, module, exports) {
        arguments[4][15][0].apply(exports, arguments)
    }, {
        dup: 15
    }],
    188: [function(require, module, exports) {
        "use strict";
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var ac_addEventListener = require("@marcom/ac-dom-events/utils/addEventListener");
        var ac_removeEventListener = require("@marcom/ac-dom-events/utils/removeEventListener");
        var create = require("@marcom/ac-object/create");
        var KeyEvent = require("./internal/KeyEvent");
        var KEYDOWN = "keydown";
        var KEYUP = "keyup";

        function Keyboard(contextElement) {
            this._keysDown = {};
            this._DOMKeyDown = this._DOMKeyDown.bind(this);
            this._DOMKeyUp = this._DOMKeyUp.bind(this);
            this._context = contextElement || document;
            ac_addEventListener(this._context, KEYDOWN, this._DOMKeyDown, true);
            ac_addEventListener(this._context, KEYUP, this._DOMKeyUp, true);
            EventEmitterMicro.call(this)
        }
        var proto = Keyboard.prototype = create(EventEmitterMicro.prototype);
        proto.onDown = function(keyCode, callback) {
            return this.on(KEYDOWN + ":" + keyCode, callback)
        };
        proto.onceDown = function(keyCode, callback) {
            return this.once(KEYDOWN + ":" + keyCode, callback)
        };
        proto.offDown = function(keyCode, callback) {
            return this.off(KEYDOWN + ":" + keyCode, callback)
        };
        proto.onUp = function(keyCode, callback) {
            return this.on(KEYUP + ":" + keyCode, callback)
        };
        proto.onceUp = function(keyCode, callback) {
            return this.once(KEYUP + ":" + keyCode, callback)
        };
        proto.offUp = function(keyCode, callback) {
            return this.off(KEYUP + ":" + keyCode, callback)
        };
        proto.isDown = function(keyCode) {
            keyCode += "";
            return this._keysDown[keyCode] || false
        };
        proto.isUp = function(keyCode) {
            return !this.isDown(keyCode)
        };
        proto.destroy = function() {
            ac_removeEventListener(this._context, KEYDOWN, this._DOMKeyDown, true);
            ac_removeEventListener(this._context, KEYUP, this._DOMKeyUp, true);
            this._keysDown = null;
            this._context = null;
            EventEmitterMicro.prototype.destroy.call(this);
            return this
        };
        proto._DOMKeyDown = function(keyboardEvent) {
            var evt = this._normalizeKeyboardEvent(keyboardEvent);
            var keyCode = evt.keyCode += "";
            this._trackKeyDown(keyCode);
            this.trigger(KEYDOWN + ":" + keyCode, evt)
        };
        proto._DOMKeyUp = function(keyboardEvent) {
            var evt = this._normalizeKeyboardEvent(keyboardEvent);
            var keyCode = evt.keyCode += "";
            this._trackKeyUp(keyCode);
            this.trigger(KEYUP + ":" + keyCode, evt)
        };
        proto._normalizeKeyboardEvent = function(keyboardEvent) {
            return new KeyEvent(keyboardEvent)
        };
        proto._trackKeyUp = function(keyCode) {
            if (this._keysDown[keyCode]) {
                this._keysDown[keyCode] = false
            }
        };
        proto._trackKeyDown = function(keyCode) {
            if (!this._keysDown[keyCode]) {
                this._keysDown[keyCode] = true
            }
        };
        module.exports = Keyboard
    }, {
        "./internal/KeyEvent": 190,
        "@marcom/ac-dom-events/utils/addEventListener": 185,
        "@marcom/ac-dom-events/utils/removeEventListener": 186,
        "@marcom/ac-event-emitter-micro": 167,
        "@marcom/ac-object/create": 187
    }],
    189: [function(require, module, exports) {
        "use strict";
        var Keyboard = require("./Keyboard");
        module.exports = new Keyboard
    }, {
        "./Keyboard": 188
    }],
    190: [function(require, module, exports) {
        "use strict";
        var blackList = ["keyLocation"];

        function KeyEvent(originalEvt) {
            this.originalEvent = originalEvt;
            var prop;
            for (prop in originalEvt) {
                if (blackList.indexOf(prop) === -1 && typeof originalEvt[prop] !== "function") {
                    this[prop] = originalEvt[prop]
                }
            }
            this.location = this.originalEvent.location !== undefined ? this.originalEvent.location : this.originalEvent.keyLocation
        }
        KeyEvent.prototype = {
            preventDefault: function() {
                if (typeof this.originalEvent.preventDefault !== "function") {
                    this.originalEvent.returnValue = false;
                    return
                }
                return this.originalEvent.preventDefault()
            },
            stopPropagation: function() {
                return this.originalEvent.stopPropagation()
            }
        };
        module.exports = KeyEvent
    }, {}],
    191: [function(require, module, exports) {
        "use strict";
        module.exports = {
            BACKSPACE: 8,
            TAB: 9,
            ENTER: 13,
            SHIFT: 16,
            CONTROL: 17,
            ALT: 18,
            COMMAND: 91,
            CAPSLOCK: 20,
            ESCAPE: 27,
            PAGE_UP: 33,
            PAGE_DOWN: 34,
            END: 35,
            HOME: 36,
            ARROW_LEFT: 37,
            ARROW_UP: 38,
            ARROW_RIGHT: 39,
            ARROW_DOWN: 40,
            DELETE: 46,
            ZERO: 48,
            ONE: 49,
            TWO: 50,
            THREE: 51,
            FOUR: 52,
            FIVE: 53,
            SIX: 54,
            SEVEN: 55,
            EIGHT: 56,
            NINE: 57,
            A: 65,
            B: 66,
            C: 67,
            D: 68,
            E: 69,
            F: 70,
            G: 71,
            H: 72,
            I: 73,
            J: 74,
            K: 75,
            L: 76,
            M: 77,
            N: 78,
            O: 79,
            P: 80,
            Q: 81,
            R: 82,
            S: 83,
            T: 84,
            U: 85,
            V: 86,
            W: 87,
            X: 88,
            Y: 89,
            Z: 90,
            NUMPAD_ZERO: 96,
            NUMPAD_ONE: 97,
            NUMPAD_TWO: 98,
            NUMPAD_THREE: 99,
            NUMPAD_FOUR: 100,
            NUMPAD_FIVE: 101,
            NUMPAD_SIX: 102,
            NUMPAD_SEVEN: 103,
            NUMPAD_EIGHT: 104,
            NUMPAD_NINE: 105,
            NUMPAD_ASTERISK: 106,
            NUMPAD_PLUS: 107,
            NUMPAD_DASH: 109,
            NUMPAD_DOT: 110,
            NUMPAD_SLASH: 111,
            NUMPAD_EQUALS: 187,
            TICK: 192,
            LEFT_BRACKET: 219,
            RIGHT_BRACKET: 221,
            BACKSLASH: 220,
            SEMICOLON: 186,
            APOSTRAPHE: 222,
            APOSTROPHE: 222,
            SPACEBAR: 32,
            CLEAR: 12,
            COMMA: 188,
            DOT: 190,
            SLASH: 191
        }
    }, {}],
    192: [function(require, module, exports) {
        arguments[4][3][0].apply(exports, arguments)
    }, {
        "./shared/getEventType": 199,
        "./utils/addEventListener": 201,
        dup: 3
    }],
    193: [function(require, module, exports) {
        arguments[4][4][0].apply(exports, arguments)
    }, {
        "./shared/camelCasedEventTypes": 194,
        "./shared/prefixHelper": 195,
        "./shared/windowFallbackEventTypes": 196,
        "./utils/eventTypeAvailable": 197,
        dup: 4
    }],
    194: [function(require, module, exports) {
        arguments[4][5][0].apply(exports, arguments)
    }, {
        dup: 5
    }],
    195: [function(require, module, exports) {
        arguments[4][6][0].apply(exports, arguments)
    }, {
        dup: 6
    }],
    196: [function(require, module, exports) {
        arguments[4][7][0].apply(exports, arguments)
    }, {
        dup: 7
    }],
    197: [function(require, module, exports) {
        arguments[4][8][0].apply(exports, arguments)
    }, {
        dup: 8
    }],
    198: [function(require, module, exports) {
        arguments[4][9][0].apply(exports, arguments)
    }, {
        "./shared/getEventType": 199,
        "./utils/removeEventListener": 202,
        dup: 9
    }],
    199: [function(require, module, exports) {
        arguments[4][10][0].apply(exports, arguments)
    }, {
        "@marcom/ac-prefixer/getEventType": 193,
        dup: 10
    }],
    200: [function(require, module, exports) {
        "use strict";
        module.exports = function target(evt) {
            evt = evt || window.event;
            return typeof evt.target !== "undefined" ? evt.target : evt.srcElement
        }
    }, {}],
    201: [function(require, module, exports) {
        arguments[4][11][0].apply(exports, arguments)
    }, {
        dup: 11
    }],
    202: [function(require, module, exports) {
        arguments[4][12][0].apply(exports, arguments)
    }, {
        dup: 12
    }],
    203: [function(require, module, exports) {
        "use strict";
        module.exports = function getScrollX(el) {
            var offset;
            el = el || window;
            if (el === window) {
                offset = window.pageXOffset;
                if (!offset) {
                    el = document.documentElement || document.body.parentNode || document.body
                } else {
                    return offset
                }
            }
            return el.scrollLeft
        }
    }, {}],
    204: [function(require, module, exports) {
        "use strict";
        module.exports = function getScrollY(el) {
            var offset;
            el = el || window;
            if (el === window) {
                offset = window.pageYOffset;
                if (!offset) {
                    el = document.documentElement || document.body.parentNode || document.body
                } else {
                    return offset
                }
            }
            return el.scrollTop
        }
    }, {}],
    205: [function(require, module, exports) {
        arguments[4][24][0].apply(exports, arguments)
    }, {
        dup: 24
    }],
    206: [function(require, module, exports) {
        arguments[4][25][0].apply(exports, arguments)
    }, {
        dup: 25
    }],
    207: [function(require, module, exports) {
        arguments[4][27][0].apply(exports, arguments)
    }, {
        dup: 27
    }],
    208: [function(require, module, exports) {
        arguments[4][28][0].apply(exports, arguments)
    }, {
        dup: 28
    }],
    209: [function(require, module, exports) {
        arguments[4][29][0].apply(exports, arguments)
    }, {
        "../isNode": 212,
        dup: 29
    }],
    210: [function(require, module, exports) {
        arguments[4][30][0].apply(exports, arguments)
    }, {
        "../COMMENT_NODE": 205,
        "../DOCUMENT_FRAGMENT_NODE": 206,
        "../ELEMENT_NODE": 207,
        "../TEXT_NODE": 208,
        "./isNodeType": 209,
        dup: 30
    }],
    211: [function(require, module, exports) {
        arguments[4][32][0].apply(exports, arguments)
    }, {
        "./ELEMENT_NODE": 207,
        "./internal/isNodeType": 209,
        dup: 32
    }],
    212: [function(require, module, exports) {
        arguments[4][33][0].apply(exports, arguments)
    }, {
        dup: 33
    }],
    213: [function(require, module, exports) {
        arguments[4][34][0].apply(exports, arguments)
    }, {
        "./internal/validate": 210,
        dup: 34
    }],
    214: [function(require, module, exports) {
        arguments[4][15][0].apply(exports, arguments)
    }, {
        dup: 15
    }],
    215: [function(require, module, exports) {
        "use strict";
        var extend = require("./extend");
        module.exports = function defaults(defaultsObj, options) {
            if (typeof defaultsObj !== "object") {
                throw new TypeError("defaults: must provide a defaults object")
            }
            options = options || {};
            if (typeof options !== "object") {
                throw new TypeError("defaults: options must be a typeof object")
            }
            return extend({}, defaultsObj, options)
        }
    }, {
        "./extend": 216
    }],
    216: [function(require, module, exports) {
        arguments[4][16][0].apply(exports, arguments)
    }, {
        "@marcom/ac-polyfills/Array/prototype.forEach": 387,
        dup: 16
    }],
    217: [function(require, module, exports) {
        "use strict";
        module.exports = {
            Modal: require("./ac-modal-basic/Modal"),
            Renderer: require("./ac-modal-basic/Renderer"),
            classNames: require("./ac-modal-basic/classNames"),
            dataAttributes: require("./ac-modal-basic/dataAttributes")
        }
    }, {
        "./ac-modal-basic/Modal": 218,
        "./ac-modal-basic/Renderer": 219,
        "./ac-modal-basic/classNames": 220,
        "./ac-modal-basic/dataAttributes": 221
    }],
    218: [function(require, module, exports) {
        "use strict";
        var ac_DomEvents = {
            addEventListener: require("@marcom/ac-dom-events/addEventListener"),
            removeEventListener: require("@marcom/ac-dom-events/removeEventListener"),
            target: require("@marcom/ac-dom-events/target")
        };
        var ac_DomMetrics = {
            getScrollX: require("@marcom/ac-dom-metrics/getScrollX"),
            getScrollY: require("@marcom/ac-dom-metrics/getScrollY")
        };
        var ac_Object = {
            create: require("@marcom/ac-object/create"),
            defaults: require("@marcom/ac-object/defaults")
        };
        var ac_Keyboard = require("@marcom/ac-keyboard");
        var keys = require("@marcom/ac-keyboard/keyMap");
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var Renderer = require("./Renderer");
        var modalDefaults = {
            retainScrollPosition: false
        };

        function Modal(modalOptions, renderOptions) {
            EventEmitterMicro.call(this);
            this.options = ac_Object.defaults(modalDefaults, modalOptions);
            this.renderer = new Renderer(renderOptions);
            this.opened = false;
            this._keysToClose = [keys.ESCAPE];
            this._attachedKeysToClose = [];
            this.close = this.close.bind(this)
        }
        var proto = Modal.prototype = ac_Object.create(EventEmitterMicro.prototype);
        proto.open = function() {
            if (this.options.retainScrollPosition) {
                this._saveScrollPosition()
            }
            if (!this.opened) {
                this._attachEvents();
                this.trigger("willopen");
                this.renderer.open();
                this.opened = true;
                this.trigger("open")
            }
        };
        proto.close = function(evt) {
            var target;
            var closeAttribute;
            if (this.opened) {
                if (evt && evt.type === "click") {
                    target = ac_DomEvents.target(evt);
                    closeAttribute = this.renderer.options.dataAttributes.close;
                    if (!target.hasAttribute(closeAttribute)) {
                        return
                    }
                }
                this.trigger("willclose");
                this._removeEvents();
                this.renderer.close();
                if (this.options.retainScrollPosition) {
                    this._restoreScrollPosition()
                }
                this.opened = false;
                this.trigger("close")
            }
        };
        proto.render = function() {
            this.renderer.render()
        };
        proto.appendContent = function(el, target) {
            this.renderer.appendContent(el, target)
        };
        proto.removeContent = function(el) {
            this.renderer.removeContent(el)
        };
        proto.destroy = function() {
            this._removeEvents();
            this.renderer.destroy();
            for (var prop in this) {
                if (this.hasOwnProperty(prop)) {
                    this[prop] = null
                }
            }
        };
        proto.addKeyToClose = function(key) {
            var index = this._keysToClose.indexOf(key);
            if (index === -1) {
                this._keysToClose.push(key);
                this._bindKeyToClose(key)
            }
        };
        proto.removeKeyToClose = function(key) {
            var index = this._keysToClose.indexOf(key);
            if (index !== -1) {
                this._keysToClose.splice(index, 1)
            }
            this._releaseKeyToClose(key)
        };
        proto._bindKeyToClose = function(key) {
            var index = this._attachedKeysToClose.indexOf(key);
            if (index === -1) {
                ac_Keyboard.onUp(key, this.close);
                this._attachedKeysToClose.push(key)
            }
        };
        proto._releaseKeyToClose = function(key) {
            var index = this._attachedKeysToClose.indexOf(key);
            if (index !== -1) {
                ac_Keyboard.offUp(key, this.close);
                this._attachedKeysToClose.splice(index, 1)
            }
        };
        proto._removeEvents = function() {
            if (this.renderer.modalElement) {
                ac_DomEvents.removeEventListener(this.renderer.modalElement, "click", this.close)
            }
            this._keysToClose.forEach(this._releaseKeyToClose, this)
        };
        proto._attachEvents = function() {
            if (this.renderer.modalElement) {
                ac_DomEvents.addEventListener(this.renderer.modalElement, "click", this.close)
            }
            this._keysToClose.forEach(this._bindKeyToClose, this)
        };
        proto._restoreScrollPosition = function() {
            window.scrollTo(this._scrollX || 0, this._scrollY || 0)
        };
        proto._saveScrollPosition = function() {
            this._scrollX = ac_DomMetrics.getScrollX();
            this._scrollY = ac_DomMetrics.getScrollY()
        };
        module.exports = Modal
    }, {
        "./Renderer": 219,
        "@marcom/ac-dom-events/addEventListener": 192,
        "@marcom/ac-dom-events/removeEventListener": 198,
        "@marcom/ac-dom-events/target": 200,
        "@marcom/ac-dom-metrics/getScrollX": 203,
        "@marcom/ac-dom-metrics/getScrollY": 204,
        "@marcom/ac-event-emitter-micro": 167,
        "@marcom/ac-keyboard": 189,
        "@marcom/ac-keyboard/keyMap": 191,
        "@marcom/ac-object/create": 214,
        "@marcom/ac-object/defaults": 215
    }],
    219: [function(require, module, exports) {
        "use strict";
        var ac_Classlist = {
            add: require("@marcom/ac-classlist/add"),
            remove: require("@marcom/ac-classlist/remove")
        };
        var ac_Object = {
            defaults: require("@marcom/ac-object/defaults")
        };
        var ac_DomNodes = {
            remove: require("@marcom/ac-dom-nodes/remove"),
            isElement: require("@marcom/ac-dom-nodes/isElement")
        };
        var modalClassNames = require("./classNames");
        var modalDataAttributes = require("./dataAttributes");
        var defaults = {
            modalElement: null,
            contentElement: null,
            closeButton: null,
            classNames: modalClassNames,
            dataAttributes: modalDataAttributes
        };
        var Renderer = function(options) {
            options = options || {};
            this.options = ac_Object.defaults(defaults, options);
            this.options.classNames = ac_Object.defaults(defaults.classNames, options.classNames);
            this.options.dataAttributes = ac_Object.defaults(defaults.dataAttributes, options.dataAttributes);
            this.modalElement = this.options.modalElement;
            this.contentElement = this.options.contentElement;
            this.closeButton = this.options.closeButton
        };
        var proto = Renderer.prototype;
        proto.render = function() {
            if (!ac_DomNodes.isElement(this.modalElement)) {
                this.modalElement = this.renderModalElement(this.options.classNames.modalElement)
            }
            if (!ac_DomNodes.isElement(this.contentElement)) {
                this.contentElement = this.renderContentElement(this.options.classNames.contentElement)
            }
            if (this.closeButton !== false) {
                if (!ac_DomNodes.isElement(this.closeButton)) {
                    this.closeButton = this.renderCloseButton(this.options.classNames.closeButton)
                }
                this.modalElement.appendChild(this.closeButton)
            }
            this.modalElement.appendChild(this.contentElement);
            document.body.appendChild(this.modalElement);
            return this.modalElement
        };
        proto.renderCloseButton = function(classNames) {
            var closeButton;
            classNames = classNames || this.options.classNames.closeButton;
            closeButton = this._renderElement("button", classNames);
            closeButton.setAttribute(this.options.dataAttributes.close, "");
            return closeButton
        };
        proto.renderModalElement = function(classNames) {
            classNames = classNames || this.options.classNames.modalElement;
            return this._renderElement("div", classNames)
        };
        proto.renderContentElement = function(classNames) {
            classNames = classNames || this.options.classNames.contentElement;
            return this._renderElement("div", classNames)
        };
        proto.appendContent = function(el, target) {
            if (!ac_DomNodes.isElement(el)) {
                return
            }
            if (arguments[1] === undefined) {
                this.contentElement.appendChild(el)
            } else if (ac_DomNodes.isElement(target)) {
                target.appendChild(el)
            }
        };
        proto.removeContent = function(el) {
            if (el) {
                if (this.modalElement.contains(el)) {
                    ac_DomNodes.remove(el)
                }
            } else {
                this._emptyContent()
            }
        };
        proto.open = function() {
            var docElArgs = [document.documentElement].concat(this.options.classNames.documentElement);
            var modalElArgs = [this.modalElement].concat(this.options.classNames.modalOpen);
            ac_Classlist.add.apply(null, docElArgs);
            ac_Classlist.add.apply(null, modalElArgs)
        };
        proto.close = function() {
            var docElArgs = [document.documentElement].concat(this.options.classNames.documentElement);
            var modalElArgs = [this.modalElement].concat(this.options.classNames.modalOpen);
            ac_Classlist.remove.apply(null, docElArgs);
            ac_Classlist.remove.apply(null, modalElArgs)
        };
        proto.destroy = function() {
            var docElArgs = [document.documentElement].concat(this.options.classNames.documentElement);
            if (this.modalElement && document.body.contains(this.modalElement)) {
                this.close();
                document.body.removeChild(this.modalElement)
            }
            ac_Classlist.remove.apply(null, docElArgs);
            for (var prop in this) {
                if (this.hasOwnProperty(prop)) {
                    this[prop] = null
                }
            }
        };
        proto._renderElement = function(type, classNames) {
            var el = document.createElement(type);
            var args = [el];
            if (classNames) {
                args = args.concat(classNames)
            }
            ac_Classlist.add.apply(null, args);
            return el
        };
        proto._emptyContent = function() {
            this.contentElement.innerHTML = ""
        };
        module.exports = Renderer
    }, {
        "./classNames": 220,
        "./dataAttributes": 221,
        "@marcom/ac-classlist/add": 179,
        "@marcom/ac-classlist/remove": 184,
        "@marcom/ac-dom-nodes/isElement": 211,
        "@marcom/ac-dom-nodes/remove": 213,
        "@marcom/ac-object/defaults": 215
    }],
    220: [function(require, module, exports) {
        "use strict";
        module.exports = {
            modalElement: "modal",
            modalOpen: "modal-open",
            documentElement: "has-modal",
            contentElement: "modal-content",
            closeButton: "modal-close"
        }
    }, {}],
    221: [function(require, module, exports) {
        "use strict";
        module.exports = {
            close: "data-modal-close"
        }
    }, {}],
    222: [function(require, module, exports) {
        "use strict";
        module.exports = {
            Modal: require("./ac-modal/Modal"),
            createStandardModal: require("./ac-modal/factory/createStandardModal"),
            createFullViewportModal: require("./ac-modal/factory/createFullViewportModal")
        }
    }, {
        "./ac-modal/Modal": 223,
        "./ac-modal/factory/createFullViewportModal": 224,
        "./ac-modal/factory/createStandardModal": 225
    }],
    223: [function(require, module, exports) {
        "use strict";
        var ac_ModalBasic = require("@marcom/ac-modal-basic").Modal;
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var CircularTab = require("@marcom/ac-accessibility/CircularTab");

        function Modal(options) {
            EventEmitterMicro.call(this);
            this.options = options || {};
            this._modal = new ac_ModalBasic(options, this.options.renderer);
            this.opened = false;
            this._render();
            this.closeButton = this._modal.renderer.closeButton;
            this.modalElement = this._modal.renderer.modalElement;
            this.contentElement = this._modal.renderer.contentElement;
            this.modalElement.setAttribute("role", "dialog");
            this.closeButton.setAttribute("aria-label", "Close");
            this._circularTab = new CircularTab(this.modalElement);
            this._onWillOpen = this._onWillOpen.bind(this);
            this._onOpen = this._onOpen.bind(this);
            this._onWillClose = this._onWillClose.bind(this);
            this._onClose = this._onClose.bind(this);
            this._bindEvents()
        }
        var proto = Modal.prototype = Object.create(EventEmitterMicro.prototype);
        proto.open = function() {
            this._modal.open();
            this.opened = this._modal.opened
        };
        proto.close = function() {
            this._modal.close()
        };
        proto.appendContent = function(el) {
            this._modal.appendContent(el)
        };
        proto.removeContent = function(el) {
            this._modal.removeContent(el)
        };
        proto.destroy = function() {
            this._releaseEvents();
            this._modal.destroy();
            this._removeModalFocus();
            this._circularTab.destroy();
            this._focusObj = null;
            for (var prop in this) {
                if (this.hasOwnProperty(prop)) {
                    this[prop] = null
                }
            }
        };
        proto.addKeyToClose = function(key) {
            this._modal.addKeyToClose(key)
        };
        proto.removeKeyToClose = function(key) {
            this._modal.removeKeyToClose(key)
        };
        proto._render = function() {
            this._modal.render();
            this._modal.renderer.modalElement.setAttribute("aria-hidden", "true")
        };
        proto._bindEvents = function() {
            this._modal.on("willopen", this._onWillOpen);
            this._modal.on("open", this._onOpen);
            this._modal.on("willclose", this._onWillClose);
            this._modal.on("close", this._onClose)
        };
        proto._releaseEvents = function() {
            this._modal.off("willopen", this._onWillOpen);
            this._modal.off("open", this._onOpen);
            this._modal.off("willclose", this._onWillClose);
            this._modal.off("close", this._onClose)
        };
        proto._onWillOpen = function() {
            this.trigger("willopen")
        };
        proto._onOpen = function() {
            this.opened = this._modal.opened;
            this._giveModalFocus();
            this.trigger("open")
        };
        proto._onWillClose = function() {
            this.trigger("willclose");
            this._removeModalFocus()
        };
        proto._onClose = function() {
            this.opened = this._modal.opened;
            this.trigger("close")
        };
        proto._giveModalFocus = function() {
            this.modalElement.setAttribute("aria-hidden", "false");
            this._activeElement = document.activeElement;
            this.closeButton.focus();
            this._circularTab.start()
        };
        proto._removeModalFocus = function() {
            this._circularTab.stop();
            this.modalElement.setAttribute("aria-hidden", "true");
            if (this._activeElement) {
                this._activeElement.focus();
                this._activeElement = null
            }
        };
        module.exports = Modal
    }, {
        "@marcom/ac-accessibility/CircularTab": 169,
        "@marcom/ac-event-emitter-micro": 167,
        "@marcom/ac-modal-basic": 217
    }],
    224: [function(require, module, exports) {
        "use strict";
        var Modal = require("../Modal");
        var modalBasicClassNames = require("@marcom/ac-modal-basic").classNames;
        var options = {
            retainScrollPosition: true,
            renderer: {
                classNames: {
                    documentElement: [modalBasicClassNames.documentElement].concat("has-modal-full-viewport"),
                    modalElement: [modalBasicClassNames.modalElement].concat("modal-full-viewport")
                }
            }
        };

        function createFullViewportModal(contentElement) {
            var modal = new Modal(options);
            if (contentElement) {
                modal.appendContent(contentElement)
            }
            return modal
        }
        module.exports = createFullViewportModal
    }, {
        "../Modal": 223,
        "@marcom/ac-modal-basic": 217
    }],
    225: [function(require, module, exports) {
        "use strict";
        var Modal = require("../Modal");
        var modalBasicClassNames = require("@marcom/ac-modal-basic").classNames;
        var modalBasicDataAttributes = require("@marcom/ac-modal-basic").dataAttributes;
        var ac_Classlist = {
            add: require("@marcom/ac-classlist/add")
        };
        var options = {
            renderer: {
                classNames: {
                    documentElement: [modalBasicClassNames.documentElement].concat("has-modal-standard"),
                    modalElement: [modalBasicClassNames.modalElement].concat("modal-standard")
                }
            }
        };

        function createStandardModal(contentElement) {
            var modal = new Modal(options);
            if (contentElement) {
                modal.appendContent(contentElement)
            }
            var contentTable = document.createElement("div");
            var contentCell = document.createElement("div");
            var contentWrapper = document.createElement("div");
            var contentPadding = document.createElement("div");
            ac_Classlist.add(contentTable, "content-table");
            ac_Classlist.add(contentCell, "content-cell");
            ac_Classlist.add(contentWrapper, "content-wrapper");
            ac_Classlist.add(contentPadding, "content-padding", "large-8", "medium-10");
            modal.modalElement.setAttribute(modalBasicDataAttributes.close, "");
            contentWrapper.setAttribute(modalBasicDataAttributes.close, "");
            contentCell.setAttribute(modalBasicDataAttributes.close, "");
            contentTable.appendChild(contentCell);
            contentCell.appendChild(contentWrapper);
            contentWrapper.appendChild(contentPadding);
            modal.modalElement.appendChild(contentTable);
            contentPadding.appendChild(modal.contentElement);
            contentPadding.appendChild(modal.closeButton);
            return modal
        }
        module.exports = createStandardModal
    }, {
        "../Modal": 223,
        "@marcom/ac-classlist/add": 179,
        "@marcom/ac-modal-basic": 217
    }],
    226: [function(require, module, exports) {
        module.exports.EventEmitter = require("./ac-event-emitter/EventEmitter")
    }, {
        "./ac-event-emitter/EventEmitter": 227
    }],
    227: [function(require, module, exports) {
        "use strict";
        var propagationName = "EventEmitter:propagation";
        var EventEmitter = function(context) {
            if (context) {
                this.context = context
            }
        };
        var proto = EventEmitter.prototype;
        var getEvents = function() {
            if (!this.hasOwnProperty("_events") && typeof this._events !== "object") {
                this._events = {}
            }
            return this._events
        };
        var parseEvents = function(args, register) {
            var event = args[0];
            var callback = args[1];
            var context = args[2];
            if (typeof event !== "string" && typeof event !== "object" || event === null || Array.isArray(event)) {
                throw new TypeError("Expecting event name to be a string or object.")
            }
            if (typeof event === "string" && !callback) {
                throw new Error("Expecting a callback function to be provided.")
            }
            if (callback && typeof callback !== "function") {
                if (typeof event === "object" && typeof callback === "object") {
                    context = callback
                } else {
                    throw new TypeError("Expecting callback to be a function.")
                }
            }
            if (typeof event === "object") {
                for (var evt in event) {
                    register.call(this, evt, event[evt], context)
                }
            }
            if (typeof event === "string") {
                event = event.split(" ");
                event.forEach(function(evt) {
                    register.call(this, evt, callback, context)
                }, this)
            }
        };
        var each = function(event, callback) {
            var eventsArray;
            var i;
            var length;
            eventsArray = getEvents.call(this)[event];
            if (!eventsArray || eventsArray.length === 0) {
                return
            }
            eventsArray = eventsArray.slice();
            this._stoppedImmediatePropagation = false;
            for (i = 0, length = eventsArray.length; i < length; i++) {
                if (this._stoppedImmediatePropagation || callback(eventsArray[i], i)) {
                    break
                }
            }
        };
        var removeSpecificCallback = function(events, event, callback) {
            var i = -1;
            each.call(this, event, function(callbackObject, index) {
                if (callbackObject.callback === callback) {
                    i = index;
                    return true
                }
            });
            if (i === -1) {
                return
            }
            events[event].splice(i, 1)
        };
        proto.on = function() {
            var events = getEvents.call(this);
            parseEvents.call(this, arguments, function(event, callback, context) {
                events[event] = events[event] || (events[event] = []);
                events[event].push({
                    callback: callback,
                    context: context
                })
            });
            return this
        };
        proto.once = function() {
            parseEvents.call(this, arguments, function(event, callback, context) {
                var wrapper = function(data) {
                    callback.call(context || this, data);
                    this.off(event, wrapper)
                };
                this.on(event, wrapper, this)
            });
            return this
        };
        proto.off = function(event, callback) {
            var events = getEvents.call(this);
            if (arguments.length === 0) {
                this._events = {}
            } else if (!event || typeof event !== "string" && typeof event !== "object" || Array.isArray(event)) {
                throw new TypeError("Expecting event name to be a string or object.")
            }
            if (typeof event === "object") {
                for (var e in event) {
                    removeSpecificCallback.call(this, events, e, event[e])
                }
            }
            if (typeof event === "string") {
                var split = event.split(" ");
                if (split.length === 1) {
                    if (callback) {
                        removeSpecificCallback.call(this, events, event, callback)
                    } else {
                        events[event] = []
                    }
                } else {
                    split.forEach(function(event) {
                        events[event] = []
                    })
                }
            }
            return this
        };
        proto.trigger = function(event, data, doNotPropagate) {
            if (!event) {
                throw new Error("trigger method requires an event name")
            }
            if (typeof event !== "string") {
                throw new TypeError("Expecting event names to be a string.")
            }
            if (doNotPropagate && typeof doNotPropagate !== "boolean") {
                throw new TypeError("Expecting doNotPropagate to be a boolean.")
            }
            event = event.split(" ");
            event.forEach(function(evt) {
                each.call(this, evt, function(callbackObject) {
                    callbackObject.callback.call(callbackObject.context || this.context || this, data)
                }.bind(this));
                if (!doNotPropagate) {
                    each.call(this, propagationName, function(propagation) {
                        var eventName = evt;
                        if (propagation.prefix) {
                            eventName = propagation.prefix + eventName
                        }
                        propagation.emitter.trigger(eventName, data)
                    })
                }
            }, this);
            return this
        };
        proto.propagateTo = function(eventEmitter, prefix) {
            var events = getEvents.call(this);
            if (!events[propagationName]) {
                this._events[propagationName] = []
            }
            events[propagationName].push({
                emitter: eventEmitter,
                prefix: prefix
            })
        };
        proto.stopPropagatingTo = function(eventEmitter) {
            var events = getEvents.call(this);
            if (!eventEmitter) {
                events[propagationName] = [];
                return
            }
            var propagationTargets = events[propagationName];
            var length = propagationTargets.length;
            var i;
            for (i = 0; i < length; i++) {
                if (propagationTargets[i].emitter === eventEmitter) {
                    propagationTargets.splice(i, 1);
                    break
                }
            }
        };
        proto.stopImmediatePropagation = function() {
            this._stoppedImmediatePropagation = true
        };
        proto.has = function(evt, callback, context) {
            var events = getEvents.call(this);
            var eventsArray = events[evt];
            if (arguments.length === 0) {
                return Object.keys(events)
            }
            if (!eventsArray) {
                return false
            }
            if (!callback) {
                return eventsArray.length > 0 ? true : false
            }
            for (var i = 0, length = eventsArray.length; i < length; i++) {
                var callbackContainer = eventsArray[i];
                if (context && callback && callbackContainer.context === context && callbackContainer.callback === callback) {
                    return true
                } else if (callback && !context && callbackContainer.callback === callback) {
                    return true
                }
            }
            return false
        };
        module.exports = EventEmitter
    }, {}],
    228: [function(require, module, exports) {
        "use strict";
        module.exports = {
            DOMEmitter: require("./ac-dom-emitter/DOMEmitter")
        }
    }, {
        "./ac-dom-emitter/DOMEmitter": 229
    }],
    229: [function(require, module, exports) {
        "use strict";
        var proto;
        var EventEmitter = require("ac-event-emitter").EventEmitter,
            DOMEmitterEvent = require("./DOMEmitterEvent"),
            ac_dom_events = {
                addEventListener: require("@marcom/ac-dom-events/addEventListener"),
                removeEventListener: require("@marcom/ac-dom-events/removeEventListener"),
                dispatchEvent: require("@marcom/ac-dom-events/dispatchEvent")
            },
            ac_dom_traversal = {
                querySelectorAll: require("@marcom/ac-dom-traversal/querySelectorAll"),
                matchesSelector: require("@marcom/ac-dom-traversal/matchesSelector")
            };
        var internalEventPrefix = "dom-emitter";

        function DOMEmitter(el) {
            if (el === null) {
                return
            }
            this.el = el;
            this._bindings = {};
            this._delegateFuncs = {};
            this._eventEmitter = new EventEmitter
        }
        proto = DOMEmitter.prototype;
        proto.on = function() {
            this._normalizeArgumentsAndCall(Array.prototype.slice.call(arguments, 0), this._on);
            return this
        };
        proto.once = function() {
            this._normalizeArgumentsAndCall(Array.prototype.slice.call(arguments, 0), this._once);
            return this
        };
        proto.off = function() {
            this._normalizeArgumentsAndCall(Array.prototype.slice.call(arguments, 0), this._off);
            return this
        };
        proto.has = function(evt, callbackOrDelegateQuery, callbackOrContext, context) {
            var delegateQuery, callback;
            if (typeof callbackOrDelegateQuery === "string") {
                delegateQuery = callbackOrDelegateQuery;
                callback = callbackOrContext
            } else {
                callback = callbackOrDelegateQuery;
                context = callbackOrContext
            }
            if (delegateQuery) {
                var matchIdx = this._getDelegateFuncBindingIdx(evt, delegateQuery, callback, context, true);
                if (matchIdx > -1) {
                    return true
                }
                return false
            }
            if (this._eventEmitter && this._eventEmitter.has.apply(this._eventEmitter, arguments)) {
                return true
            }
            return false
        };
        proto.trigger = function(evts, dataOrDelegateQuery, doNotPropogateOrData, doNotPropogate) {
            evts = this._parseEventNames(evts);
            evts = this._cleanStringData(evts);
            var delegateQuery, data, i, len = evts.length;
            if (typeof dataOrDelegateQuery === "string") {
                delegateQuery = this._cleanStringData(dataOrDelegateQuery);
                data = doNotPropogateOrData
            } else {
                data = dataOrDelegateQuery;
                doNotPropogate = doNotPropogateOrData
            }
            for (i = 0; i < len; i++) {
                this._triggerDOMEvents(evts[i], data, delegateQuery)
            }
            return this
        };
        proto.emitterTrigger = function(evts, data, doNotPropogate) {
            if (!this._eventEmitter) {
                return this
            }
            evts = this._parseEventNames(evts);
            evts = this._cleanStringData(evts);
            data = new DOMEmitterEvent(data, this);
            var i, len = evts.length;
            for (i = 0; i < len; i++) {
                this._eventEmitter.trigger(evts[i], data, doNotPropogate)
            }
            return this
        };
        proto.propagateTo = function(eventEmitter, prefix) {
            this._eventEmitter.propagateTo(eventEmitter, prefix);
            return this
        };
        proto.stopPropagatingTo = function(eventEmitter) {
            this._eventEmitter.stopPropagatingTo(eventEmitter);
            return this
        };
        proto.stopImmediatePropagation = function() {
            this._eventEmitter.stopImmediatePropagation();
            return this
        };
        proto.destroy = function() {
            this._triggerInternalEvent("willdestroy");
            this.off();
            var i;
            for (i in this) {
                if (this.hasOwnProperty(i)) {
                    this[i] = null
                }
            }
        };
        proto._parseEventNames = function(evt) {
            if (!evt) {
                return [evt]
            }
            return evt.split(" ")
        };
        proto._onListenerEvent = function(evtName, e) {
            var data = new DOMEmitterEvent(e, this);
            this._eventEmitter.trigger(evtName, data, false)
        };
        proto._setListener = function(evt) {
            this._bindings[evt] = this._onListenerEvent.bind(this, evt);
            ac_dom_events.addEventListener(this.el, evt, this._bindings[evt])
        };
        proto._removeListener = function(evt) {
            ac_dom_events.removeEventListener(this.el, evt, this._bindings[evt]);
            this._bindings[evt] = null
        };
        proto._triggerInternalEvent = function(evt, data) {
            this.emitterTrigger(internalEventPrefix + ":" + evt, data)
        };
        proto._normalizeArgumentsAndCall = function(argsArr, func) {
            var binding = {};
            if (argsArr.length === 0) {
                func.call(this, binding);
                return
            }
            if (typeof argsArr[0] === "string" || argsArr[0] === null) {
                argsArr = this._cleanStringData(argsArr);
                binding.events = argsArr[0];
                if (typeof argsArr[1] === "string") {
                    binding.delegateQuery = argsArr[1];
                    binding.callback = argsArr[2];
                    binding.context = argsArr[3]
                } else {
                    binding.callback = argsArr[1];
                    binding.context = argsArr[2]
                }
                func.call(this, binding);
                return
            }
            var i, splits, splitChar = ":",
                obj = argsArr[0];
            for (i in obj) {
                if (obj.hasOwnProperty(i)) {
                    binding = {};
                    splits = this._cleanStringData(i.split(splitChar));
                    binding.events = splits[0];
                    binding.delegateQuery = splits[1];
                    binding.callback = obj[i];
                    binding.context = argsArr[1];
                    func.call(this, binding)
                }
            }
        };
        proto._registerDelegateFunc = function(evt, delegateQuery, callback, unboundCallback, context) {
            var delegateFunc = this._delegateFunc.bind(this, evt, delegateQuery, callback, context);
            this._delegateFuncs[delegateQuery] = this._delegateFuncs[delegateQuery] || {};
            this._delegateFuncs[delegateQuery][evt] = this._delegateFuncs[delegateQuery][evt] || [];
            this._delegateFuncs[delegateQuery][evt].push({
                func: unboundCallback,
                context: context,
                delegateFunc: delegateFunc
            });
            return delegateFunc
        };
        proto._cleanStringData = function(arr) {
            var isString = false;
            if (typeof arr === "string") {
                arr = [arr];
                isString = true
            }
            var result = [],
                i, val, valLen, spaceIdx, len = arr.length;
            for (i = 0; i < len; i++) {
                val = arr[i];
                if (typeof val === "string") {
                    if (val === "" || val === " ") {
                        continue
                    }
                    valLen = val.length;
                    while (val[0] === " ") {
                        val = val.slice(1, valLen);
                        valLen--
                    }
                    while (val[valLen - 1] === " ") {
                        val = val.slice(0, valLen - 1);
                        valLen--
                    }
                }
                result.push(val)
            }
            if (isString) {
                return result[0]
            }
            return result
        };
        proto._unregisterDelegateFunc = function(evt, delegateQuery, unboundCallback, context) {
            if (!this._delegateFuncs[delegateQuery] || !this._delegateFuncs[delegateQuery][evt]) {
                return
            }
            var matchIdx = this._getDelegateFuncBindingIdx(evt, delegateQuery, unboundCallback, context),
                delegateFunc;
            if (matchIdx > -1) {
                delegateFunc = this._delegateFuncs[delegateQuery][evt][matchIdx].delegateFunc;
                this._delegateFuncs[delegateQuery][evt].splice(matchIdx, 1);
                if (this._delegateFuncs[delegateQuery][evt].length === 0) {
                    this._delegateFuncs[delegateQuery][evt] = null
                }
            }
            return delegateFunc
        };
        proto._unregisterDelegateFuncs = function(evt, delegateQuery) {
            if (!this._delegateFuncs[delegateQuery]) {
                return
            }
            if (evt !== null && !this._delegateFuncs[delegateQuery][evt]) {
                return
            }
            if (evt === null) {
                var i;
                for (i in this._delegateFuncs[delegateQuery]) {
                    if (this._delegateFuncs[delegateQuery].hasOwnProperty(i)) {
                        this._unbindDelegateFunc(i, delegateQuery)
                    }
                }
                return
            }
            this._unbindDelegateFunc(evt, delegateQuery)
        };
        proto._unbindDelegateFunc = function(evt, delegateQuery) {
            var binding, preRemoveLen, i = 0;
            while (this._delegateFuncs[delegateQuery][evt] && this._delegateFuncs[delegateQuery][evt][i]) {
                binding = this._delegateFuncs[delegateQuery][evt][i];
                preRemoveLen = this._delegateFuncs[delegateQuery][evt][i].length;
                this._off({
                    events: evt,
                    delegateQuery: delegateQuery,
                    callback: binding.func,
                    context: binding.context
                });
                if (this._delegateFuncs[delegateQuery][evt] && preRemoveLen === this._delegateFuncs[delegateQuery][evt].length) {
                    i++
                }
            }
            binding = preRemoveLen = null
        };
        proto._unregisterDelegateFuncsByEvent = function(evt) {
            var i;
            for (i in this._delegateFuncs) {
                if (this._delegateFuncs.hasOwnProperty(i)) {
                    this._unregisterDelegateFuncs(evt, i)
                }
            }
        };
        proto._delegateFunc = function(evt, delegateQuery, callback, context, e) {
            if (this._targetHasDelegateAncestor(e.target, delegateQuery)) {
                var args = Array.prototype.slice.call(arguments, 0),
                    unboundArgs = args.slice(4, args.length);
                context = context || window;
                if (typeof e.detail === "object") {
                    unboundArgs[0] = e.detail
                }
                callback.apply(context, unboundArgs)
            }
        };
        proto._targetHasDelegateAncestor = function(target, delegateQuery) {
            var ancestor = target;
            while (ancestor && ancestor !== this.el && ancestor !== document.documentElement) {
                if (ac_dom_traversal.matchesSelector(ancestor, delegateQuery)) {
                    return true
                }
                ancestor = ancestor.parentNode
            }
            return false
        };
        proto._on = function(binding) {
            var evts = binding.events,
                callback = binding.callback,
                delegateQuery = binding.delegateQuery,
                context = binding.context,
                unboundCallback = binding.unboundCallback || callback;
            evts = this._parseEventNames(evts);
            evts.forEach(function(callback, unboundCallback, context, delegateQuery, evt) {
                if (!this.has(evt)) {
                    this._setListener(evt)
                }
                if (typeof delegateQuery === "string") {
                    callback = this._registerDelegateFunc(evt, delegateQuery, callback, unboundCallback, context)
                }
                this._triggerInternalEvent("willon", {
                    evt: evt,
                    callback: callback,
                    context: context,
                    delegateQuery: delegateQuery
                });
                this._eventEmitter.on(evt, callback, context);
                this._triggerInternalEvent("didon", {
                    evt: evt,
                    callback: callback,
                    context: context,
                    delegateQuery: delegateQuery
                })
            }.bind(this, callback, unboundCallback, context, delegateQuery));
            evts = callback = unboundCallback = delegateQuery = context = null
        };
        proto._off = function(binding) {
            var evts = binding.events,
                callback = binding.callback,
                delegateQuery = binding.delegateQuery,
                context = binding.context,
                unboundCallback = binding.unboundCallback || callback;
            if (typeof evts === "undefined") {
                this._eventEmitter.off();
                var i;
                for (i in this._bindings) {
                    if (this._bindings.hasOwnProperty(i)) {
                        this._removeListener(i)
                    }
                }
                for (i in this._delegateFuncs) {
                    if (this._delegateFuncs.hasOwnProperty(i)) {
                        this._delegateFuncs[i] = null
                    }
                }
                return
            }
            evts = this._parseEventNames(evts);
            evts.forEach(function(callback, unboundCallback, context, delegateQuery, evt) {
                if (typeof delegateQuery === "string" && typeof unboundCallback === "function") {
                    callback = this._unregisterDelegateFunc(evt, delegateQuery, unboundCallback, context);
                    if (!callback) {
                        return
                    }
                }
                if (typeof delegateQuery === "string" && typeof callback === "undefined") {
                    this._unregisterDelegateFuncs(evt, delegateQuery);
                    return
                }
                if (typeof evt === "string" && typeof callback === "undefined") {
                    this._unregisterDelegateFuncsByEvent(evt);
                    if (typeof delegateQuery === "string") {
                        return
                    }
                }
                this._triggerInternalEvent("willoff", {
                    evt: evt,
                    callback: callback,
                    context: context,
                    delegateQuery: delegateQuery
                });
                this._eventEmitter.off(evt, callback, context);
                this._triggerInternalEvent("didoff", {
                    evt: evt,
                    callback: callback,
                    context: context,
                    delegateQuery: delegateQuery
                });
                if (!this.has(evt)) {
                    this._removeListener(evt)
                }
            }.bind(this, callback, unboundCallback, context, delegateQuery));
            evts = callback = unboundCallback = delegateQuery = context = null
        };
        proto._once = function(binding) {
            var evts = binding.events,
                callback = binding.callback,
                delegateQuery = binding.delegateQuery,
                context = binding.context;
            evts = this._parseEventNames(evts);
            evts.forEach(function(callback, context, delegateQuery, evt) {
                if (typeof delegateQuery === "string") {
                    return this._handleDelegateOnce(evt, callback, context, delegateQuery)
                }
                if (!this.has(evt)) {
                    this._setListener(evt)
                }
                this._triggerInternalEvent("willonce", {
                    evt: evt,
                    callback: callback,
                    context: context,
                    delegateQuery: delegateQuery
                });
                this._eventEmitter.once.call(this, evt, callback, context);
                this._triggerInternalEvent("didonce", {
                    evt: evt,
                    callback: callback,
                    context: context,
                    delegateQuery: delegateQuery
                })
            }.bind(this, callback, context, delegateQuery));
            evts = callback = delegateQuery = context = null
        };
        proto._handleDelegateOnce = function(evt, callback, context, delegateQuery) {
            this._triggerInternalEvent("willonce", {
                evt: evt,
                callback: callback,
                context: context,
                delegateQuery: delegateQuery
            });
            this._on({
                events: evt,
                context: context,
                delegateQuery: delegateQuery,
                callback: this._getDelegateOnceCallback.bind(this, evt, callback, context, delegateQuery),
                unboundCallback: callback
            });
            this._triggerInternalEvent("didonce", {
                evt: evt,
                callback: callback,
                context: context,
                delegateQuery: delegateQuery
            });
            return this
        };
        proto._getDelegateOnceCallback = function(evt, callback, context, delegateQuery) {
            var args = Array.prototype.slice.call(arguments, 0),
                passedArgs = args.slice(4, args.length);
            callback.apply(context, passedArgs);
            this._off({
                events: evt,
                delegateQuery: delegateQuery,
                callback: callback,
                context: context
            })
        };
        proto._getDelegateFuncBindingIdx = function(evt, delegateQuery, unboundCallback, context, ignoreFuncMatch) {
            var idx = -1;
            if (this._delegateFuncs[delegateQuery] && this._delegateFuncs[delegateQuery][evt]) {
                var i, bindingObj, len = this._delegateFuncs[delegateQuery][evt].length;
                for (i = 0; i < len; i++) {
                    bindingObj = this._delegateFuncs[delegateQuery][evt][i];
                    if (ignoreFuncMatch && typeof unboundCallback === "undefined") {
                        unboundCallback = bindingObj.func
                    }
                    if (bindingObj.func === unboundCallback && bindingObj.context === context) {
                        idx = i;
                        break
                    }
                }
            }
            return idx
        };
        proto._triggerDOMEvents = function(evt, data, delegateQuery) {
            var targets = [this.el];
            if (delegateQuery) {
                targets = ac_dom_traversal.querySelectorAll(delegateQuery, this.el)
            }
            var i, target, len = targets.length;
            for (i = 0; i < len; i++) {
                ac_dom_events.dispatchEvent(targets[i], evt, {
                    bubbles: true,
                    cancelable: true,
                    detail: data
                })
            }
        };
        module.exports = DOMEmitter
    }, {
        "./DOMEmitterEvent": 230,
        "@marcom/ac-dom-events/addEventListener": 231,
        "@marcom/ac-dom-events/dispatchEvent": 232,
        "@marcom/ac-dom-events/removeEventListener": 240,
        "@marcom/ac-dom-traversal/matchesSelector": 37,
        "@marcom/ac-dom-traversal/querySelectorAll": 39,
        "ac-event-emitter": 226
    }],
    230: [function(require, module, exports) {
        "use strict";
        var ac_dom_events = {
            preventDefault: require("@marcom/ac-dom-events/preventDefault"),
            stopPropagation: require("@marcom/ac-dom-events/stopPropagation"),
            target: require("@marcom/ac-dom-events/target")
        };
        var proto;
        var DOMEmitterEvent = function(eventData, domEmitter) {
            this._domEmitter = domEmitter;
            this.originalEvent = eventData || {};
            this._originalTarget = ac_dom_events.target(this.originalEvent);
            this.target = this._originalTarget || this._domEmitter.el;
            this.currentTarget = this._domEmitter.el;
            this.timeStamp = this.originalEvent.timeStamp || Date.now();
            if (this._isDOMEvent(this.originalEvent)) {
                if (typeof this.originalEvent.detail === "object") {
                    this.data = this.originalEvent.detail
                }
            } else if (eventData) {
                this.data = this.originalEvent;
                this.originalEvent = {}
            }
        };
        proto = DOMEmitterEvent.prototype;
        proto.preventDefault = function() {
            ac_dom_events.preventDefault(this.originalEvent)
        };
        proto.stopPropagation = function() {
            ac_dom_events.stopPropagation(this.originalEvent)
        };
        proto.stopImmediatePropagation = function() {
            if (this.originalEvent.stopImmediatePropagation) {
                this.originalEvent.stopImmediatePropagation()
            }
            this._domEmitter.stopImmediatePropagation()
        };
        proto._isDOMEvent = function(e) {
            if (this._originalTarget || document.createEvent !== "undefined" && typeof CustomEvent !== "undefined" && e instanceof CustomEvent) {
                return true
            }
            return false
        };
        module.exports = DOMEmitterEvent
    }, {
        "@marcom/ac-dom-events/preventDefault": 239,
        "@marcom/ac-dom-events/stopPropagation": 243,
        "@marcom/ac-dom-events/target": 244
    }],
    231: [function(require, module, exports) {
        arguments[4][3][0].apply(exports, arguments)
    }, {
        "./shared/getEventType": 241,
        "./utils/addEventListener": 245,
        dup: 3
    }],
    232: [function(require, module, exports) {
        "use strict";
        var dispatchEventUtil = require("./utils/dispatchEvent");
        var getEventType = require("./shared/getEventType");
        module.exports = function dispatchEvent(target, type, options) {
            type = getEventType(target, type);
            return dispatchEventUtil(target, type, options)
        }
    }, {
        "./shared/getEventType": 241,
        "./utils/dispatchEvent": 246
    }],
    233: [function(require, module, exports) {
        "use strict";
        module.exports = {
            addEventListener: require("./addEventListener"),
            dispatchEvent: require("./dispatchEvent"),
            preventDefault: require("./preventDefault"),
            removeEventListener: require("./removeEventListener"),
            stop: require("./stop"),
            stopPropagation: require("./stopPropagation"),
            target: require("./target")
        }
    }, {
        "./addEventListener": 231,
        "./dispatchEvent": 232,
        "./preventDefault": 239,
        "./removeEventListener": 240,
        "./stop": 242,
        "./stopPropagation": 243,
        "./target": 244
    }],
    234: [function(require, module, exports) {
        arguments[4][4][0].apply(exports, arguments)
    }, {
        "./shared/camelCasedEventTypes": 235,
        "./shared/prefixHelper": 236,
        "./shared/windowFallbackEventTypes": 237,
        "./utils/eventTypeAvailable": 238,
        dup: 4
    }],
    235: [function(require, module, exports) {
        arguments[4][5][0].apply(exports, arguments)
    }, {
        dup: 5
    }],
    236: [function(require, module, exports) {
        arguments[4][6][0].apply(exports, arguments)
    }, {
        dup: 6
    }],
    237: [function(require, module, exports) {
        arguments[4][7][0].apply(exports, arguments)
    }, {
        dup: 7
    }],
    238: [function(require, module, exports) {
        arguments[4][8][0].apply(exports, arguments)
    }, {
        dup: 8
    }],
    239: [function(require, module, exports) {
        "use strict";
        module.exports = function preventDefault(evt) {
            evt = evt || window.event;
            if (evt.preventDefault) {
                evt.preventDefault()
            } else {
                evt.returnValue = false
            }
        }
    }, {}],
    240: [function(require, module, exports) {
        arguments[4][9][0].apply(exports, arguments)
    }, {
        "./shared/getEventType": 241,
        "./utils/removeEventListener": 247,
        dup: 9
    }],
    241: [function(require, module, exports) {
        arguments[4][10][0].apply(exports, arguments)
    }, {
        "@marcom/ac-prefixer/getEventType": 234,
        dup: 10
    }],
    242: [function(require, module, exports) {
        "use strict";
        var stopPropagation = require("./stopPropagation");
        var preventDefault = require("./preventDefault");
        module.exports = function stop(evt) {
            evt = evt || window.event;
            stopPropagation(evt);
            preventDefault(evt);
            evt.stopped = true;
            evt.returnValue = false
        }
    }, {
        "./preventDefault": 239,
        "./stopPropagation": 243
    }],
    243: [function(require, module, exports) {
        "use strict";
        module.exports = function stopPropagation(evt) {
            evt = evt || window.event;
            if (evt.stopPropagation) {
                evt.stopPropagation()
            } else {
                evt.cancelBubble = true
            }
        }
    }, {}],
    244: [function(require, module, exports) {
        arguments[4][200][0].apply(exports, arguments)
    }, {
        dup: 200
    }],
    245: [function(require, module, exports) {
        arguments[4][11][0].apply(exports, arguments)
    }, {
        dup: 11
    }],
    246: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/CustomEvent");
        module.exports = function dispatchEvent(target, type, options) {
            var evt;
            if (target.dispatchEvent) {
                if (options) {
                    evt = new CustomEvent(type, options)
                } else {
                    evt = new CustomEvent(type)
                }
                target.dispatchEvent(evt)
            } else {
                evt = document.createEventObject();
                if (options && "detail" in options) {
                    evt.detail = options.detail
                }
                target.fireEvent("on" + type, evt)
            }
            return target
        }
    }, {
        "@marcom/ac-polyfills/CustomEvent": 391
    }],
    247: [function(require, module, exports) {
        arguments[4][12][0].apply(exports, arguments)
    }, {
        dup: 12
    }],
    248: [function(require, module, exports) {
        arguments[4][226][0].apply(exports, arguments)
    }, {
        "./ac-event-emitter/EventEmitter": 249,
        dup: 226
    }],
    249: [function(require, module, exports) {
        arguments[4][227][0].apply(exports, arguments)
    }, {
        dup: 227
    }],
    250: [function(require, module, exports) {
        "use strict";
        module.exports = function joinSearchParams(obj, questionMark) {
            var sep = "&";
            var str = "";
            if (obj) {
                var keysArr = Object.keys(obj);
                var lastIndex = keysArr.length - 1;
                keysArr.forEach(function(key, index) {
                    var value = obj[key];
                    key = key.trim();
                    value = value && typeof value === "string" ? value.trim() : value;
                    value = value === null ? "" : "=" + value;
                    var param = key + value + (index === lastIndex ? "" : sep);
                    str = str ? str.concat(param) : param
                })
            }
            return str && questionMark !== false ? "?" + str : str
        }
    }, {}],
    251: [function(require, module, exports) {
        "use strict";
        module.exports = {
            clone: require("./clone"),
            create: require("./create"),
            defaults: require("./defaults"),
            extend: require("./extend"),
            getPrototypeOf: require("./getPrototypeOf"),
            isDate: require("./isDate"),
            isEmpty: require("./isEmpty"),
            isRegExp: require("./isRegExp"),
            toQueryParameters: require("./toQueryParameters")
        }
    }, {
        "./clone": 252,
        "./create": 253,
        "./defaults": 254,
        "./extend": 255,
        "./getPrototypeOf": 256,
        "./isDate": 257,
        "./isEmpty": 258,
        "./isRegExp": 259,
        "./toQueryParameters": 260
    }],
    252: [function(require, module, exports) {
        arguments[4][94][0].apply(exports, arguments)
    }, {
        "./extend": 255,
        "@marcom/ac-polyfills/Array/isArray": 384,
        dup: 94
    }],
    253: [function(require, module, exports) {
        arguments[4][15][0].apply(exports, arguments)
    }, {
        dup: 15
    }],
    254: [function(require, module, exports) {
        arguments[4][215][0].apply(exports, arguments)
    }, {
        "./extend": 255,
        dup: 215
    }],
    255: [function(require, module, exports) {
        arguments[4][16][0].apply(exports, arguments)
    }, {
        "@marcom/ac-polyfills/Array/prototype.forEach": 387,
        dup: 16
    }],
    256: [function(require, module, exports) {
        "use strict";
        var hasOwnProp = Object.prototype.hasOwnProperty;
        module.exports = function getPrototypeOf(obj) {
            if (Object.getPrototypeOf) {
                return Object.getPrototypeOf(obj)
            } else {
                if (typeof obj !== "object") {
                    throw new Error("Requested prototype of a value that is not an object.")
                } else if (typeof this.__proto__ === "object") {
                    return obj.__proto__
                } else {
                    var constructor = obj.constructor;
                    var oldConstructor;
                    if (hasOwnProp.call(obj, "constructor")) {
                        oldConstructor = constructor;
                        if (!delete obj.constructor) {
                            return null
                        }
                        constructor = obj.constructor;
                        obj.constructor = oldConstructor
                    }
                    return constructor ? constructor.prototype : null
                }
            }
        }
    }, {}],
    257: [function(require, module, exports) {
        "use strict";
        module.exports = function isDate(date) {
            return Object.prototype.toString.call(date) === "[object Date]"
        }
    }, {}],
    258: [function(require, module, exports) {
        "use strict";
        var hasOwnProp = Object.prototype.hasOwnProperty;
        module.exports = function isEmpty(object) {
            var prop;
            if (typeof object !== "object") {
                throw new TypeError("ac-base.Object.isEmpty : Invalid parameter - expected object")
            }
            for (prop in object) {
                if (hasOwnProp.call(object, prop)) {
                    return false
                }
            }
            return true
        }
    }, {}],
    259: [function(require, module, exports) {
        "use strict";
        module.exports = function isRegExp(obj) {
            return window.RegExp ? obj instanceof RegExp : false
        }
    }, {}],
    260: [function(require, module, exports) {
        "use strict";
        var joinSearchParams = require("@marcom/ac-url/joinSearchParams");
        module.exports = function toQueryParameters(object) {
            if (typeof object !== "object") {
                throw new TypeError("toQueryParameters error: argument is not an object")
            }
            return joinSearchParams(object, false)
        }
    }, {
        "@marcom/ac-url/joinSearchParams": 250
    }],
    261: [function(require, module, exports) {
        "use strict";
        module.exports = {
            Routes: require("./ac-routes/Routes"),
            Route: require("./ac-routes/Route")
        }
    }, {
        "./ac-routes/Route": 262,
        "./ac-routes/Routes": 263
    }],
    262: [function(require, module, exports) {
        "use strict";

        function Route(path, callback, context, greedy, priority) {
            this.path = path;
            this.callback = callback;
            this.context = context;
            this.greedy = greedy || false;
            this.priority = priority || 0;
            if (typeof this.priority !== "number") {
                throw new Error("Priority must be a Number.")
            }
            this.identifierPattern = "([a-zA-Z0-9\\-\\_]+)";
            this.tokensRe = new RegExp(":" + this.identifierPattern, "g");
            this.matcher = this._createRouteMatcher(path)
        }
        var proto = Route.prototype;
        proto._createRouteMatcher = function(path) {
            if (path && path.exec) {
                return {
                    pattern: path
                }
            } else if (path === "/") {
                return {
                    pattern: /^\/$/
                }
            } else if (typeof path !== "string") {
                throw new Error("path must be either a string or regex")
            }
            var routeTokens = this._extractRouteTokens(path);
            var paramReString = path.replace(this.tokensRe, this.identifierPattern);
            var paramRe = new RegExp(paramReString, "g");
            return {
                pattern: paramRe,
                routeTokens: routeTokens
            }
        };
        proto._extractRouteTokens = function(routePattern) {
            var routeTokenPattern = routePattern.replace(this.tokensRe, ":" + this.identifierPattern);
            var routeTokenRe = new RegExp(routeTokenPattern, "g");
            var routeTokens = routeTokenRe.exec(routePattern);
            if (routeTokens && routeTokens.length > 1) {
                routeTokens = routeTokens.slice(1)
            } else {
                routeTokens = null
            }
            return routeTokens
        };
        proto.match = function(path) {
            this.matcher.pattern.lastIndex = 0;
            var matches = this.matcher.pattern.exec(path);
            if (matches) {
                var params = matches.length ? matches.slice(1) : [];
                var callback = this.callback;
                if (callback && typeof callback === "function") {
                    callback.apply(this.context || this, params);
                    return true
                }
            }
            return false
        };
        module.exports = Route
    }, {}],
    263: [function(require, module, exports) {
        "use strict";
        var Route = require("./Route");

        function Routes(routes) {
            this._routes = {};
            if (routes) {
                this.addRoutes(routes)
            }
        }
        var proto = Routes.prototype;
        proto._getIndex = function(path, callback, context) {
            if (this._routes[path] !== undefined) {
                var i = this._routes[path].length;
                while (--i > -1) {
                    if (this._routes[path][i].callback === callback && this._routes[path][i].context === context) {
                        return i
                    }
                }
            }
            return -1
        };
        proto.match = function(path) {
            var routeString, i;
            for (routeString in this._routes) {
                i = this._routes[routeString].length;
                while (--i > -1) {
                    if (this._routes[routeString][i].match(path) && this._routes[routeString][i].greedy) {
                        break
                    }
                }
            }
        };
        proto.add = function(route) {
            if (this._routes[route.path] === undefined) {
                this._routes[route.path] = [route]
            } else if (!this.get(route.path, route.callback, route.context)) {
                var i, len = this._routes[route.path].length;
                if (len > 0) {
                    for (i = 0; i < len; ++i) {
                        if (this._routes[route.path][i].priority > route.priority) {
                            this._routes[route.path].splice(i, 0, route);
                            return route
                        }
                    }
                }
                this._routes[route.path].push(route)
            }
            return route
        };
        proto.remove = function(route) {
            var i = this._getIndex(route.path, route.callback, route.context);
            if (i > -1) {
                this._routes[route.path].splice(i, 1);
                return route
            }
            return false
        };
        proto.get = function(path, callback, context) {
            var i = this._getIndex(path, callback, context);
            if (i > -1) {
                return this._routes[path][i]
            }
            return false
        };
        proto.createRoute = function(path, callback, context, greedy, priority) {
            var route = new Route(path, callback, context, greedy, priority);
            this.add(route);
            return route
        };
        proto.addRoutes = function(routes) {
            if (routes instanceof Array) {
                var i, route, len = routes.length;
                for (i = 0; i < len; ++i) {
                    route = routes[i];
                    if (route && typeof route === "object") {
                        this.add(route)
                    }
                }
            } else {
                throw new Error("routes must be an Array.")
            }
        };
        proto.removeRoutes = function(routes) {
            if (routes instanceof Array) {
                var i, route, len = routes.length;
                for (i = 0; i < len; ++i) {
                    route = routes[i];
                    if (route && typeof route === "object") {
                        this.remove(route)
                    }
                }
            } else {
                throw new Error("routes must be an Array.")
            }
        };
        proto.getRoutes = function(path) {
            if (this._routes[path] === undefined) {
                return []
            }
            return this._routes[path]
        };
        module.exports = Routes
    }, {
        "./Route": 262
    }],
    264: [function(require, module, exports) {
        "use strict";
        module.exports = {
            Router: require("./ac-router/Router"),
            History: require("./ac-router/History"),
            Routes: require("@marcom/ac-routes").Routes,
            Route: require("@marcom/ac-routes").Route
        }
    }, {
        "./ac-router/History": 265,
        "./ac-router/Router": 266,
        "@marcom/ac-routes": 261
    }],
    265: [function(require, module, exports) {
        "use strict";
        var create = require("@marcom/ac-object").create;
        var DomEvents = require("@marcom/ac-dom-events");
        var EventEmitter = require("@marcom/ac-event-emitter").EventEmitter;

        function History(options) {
            options = options || {};
            this.history = window.history;
            this.rootStripper = /^\/+|\/+$/g;
            this.root = options.root || "/";
            this.root = ("/" + this.root + "/").replace(this.rootStripper, "/");
            var resolveInitialHash = typeof options.resolveInitialHash !== "boolean" ? true : options.resolveInitialHash;
            this._pushState = typeof options.pushState !== "boolean" ? true : options.pushState;
            this._hashChange = options.hashChange || false;
            this._setUpdateVars(resolveInitialHash);
            if (options.autoStart) {
                this.start()
            }
        }
        var proto = History.prototype = create(EventEmitter.prototype);
        proto._isRoot = function(fragment) {
            return ("/" + fragment + "/").replace(this.rootStripper, "/") === this.root
        };
        proto._isPushStateSupported = function() {
            return this.history && this.history.pushState
        };
        proto._isHashChangeSupported = function() {
            return "onhashchange" in window
        };
        proto._setUpdateVars = function(resolveInitialHash) {
            if (this._pushState && this._isPushStateSupported()) {
                if (resolveInitialHash && this._hashChange && window.location.href.indexOf("#") !== -1) {
                    this.history.pushState({}, document.title, window.location.href.replace("#", ""))
                }
                this._hashChange = false
            } else {
                if (resolveInitialHash && this._pushState && this._hashChange && window.location.href.indexOf("#") < 0) {
                    if (!window.location.origin) {
                        window.location.origin = window.location.protocol + "//" + window.location.hostname;
                        window.location.origin += window.location.port ? ":" + window.location.port : ""
                    }
                    var fragment = window.location.href.substr(window.location.origin.length + this.root.length);
                    if (fragment.length) {
                        window.location = window.location.origin + this.root + "#" + fragment;
                        return
                    }
                }
                if (this._hashChange && !this._isHashChangeSupported()) {
                    this._interval = 50;
                    this._iframe = document.createElement('<iframe src="javascript:0" tabindex="-1" style="display:none;">');
                    this._iframe = document.body.appendChild(this._iframe).contentWindow;
                    this._iframe.document.open().close()
                }
                this._pushState = false
            }
        };
        proto._checkUrl = function() {
            var iframeHash = this._iframe.location.hash.substr(1);
            if (iframeHash.length === 0) {
                iframeHash = "/"
            }
            if (this.fragment() !== iframeHash) {
                window.location.hash = "#" + iframeHash;
                this._ignoreHashChange = false;
                this._handleHashChange()
            }
        };
        proto._handlePopState = function(evt) {
            this.trigger("popstate", {
                fragment: this.fragment()
            })
        };
        proto._handleHashChange = function(evt) {
            if (this._ignoreHashChange) {
                this._ignoreHashChange = false;
                return
            }
            this.trigger("popstate", {
                fragment: this.fragment()
            })
        };
        proto.canUpdate = function() {
            return this._pushState || this._hashChange
        };
        proto.start = function() {
            if (!this.started && (this._pushState || this._hashChange)) {
                this.started = true;
                if (this._pushState) {
                    this._handlePopState = this._handlePopState.bind(this);
                    DomEvents.addEventListener(window, "popstate", this._handlePopState)
                } else if (this._hashChange) {
                    if (this._isHashChangeSupported()) {
                        this._handleHashChange = this._handleHashChange.bind(this);
                        DomEvents.addEventListener(window, "hashchange", this._handleHashChange)
                    } else {
                        this._iframe.location.hash = this.fragment();
                        this._checkUrl = this._checkUrl.bind(this);
                        this._checkUrlInterval = setInterval(this._checkUrl, this._interval)
                    }
                }
            }
            return this.started || false
        };
        proto.stop = function() {
            if (this.started) {
                this.started = false;
                if (this._pushState) {
                    DomEvents.removeEventListener(window, "popstate", this._handlePopState)
                } else if (this._hashChange) {
                    if (this._isHashChangeSupported()) {
                        DomEvents.removeEventListener(window, "hashchange", this._handleHashChange)
                    } else if (this._checkUrlInterval) {
                        clearInterval(this._checkUrlInterval);
                        this._checkUrlInterval = null
                    }
                }
            }
        };
        proto.navigate = function(fragment, options) {
            if (!this.started || !this.canUpdate()) {
                return false
            }
            options = options || {};
            var url = ((this._isRoot(fragment) ? "" : this.root) + fragment).replace(/([^:])(\/\/)/g, "$1/");
            if (this._pushState) {
                this.history.pushState(options, document.title, url)
            } else if (this._hashChange) {
                this._ignoreHashChange = true;
                window.location.hash = "#" + fragment;
                if (!this._isHashChangeSupported()) {
                    this._iframe.document.open().close();
                    this._iframe.location.hash = "#" + fragment
                }
            }
            return true
        };
        proto.fragment = function() {
            var fragment = "";
            if (this._pushState) {
                fragment = window.location.pathname.substr(this.root.length)
            } else if (this._hashChange) {
                fragment = window.location.hash.substr(1)
            }
            return fragment === "" ? "/" : fragment
        };
        module.exports = History
    }, {
        "@marcom/ac-dom-events": 233,
        "@marcom/ac-event-emitter": 248,
        "@marcom/ac-object": 251
    }],
    266: [function(require, module, exports) {
        "use strict";
        var create = require("@marcom/ac-object").create;
        var DOMEmitter = require("@marcom/ac-dom-emitter").DOMEmitter;
        var History = require("./History");
        var Route = require("@marcom/ac-routes").Route;
        var Routes = require("@marcom/ac-routes").Routes;

        function Router(options) {
            options = options || {};
            this._intercept = options.intercept || "[data-route]";
            this._interceptAttribute = options.attribute || "href";
            this._handleTrigger = this._handleTrigger.bind(this);
            this.intercept(this._intercept);
            this.history = options.history || new History({
                root: options.root,
                autoStart: options.autoStart,
                pushState: options.pushState,
                hashChange: options.hashChange,
                resolveInitialHash: options.resolveInitialHash
            });
            Routes.call(this, options.routes);
            if (options.autoStart) {
                if (!this.history.started) {
                    this.history.start()
                }
                this.start()
            }
        }
        var proto = Router.prototype = create(Routes.prototype);
        proto._handleTrigger = function(evt) {
            if (!this.started) {
                return
            }
            var destination = evt.target.getAttribute(this._interceptAttribute);
            if (destination) {
                if (/^(http|https):\/\/+/.exec(destination) && this._interceptAttribute === "href") {
                    destination = destination.substr(destination.indexOf(this.history.root) + this.history.root.length) || "/"
                }
                if (this.navigate(destination)) {
                    evt.preventDefault()
                }
            }
        };
        proto._handlePopstate = function(evt) {
            this.navigate(evt.fragment, true)
        };
        proto.start = function() {
            if (!this.started) {
                this.started = true;
                this.history.start();
                this._handlePopstate = this._handlePopstate.bind(this);
                this.history.on("popstate", this._handlePopstate);
                this.navigate(this.history.fragment(), true)
            }
        };
        proto.stop = function() {
            if (this.started) {
                this.started = false;
                this.history.stop();
                this.history.off("popstate", this._handlePopstate)
            }
        };
        proto.navigate = function(path, silent) {
            if (this.history.fragment() === path && !silent) {
                return this.history.canUpdate()
            }
            if (path && !silent) {
                if (!this.history.navigate(path)) {
                    return false
                }
            }
            this.match(path);
            return true
        };
        proto.intercept = function(elementSelector, containerElement) {
            var domEmitter = new DOMEmitter(containerElement || document.body);
            domEmitter.on("click", elementSelector, this._handleTrigger)
        };
        module.exports = Router
    }, {
        "./History": 265,
        "@marcom/ac-dom-emitter": 228,
        "@marcom/ac-object": 251,
        "@marcom/ac-routes": 261
    }],
    267: [function(require, module, exports) {
        "use strict";
        module.exports = {
            create: require("./factory/createFilms")
        }
    }, {
        "./factory/createFilms": 272
    }],
    268: [function(require, module, exports) {
        "use strict";
        var ac_analytics;
        try {
            ac_analytics = require("@marcom/ac-analytics")
        } catch (e) {}
        var browser = require("@marcom/ac-useragent").browser;
        var IS_IE_OR_EDGE = browser.ie || browser.edge;
        var EventEmitterMicro = require("@marcom/ac-video/event-emitter-shim/EventEmitterShim");
        var specialOnce = function(eventName, callback, context) {
            if (context) {
                var cb = function() {
                    callback.apply(context, arguments)
                };
                EventEmitterMicro.prototype.once.apply(this, [eventName, cb])
            } else {
                EventEmitterMicro.prototype.once.apply(this, arguments)
            }
        };

        function AnalyticsTranslator(player, options, anchors) {
            this.player = player;
            this.sources = {};
            this.currentStubPlayer = null;
            this.playerType = "";
            this.videoType = "";
            this.options = options;
            if (anchors) {
                this._bindAnchors(anchors)
            }
        }
        var proto = AnalyticsTranslator.prototype;
        proto._bindAnchors = function(anchors) {
            var i = 0;
            var len = anchors.length;
            for (; i < len; i++) {
                this._bindAnchorForAnalytics(anchors[i])
            }
        };
        proto.activate = function() {
            this._onPlay = this._onPlay.bind(this);
            this._onEnded = this._onEnded.bind(this);
            this._onTimeupdate = this._onTimeupdate.bind(this);
            this._onTexttrackshow = this._onTexttrackshow.bind(this);
            this._onLoadStart = this._onLoadStart.bind(this);
            this.setCurrentStubPlayer = this.setCurrentStubPlayer.bind(this);
            if (IS_IE_OR_EDGE) {
                this.player.on("playing", this._onPlay)
            } else {
                this.player.on("play", this._onPlay)
            }
            this.player.on("ended", this._onEnded);
            this.player.on("loadstart", this._onLoadStart);
            this.player.on("timeupdate", this._onTimeupdate);
            this.player.on("texttrackshow", this._onTexttrackshow);
            this.player.on("durationchange", this.setCurrentStubPlayer)
        };
        proto.deactivate = function() {
            if (IS_IE_OR_EDGE) {
                this.player.off("playing", this._onPlay)
            } else {
                this.player.off("play", this._onPlay)
            }
            this.player.off("ended", this._onEnded);
            this.player.off("timeupdate", this._onTimeupdate);
            this.player.off("texttrackshow", this._onTexttrackshow);
            this.player.off("durationchange", this.setCurrentStubPlayer)
        };
        proto._bindAnchorForAnalytics = function(anchor) {
            var stubPlayer;
            var analyticsVideoId;
            if (anchor) {
                if (this.sources[anchor.id]) {
                    return
                }
                stubPlayer = this._createStubPlayer(anchor);
                analyticsVideoId = anchor.getAttribute("data-" + this.options.dataAttribute);
                if (!analyticsVideoId) {
                    stubPlayer.videoId = anchor.id
                }
                this.sources[anchor.id] = {
                    stubPlayer: stubPlayer,
                    observer: this._createObserver(stubPlayer)
                }
            }
        };
        proto.addSourceObject = proto._bindAnchorForAnalytics;
        proto.setCurrentStubPlayer = function() {
            var currentSrc;
            var playerEl = this.player.el;
            var currentSrcId = playerEl.getAttribute("data-" + this.options.dataAttribute);
            var srcObj = this._getCurrentSourceObject(currentSrcId);
            if (srcObj && srcObj.stubPlayer) {
                this.currentStubPlayer = srcObj.stubPlayer;
                this.playerType = "html5";
                currentSrc = this.player.getCurrentSrc();
                if (currentSrc && currentSrc.attributes && currentSrc.attributes.src) {
                    this.videoType = currentSrc.attributes.src.value.split(".").pop()
                }
            }
        };
        proto.destroy = function() {
            this.deactivate();
            this.player = null;
            this.sources = null;
            this.currentStubPlayer = null;
            this.options = null
        };
        proto._onPlay = function() {
            this.setCurrentStubPlayer();
            if (!this._started) {
                this._proxyEvent("play");
                this._started = true
            }
        };
        proto._onLoadStart = function() {
            this._started = false
        };
        proto._onEnded = function() {
            this._started = false;
            this._proxyEvent("ended")
        };
        proto._onTimeupdate = function() {
            this._proxyEvent("timeupdate");
            if (this._started && this.player.getCurrentTime() === 0 && this.player.getPaused()) {
                this._started = false
            }
        };
        proto._onTexttrackshow = function() {
            this._proxyEvent("captions-enabled")
        };
        proto._getSourceObjectBySrcObjId = function(srcObjId) {
            return this.sources[srcObjId] || null
        };
        proto._getCurrentSourceObject = function(srcObjId) {
            var assoc;
            if (srcObjId) {
                assoc = this._getSourceObjectBySrcObjId(srcObjId)
            }
            return assoc
        };
        proto._createStubPlayer = function(el) {
            var stubPlayer = new EventEmitterMicro;
            stubPlayer.once = specialOnce;
            stubPlayer.el = el;
            return stubPlayer
        };
        proto._getEventData = function() {
            return {
                currentTime: this.player.getCurrentTime(),
                playerType: this.playerType || "html5",
                videoType: this.videoType || null
            }
        };
        proto._createObserver = function(stubPlayer) {
            var observer;
            if (ac_analytics && ac_analytics.observer && ac_analytics.observer.Video) {
                observer = new ac_analytics.observer.Video(stubPlayer, {
                    dataAttribute: this.options.dataAttribute
                })
            }
            return observer
        };
        proto._proxyEvent = function(eventName) {
            if (this.currentStubPlayer) {
                this.currentStubPlayer.trigger(eventName, this._getEventData())
            }
        };
        module.exports = AnalyticsTranslator
    }, {
        "@marcom/ac-analytics": "@marcom/ac-analytics",
        "@marcom/ac-useragent": 403,
        "@marcom/ac-video/event-emitter-shim/EventEmitterShim": 502
    }],
    269: [function(require, module, exports) {
        "use strict";
        var windowLoad = require("../windowload/windowLoad");
        var TouchClick = require("../touchclick/TouchClick");
        var userAgent = require("@marcom/ac-useragent");
        var IS_MOBILE = userAgent.os.ios || userAgent.os.android;
        module.exports = function bindAnchor(anchor, clickHandler, playHandler, router) {
            var touchClick = TouchClick.create(anchor);
            touchClick.on("click", function() {
                clickHandler(anchor)
            });
            if (router && anchor.id) {
                router.createRoute(anchor.id, function() {
                    windowLoad(function() {
                        clickHandler(anchor, !IS_MOBILE)
                    })
                })
            }
        }
    }, {
        "../touchclick/TouchClick": 278,
        "../windowload/windowLoad": 279,
        "@marcom/ac-useragent": 403
    }],
    270: [function(require, module, exports) {
        "use strict";
        var Router = require("@marcom/ac-router").Router;
        var createPlayer = require("@marcom/ac-video/player/factory/createShareablePlayer");
        var optimizeVideoUrl = require("@marcom/ac-video/optimizeVideoUrl");
        var userAgent = require("@marcom/ac-useragent");
        var bindAnchor = require("./bindAnchor");
        var createClickHandler = require("./createClickHandler");
        var createModalLink = require("./createModalLink");
        var createHandheldModalLink = require("./createHandheldModalLink");
        var createInlineLink = require("./createInlineLink");
        var OPTIONS_DATA_ATTRIBUTE = "data-films-options";
        var IS_HANDHELD = require("@marcom/ac-feature/isHandheld")();
        var IS_IOS = userAgent.os.ios;
        var DEFAULT_OPTIONS = {
            controls: true,
            urlOptimizer: optimizeVideoUrl
        };
        module.exports = function bindAnchors(anchors, options) {
            options = options || {};
            options = Object.assign({}, DEFAULT_OPTIONS, options);
            var router;
            anchors.forEach(function(a) {
                if (a.hasAttribute(OPTIONS_DATA_ATTRIBUTE)) {
                    var opts = JSON.parse(a.getAttribute(OPTIONS_DATA_ATTRIBUTE));
                    if (opts.closeOnEnd === false && !options.closeOnEnd) {
                        options.closeOnEnd = false
                    }
                }
            });
            if (!options.maxWidth) {
                options.maxWidth = 1280
            }
            var player = createPlayer(options);
            var filmsObj;
            router = new Router({
                hashChange: true,
                pushState: false
            });
            if (options.modal && (!IS_HANDHELD || !IS_IOS)) {
                filmsObj = createModalLink(player, options)
            } else if (options.modal) {
                filmsObj = createHandheldModalLink(player, document.body, options)
            } else {
                filmsObj = createInlineLink(player, options)
            }
            var boundFilmsObjectPlay = filmsObj.play.bind(filmsObj);
            var playHandler = function(id) {
                var i = 0;
                var len = anchors.length;
                for (; i < len; i++) {
                    if (anchors[i].id === id || anchors[i] === id) {
                        boundFilmsObjectPlay(anchors[i].href)
                    }
                }
            };
            var clickHandler = createClickHandler({
                player: player,
                playHandler: boundFilmsObjectPlay,
                attr: "data-" + options.dataAttribute
            });
            anchors.forEach(function(anchor) {
                bindAnchor(anchor, clickHandler, boundFilmsObjectPlay, router)
            });
            router.start();
            return {
                play: playHandler,
                player: player,
                modalVideo: filmsObj.modal
            }
        }
    }, {
        "./bindAnchor": 269,
        "./createClickHandler": 271,
        "./createHandheldModalLink": 273,
        "./createInlineLink": 274,
        "./createModalLink": 275,
        "@marcom/ac-feature/isHandheld": 162,
        "@marcom/ac-router": 264,
        "@marcom/ac-useragent": 403,
        "@marcom/ac-video/optimizeVideoUrl": 503,
        "@marcom/ac-video/player/factory/createShareablePlayer": 508
    }],
    271: [function(require, module, exports) {
        "use strict";
        var OPTIONS_DATA_ATTRIBUTE = "data-films-options";
        var MODAL_LABEL_ATTRIBUTE = "data-films-modal-label";
        var DEFAULT_LABEL = "Video Player";
        module.exports = function createClickHandler(options) {
            return function(target, autoplay) {
                var optionsAttr = target.getAttribute(OPTIONS_DATA_ATTRIBUTE);
                var metadata;
                if (optionsAttr) {
                    metadata = JSON.parse(optionsAttr)
                } else {
                    metadata = null
                }
                var label = target.getAttribute(MODAL_LABEL_ATTRIBUTE) || metadata && metadata.modalLabel || options.player.options.modalLabel || DEFAULT_LABEL;
                options.player.el.setAttribute(options.attr, target.getAttribute(options.attr) || target.id);
                options.playHandler(target.href, metadata, autoplay, label)
            }
        }
    }, {}],
    272: [function(require, module, exports) {
        "use strict";
        var bindAnchors = require("./bindAnchors");
        var AnalyticsTranslator = require("../analytics/AnalyticsTranslator");
        var defaults = {
            dataAttribute: "analytics-video-id",
            analytics: true
        };
        module.exports = function createFilms(anchors, options) {
            options = options || {};
            options = Object.assign({}, defaults, options);
            var bindObj = bindAnchors(anchors, options);
            if (options.analytics) {
                var analyticsTranslator = new AnalyticsTranslator(bindObj.player, options, anchors);
                analyticsTranslator.activate()
            }
            return bindObj
        }
    }, {
        "../analytics/AnalyticsTranslator": 268,
        "./bindAnchors": 270
    }],
    273: [function(require, module, exports) {
        "use strict";
        var AC_FILMS_HANDHELD_PLAYER = "ac-films-handheld-player";
        var PLAYER_FULLSCREEN = "player-fullscreen";
        module.exports = function createHandheldModalLink(player, targetElement, options) {
            player.el.classList.add(AC_FILMS_HANDHELD_PLAYER);
            var playHandler = function(url, autoplay) {
                var endHandler = function() {
                    if (!player.getPaused()) {
                        player.pause()
                    }
                    player.el.classList.remove(PLAYER_FULLSCREEN)
                };
                player.el.classList.add(PLAYER_FULLSCREEN);
                player.once("ended", endHandler);
                player.once("exitfullscreen", endHandler);
                player.load(url);
                if (autoplay !== false) {
                    player.play()
                }
            };
            targetElement.appendChild(player.el);
            return {
                play: playHandler,
                player: player
            }
        }
    }, {}],
    274: [function(require, module, exports) {
        "use strict";
        module.exports = function createInlineLink(player, options) {
            var targetElement = options.targetElement;
            var playHandler = function(url, metadata) {
                player.load(url, null, 0, metadata);
                player.play()
            };
            options.playHandler = playHandler;
            if (targetElement) {
                targetElement.appendChild(player.el)
            }
            return {
                play: playHandler,
                player: player
            }
        }
    }, {}],
    275: [function(require, module, exports) {
        "use strict";
        var createFullViewportModal = require("@marcom/ac-modal").createFullViewportModal;
        var userAgent = require("@marcom/ac-useragent");
        var IS_MOBILE = userAgent.os.ios || userAgent.os.android;
        var MOBILE_CLASSNAME = "ac-films-modal-mobile";
        var ModalLink = require("./link/ModalLink");
        var AC_MODAL_VIDEO = "ac-modal-video";
        module.exports = function createModalLink(player, options) {
            options = options || {};
            var container = document.createElement("div");
            container.classList.add("ac-player-container");
            if (IS_MOBILE) {
                container.classList.add(MOBILE_CLASSNAME)
            }
            container.appendChild(player.el);
            var modal = createFullViewportModal(container);
            modal.modalElement.classList.add(AC_MODAL_VIDEO);
            var link = new ModalLink({
                player: player,
                modal: modal,
                closeOnEnd: options.closeOnEnd
            });
            return link
        }
    }, {
        "./link/ModalLink": 276,
        "@marcom/ac-modal": 222,
        "@marcom/ac-useragent": 403
    }],
    276: [function(require, module, exports) {
        "use strict";
        var CINEMATIC_ASPECT_RATIO_MARKER = "-tft-";
        var URL_SIZE = /_([0-9]+)x([0-9]+)/;
        var PLAYER_CINEMATIC_CLASS = "ac-video-cinematic-aspect-ratio";
        var PLAYER_SQUARE_CLASS = "ac-video-square-aspect-ratio";
        var PLAYER_VERTICAL_CLASS = "ac-video-vertical-aspect-ratio";
        var PLAYER_19X9_CLASS = "ac-video-19x9-aspect-ratio";
        var PLAYER_9X19_CLASS = "ac-video-9x19-aspect-ratio";
        var AC_MODAL_VIDEO_PIP = "ac-modal-video-pip";
        var PIP_CHANGE_EVENT = "pictureinpicture:change";
        var HAS_MODAL = "has-modal";
        var ResizeHandler = require("../../resize/ResizeHandler");
        var _19X9_ASSET_SIZES = require("@marcom/ac-video/utils/urlOptimizer/19X9AssetSizes");
        var containsMatch = function(array, urlSize) {
            return array.find(function(size) {
                return size.width === urlSize.width && (size.height = urlSize.height) || size.width === urlSize.height && (size.height = urlSize.width)
            })
        };
        var ModalLink = function(options) {
            this.modal = options.modal;
            this.player = options.player;
            this._resizeHandler = new ResizeHandler({
                player: this.player,
                modal: this.modal
            });
            this._closeOnEnd = options.closeOnEnd !== undefined ? options.closeOnEnd : true;
            this._ended = false;
            this._pauseTime = 0;
            this._playing = false;
            this._initialize()
        };
        var proto = ModalLink.prototype;
        proto._initialize = function() {
            this._bindMethods();
            this.player.on("ended", this._onEnded);
            this.player.on("pause", this._onPaused);
            this.modal.on("open", this._onOpen);
            if (this.player.supportsPictureInPicture()) {
                this.player.on(PIP_CHANGE_EVENT, this._onPipModeChanged)
            }
        };
        proto._bindMethods = function() {
            this._onEnded = this._onEnded.bind(this);
            this._onPipModeChanged = this._onPipModeChanged.bind(this);
            this._onPaused = this._onPaused.bind(this);
            this._onModalWillClose = this._onModalWillClose.bind(this);
            this._onOpen = this._onOpen.bind(this)
        };
        proto._onOpen = function() {
            this.player.refreshSize()
        };
        proto._onPaused = function() {
            this._pauseTime = Date.now()
        };
        proto._onEnded = function() {
            this._ended = true;
            if (!this.player.isPictureInPicture() && this._closeOnEnd) {
                this.modal.close()
            } else if (this.player.isPictureInPicture()) {
                this.player.setPictureInPicture(false);
                this.modal.modalElement.classList.remove(AC_MODAL_VIDEO_PIP);
                if (!this._closeOnEnd) {
                    this.modal.open();
                    this._bindWillClose()
                }
            }
        };
        proto._onPipModeChanged = function() {
            if (this._ended) {
                return
            }
            if (this.player.isPictureInPicture() && this._isModalOpen()) {
                this._unBindWillClose();
                this.modal.modalElement.classList.add(AC_MODAL_VIDEO_PIP);
                this.modal.close()
            } else if (!this._isModalOpen()) {
                this.modal.modalElement.classList.remove(AC_MODAL_VIDEO_PIP);
                if (!this._pauseTime || Date.now() - this._pauseTime > 400) {
                    this._bindWillClose();
                    this.modal.open()
                } else {
                    this._resetVideo()
                }
            }
        };
        proto._resetVideo = function() {
            this.player.pause();
            this.player.setCurrentTime(0)
        };
        proto._onModalWillClose = function() {
            this._unBindWillClose();
            this._resetVideo();
            this.player.setPictureInPicture(false);
            this.modal.modalElement.classList.remove(AC_MODAL_VIDEO_PIP)
        };
        proto._clearAspectRatio = function() {
            this.player.el.parentElement.classList.remove(PLAYER_CINEMATIC_CLASS);
            this.player.el.parentElement.classList.remove(PLAYER_SQUARE_CLASS);
            this.player.el.parentElement.classList.remove(PLAYER_VERTICAL_CLASS);
            this.player.el.parentElement.classList.remove(PLAYER_19X9_CLASS);
            this.player.el.parentElement.classList.remove(PLAYER_9X19_CLASS)
        };
        proto._set19X9Mode = function() {
            this.player.el.parentElement.classList.add(PLAYER_19X9_CLASS)
        };
        proto._set9X19Mode = function() {
            this.player.el.parentElement.classList.add(PLAYER_9X19_CLASS)
        };
        proto._setCinematicMode = function() {
            this.player.el.parentElement.classList.add(PLAYER_CINEMATIC_CLASS)
        };
        proto._setSquareVideo = function() {
            this.player.el.parentElement.classList.add(PLAYER_SQUARE_CLASS)
        };
        proto._setVerticalVideo = function() {
            this.player.el.parentElement.classList.add(PLAYER_VERTICAL_CLASS)
        };
        proto._resetPiPVideo = function() {
            var visibleTracks = this.player.getVisibleTextTracks();
            visibleTracks.forEach(function(tt) {
                tt.mode = "hidden"
            });
            this._resetVideo();
            visibleTracks.forEach(function(tt) {
                tt.mode = "showing"
            })
        };
        proto.play = function(url, metadata, autoplay, label) {
            this._ended = false;
            this._clearAspectRatio();
            if (url.match(CINEMATIC_ASPECT_RATIO_MARKER)) {
                this._setCinematicMode()
            } else if (URL_SIZE.test(url)) {
                var width = parseInt(RegExp.$1, 10);
                var height = parseInt(RegExp.$2, 10);
                if (containsMatch(_19X9_ASSET_SIZES, {
                        width: width,
                        height: height
                    })) {
                    if (height > width) {
                        this._set9X19Mode(true)
                    } else {
                        this._set19X9Mode(true)
                    }
                } else if (height > width) {
                    this._setVerticalVideo(true)
                } else if (height === width) {
                    this._setSquareVideo(true)
                }
            }
            this.modal.modalElement.setAttribute("aria-label", label);
            this.player.load(url, null, 0, Object.assign({}, metadata, {
                maxWidth: window.innerWidth
            }));
            if (!this.player.isPictureInPicture()) {
                this.modal.open();
                this._bindWillClose()
            } else {
                this._resetPiPVideo()
            }
            if (autoplay !== false) {
                this.player.play()
            }
        };
        proto._bindWillClose = function() {
            this.modal.on("willclose", this._onModalWillClose)
        };
        proto._unBindWillClose = function() {
            this.modal.off("willclose", this._onModalWillClose)
        };
        proto._isModalOpen = function() {
            return document.documentElement.classList.contains(HAS_MODAL)
        };
        proto.destroy = function() {
            this.player.off("ended", this._onEnded);
            this.player.off("paused", this._onPaused);
            this.player.off(PIP_CHANGE_EVENT, this._onPipModeChanged);
            this._unBindWillClose();
            this._resizeHandler.destroy();
            this.modal.destroy();
            this.player.destroy()
        };
        module.exports = ModalLink
    }, {
        "../../resize/ResizeHandler": 277,
        "@marcom/ac-video/utils/urlOptimizer/19X9AssetSizes": 555
    }],
    277: [function(require, module, exports) {
        "use strict";
        var URL_SIZE = /_([0-9]+)x([0-9]+)/;
        var userAgent = require("@marcom/ac-useragent");
        var IS_MOBILE = userAgent.os.ios || userAgent.os.android;

        function ResizeHandler(options) {
            this._modal = options.modal;
            this._player = options.player;
            this._mediaElement = options.player.getMediaElement();
            this._posterEl = this._player.el.querySelector(".ac-video-poster img");
            this._playerContainer = this._player.el.parentElement;
            this._bindMethods();
            this._addEventListeners();
            this._calcAspectRatio()
        }
        var proto = ResizeHandler.prototype;
        proto._bindMethods = function() {
            this._onLoadStart = this._onLoadStart.bind(this);
            this._onResize = this._onResize.bind(this);
            this._fullScreenChange = this._fullScreenChange.bind(this);
            this._calcAspectRatio = this._calcAspectRatio.bind(this);
            this._addResizeListeners = this._addResizeListeners.bind(this);
            this._removeResizeListeners = this._removeResizeListeners.bind(this);
            this._onModalOpen = this._onModalOpen.bind(this)
        };
        proto._addEventListeners = function() {
            if (this._posterEl) {
                this._posterEl.addEventListener("load", this._calcAspectRatio)
            }
            this._modal.on("willopen", this._addResizeListeners);
            this._modal.on("open", this._onModalOpen);
            this._modal.on("close", this._removeResizeListeners)
        };
        proto._onModalOpen = function() {
            if (this._loadStarted) {
                this._onResize();
                this._player.el.style.display = "";
                this._player.el.style.opacity = ""
            }
        };
        proto._addResizeListeners = function() {
            this._player.el.style.display = "block";
            this._player.el.style.opacity = 0;
            window.addEventListener("resize", this._onResize);
            window.addEventListener("orientationchange", this._onResize);
            this._player.on("loadstart", this._onLoadStart);
            this._player.on("loadeddata", this._calcAspectRatio);
            this._player.on("fullscreen:change", this._fullScreenChange);
            this._player.on("fullscreen:willenter", this._fullScreenChange);
            this._calcAspectRatio()
        };
        proto._removeResizeListeners = function() {
            this._onResize();
            window.removeEventListener("resize", this._onResize);
            window.removeEventListener("orientationchange", this._onResize);
            this._player.off("loadstart", this._onLoadStart);
            this._player.off("loadeddata", this._calcAspectRatio);
            this._player.off("fullscreen:change", this._fullScreenChange)
        };
        proto._removeEventListeners = function() {
            this._removeResizeListeners();
            this._modal.off("willopen", this._addResizeListeners);
            this._modal.off("open", this._onModalOpen);
            this._modal.off("close", this._removeResizeListeners);
            if (this._posterEl) {
                this._posterEl.removeEventListener("load", this._calcAspectRatio)
            }
        };
        proto._onLoadStart = function() {
            this._loadStarted = false;
            requestAnimationFrame(function() {
                this._loadStarted = true;
                this._onModalOpen()
            }.bind(this));
            this._calcAspectRatio()
        };
        proto._calcAspectRatio = function() {
            this._aspectRatio = this._player.getMediaWidth() / this._player.getMediaHeight();
            if ((isNaN(this._aspectRatio) || this._aspectRatio <= 0) && this._mediaElement.src) {
                if (URL_SIZE.test(this._mediaElement.src)) {
                    this._aspectRatio = parseInt(RegExp.$1, 10) / parseInt(RegExp.$2, 10)
                }
            }
            if ((isNaN(this._aspectRatio) || this._aspectRatio <= 0) && this._posterEl) {
                this._aspectRatio = this._posterEl.naturalWidth / this._posterEl.naturalHeight
            }
            this._onResize()
        };
        proto._fullScreenChange = function(evt) {
            if (evt && evt.type === "enter") {
                setTimeout(function() {
                    this._isFullScreen = true;
                    this._onResize()
                }.bind(this), 60);
                return
            }
            this._isFullScreen = this._player.isFullscreen();
            this._onResize()
        };
        proto.destroy = function() {
            this._removeEventListeners()
        };
        proto._onResize = function() {
            var aspectRatio = this._aspectRatio;
            if (isNaN(aspectRatio)) {
                this._mediaElement.style.width = "";
                this._mediaElement.style.height = "";
                return
            }
            var windowWidth = window.innerWidth;
            var windowHeight = window.innerHeight;
            var windowAspectRatio = windowWidth / windowHeight;
            if (this._mediaElement.readyState < 1) {
                var maxWidth = parseInt(getComputedStyle(this._playerContainer).maxWidth.replace("px", ""));
                var maxHeight = maxWidth / aspectRatio;
                var minWidth = parseInt(getComputedStyle(this._playerContainer).minWidth.replace("px", ""));
                var playerMaxHeight = IS_MOBILE ? parseInt(getComputedStyle(this._player.el).maxHeight.replace("px", "")) : maxHeight;
                if (maxHeight > windowHeight || playerMaxHeight && maxHeight > playerMaxHeight) {
                    maxWidth = (playerMaxHeight || windowHeight) * aspectRatio;
                    maxHeight = Math.min(maxWidth / aspectRatio, windowHeight)
                }
                if (maxWidth > windowWidth || maxWidth > maxHeight * aspectRatio) {
                    maxHeight = Math.min(windowWidth / aspectRatio, windowHeight);
                    maxWidth = maxHeight * aspectRatio
                }
                this._mediaElement.style.width = maxWidth + "px";
                this._mediaElement.style.height = Math.min(maxHeight, windowHeight) + "px"
            } else {
                this._mediaElement.style.width = "";
                this._mediaElement.style.height = ""
            }
            if (windowAspectRatio > aspectRatio && !this._isFullScreen) {
                this._playerContainer.parentElement.classList.add("center-horizontal")
            } else {
                this._playerContainer.parentElement.classList.remove("center-horizontal")
            }
            this._player.refreshSize()
        };
        module.exports = ResizeHandler
    }, {
        "@marcom/ac-useragent": 403
    }],
    278: [function(require, module, exports) {
        "use strict";
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var TOUCH_AVAILABLE = require("@marcom/ac-feature/touchAvailable")();

        function TouchClick(options) {
            options = options || {};
            this.el = options.el;
            this._onTouchStart = this._onTouchStart.bind(this);
            this._onTouchMove = this._onTouchMove.bind(this);
            this._onTouchEnd = this._onTouchEnd.bind(this);
            this._onClick = this._onClick.bind(this);
            this._touchStart = false;
            EventEmitterMicro.call(this);
            this.activate()
        }
        var proto = TouchClick.prototype = Object.create(EventEmitterMicro.prototype);
        proto._broadcastClick = function(e) {
            this.trigger("click", {
                originalEvent: e
            })
        };
        proto._onClick = function(e) {
            e.stopPropagation();
            e.preventDefault();
            if (!TOUCH_AVAILABLE) {
                this._broadcastClick(e)
            }
        };
        proto._onTouchStart = function() {
            this._touchStart = true
        };
        proto._onTouchEnd = function(e) {
            if (this._touchStart === true) {
                e.stopPropagation();
                e.preventDefault();
                this._broadcastClick(e)
            }
            this._touchStart = false
        };
        proto._onTouchMove = function() {
            this._touchStart = false
        };
        proto.activate = function() {
            if (TOUCH_AVAILABLE) {
                this.el.addEventListener("touchstart", this._onTouchStart);
                this.el.addEventListener("touchmove", this._onTouchMove);
                this.el.addEventListener("touchend", this._onTouchEnd)
            }
            this.el.addEventListener("click", this._onClick)
        };
        proto.deactivate = function() {
            this.el.removeEventListener("touchstart", this._onTouchStart);
            this.el.removeEventListener("touchmove", this._onTouchMove);
            this.el.removeEventListener("touchend", this._onTouchEnd);
            this.el.removeEventListener("click", this._onClick)
        };
        TouchClick.create = function(element, options) {
            options = options || {};
            return new TouchClick({
                el: element
            })
        };
        module.exports = TouchClick
    }, {
        "@marcom/ac-event-emitter-micro": 167,
        "@marcom/ac-feature/touchAvailable": 166
    }],
    279: [function(require, module, exports) {
        "use strict";
        var isLoaded = false;
        window.addEventListener("load", function() {
            isLoaded = true
        });

        function windowLoad(func) {
            if (isLoaded) {
                func()
            } else {
                window.addEventListener("load", func)
            }
        }
        module.exports = windowLoad
    }, {}],
    280: [function(require, module, exports) {
        (function(global) {
            "use strict";
            var base64 = require("base64-js");
            var ieee754 = require("ieee754");
            var isArray = require("isarray");
            exports.Buffer = Buffer;
            exports.SlowBuffer = SlowBuffer;
            exports.INSPECT_MAX_BYTES = 50;
            Buffer.poolSize = 8192;
            var rootParent = {};
            Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined ? global.TYPED_ARRAY_SUPPORT : typedArraySupport();

            function typedArraySupport() {
                function Bar() {}
                try {
                    var arr = new Uint8Array(1);
                    arr.foo = function() {
                        return 42
                    };
                    arr.constructor = Bar;
                    return arr.foo() === 42 && arr.constructor === Bar && typeof arr.subarray === "function" && arr.subarray(1, 1).byteLength === 0
                } catch (e) {
                    return false
                }
            }

            function kMaxLength() {
                return Buffer.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823
            }

            function Buffer(arg) {
                if (!(this instanceof Buffer)) {
                    if (arguments.length > 1) return new Buffer(arg, arguments[1]);
                    return new Buffer(arg)
                }
                if (!Buffer.TYPED_ARRAY_SUPPORT) {
                    this.length = 0;
                    this.parent = undefined
                }
                if (typeof arg === "number") {
                    return fromNumber(this, arg)
                }
                if (typeof arg === "string") {
                    return fromString(this, arg, arguments.length > 1 ? arguments[1] : "utf8")
                }
                return fromObject(this, arg)
            }

            function fromNumber(that, length) {
                that = allocate(that, length < 0 ? 0 : checked(length) | 0);
                if (!Buffer.TYPED_ARRAY_SUPPORT) {
                    for (var i = 0; i < length; i++) {
                        that[i] = 0
                    }
                }
                return that
            }

            function fromString(that, string, encoding) {
                if (typeof encoding !== "string" || encoding === "") encoding = "utf8";
                var length = byteLength(string, encoding) | 0;
                that = allocate(that, length);
                that.write(string, encoding);
                return that
            }

            function fromObject(that, object) {
                if (Buffer.isBuffer(object)) return fromBuffer(that, object);
                if (isArray(object)) return fromArray(that, object);
                if (object == null) {
                    throw new TypeError("must start with number, buffer, array or string")
                }
                if (typeof ArrayBuffer !== "undefined") {
                    if (object.buffer instanceof ArrayBuffer) {
                        return fromTypedArray(that, object)
                    }
                    if (object instanceof ArrayBuffer) {
                        return fromArrayBuffer(that, object)
                    }
                }
                if (object.length) return fromArrayLike(that, object);
                return fromJsonObject(that, object)
            }

            function fromBuffer(that, buffer) {
                var length = checked(buffer.length) | 0;
                that = allocate(that, length);
                buffer.copy(that, 0, 0, length);
                return that
            }

            function fromArray(that, array) {
                var length = checked(array.length) | 0;
                that = allocate(that, length);
                for (var i = 0; i < length; i += 1) {
                    that[i] = array[i] & 255
                }
                return that
            }

            function fromTypedArray(that, array) {
                var length = checked(array.length) | 0;
                that = allocate(that, length);
                for (var i = 0; i < length; i += 1) {
                    that[i] = array[i] & 255
                }
                return that
            }

            function fromArrayBuffer(that, array) {
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    array.byteLength;
                    that = Buffer._augment(new Uint8Array(array))
                } else {
                    that = fromTypedArray(that, new Uint8Array(array))
                }
                return that
            }

            function fromArrayLike(that, array) {
                var length = checked(array.length) | 0;
                that = allocate(that, length);
                for (var i = 0; i < length; i += 1) {
                    that[i] = array[i] & 255
                }
                return that
            }

            function fromJsonObject(that, object) {
                var array;
                var length = 0;
                if (object.type === "Buffer" && isArray(object.data)) {
                    array = object.data;
                    length = checked(array.length) | 0
                }
                that = allocate(that, length);
                for (var i = 0; i < length; i += 1) {
                    that[i] = array[i] & 255
                }
                return that
            }
            if (Buffer.TYPED_ARRAY_SUPPORT) {
                Buffer.prototype.__proto__ = Uint8Array.prototype;
                Buffer.__proto__ = Uint8Array
            } else {
                Buffer.prototype.length = undefined;
                Buffer.prototype.parent = undefined
            }

            function allocate(that, length) {
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    that = Buffer._augment(new Uint8Array(length));
                    that.__proto__ = Buffer.prototype
                } else {
                    that.length = length;
                    that._isBuffer = true
                }
                var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1;
                if (fromPool) that.parent = rootParent;
                return that
            }

            function checked(length) {
                if (length >= kMaxLength()) {
                    throw new RangeError("Attempt to allocate Buffer larger than maximum " + "size: 0x" + kMaxLength().toString(16) + " bytes")
                }
                return length | 0
            }

            function SlowBuffer(subject, encoding) {
                if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding);
                var buf = new Buffer(subject, encoding);
                delete buf.parent;
                return buf
            }
            Buffer.isBuffer = function isBuffer(b) {
                return !!(b != null && b._isBuffer)
            };
            Buffer.compare = function compare(a, b) {
                if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
                    throw new TypeError("Arguments must be Buffers")
                }
                if (a === b) return 0;
                var x = a.length;
                var y = b.length;
                var i = 0;
                var len = Math.min(x, y);
                while (i < len) {
                    if (a[i] !== b[i]) break;
                    ++i
                }
                if (i !== len) {
                    x = a[i];
                    y = b[i]
                }
                if (x < y) return -1;
                if (y < x) return 1;
                return 0
            };
            Buffer.isEncoding = function isEncoding(encoding) {
                switch (String(encoding).toLowerCase()) {
                    case "hex":
                    case "utf8":
                    case "utf-8":
                    case "ascii":
                    case "binary":
                    case "base64":
                    case "raw":
                    case "ucs2":
                    case "ucs-2":
                    case "utf16le":
                    case "utf-16le":
                        return true;
                    default:
                        return false
                }
            };
            Buffer.concat = function concat(list, length) {
                if (!isArray(list)) throw new TypeError("list argument must be an Array of Buffers.");
                if (list.length === 0) {
                    return new Buffer(0)
                }
                var i;
                if (length === undefined) {
                    length = 0;
                    for (i = 0; i < list.length; i++) {
                        length += list[i].length
                    }
                }
                var buf = new Buffer(length);
                var pos = 0;
                for (i = 0; i < list.length; i++) {
                    var item = list[i];
                    item.copy(buf, pos);
                    pos += item.length
                }
                return buf
            };

            function byteLength(string, encoding) {
                if (typeof string !== "string") string = "" + string;
                var len = string.length;
                if (len === 0) return 0;
                var loweredCase = false;
                for (;;) {
                    switch (encoding) {
                        case "ascii":
                        case "binary":
                        case "raw":
                        case "raws":
                            return len;
                        case "utf8":
                        case "utf-8":
                            return utf8ToBytes(string).length;
                        case "ucs2":
                        case "ucs-2":
                        case "utf16le":
                        case "utf-16le":
                            return len * 2;
                        case "hex":
                            return len >>> 1;
                        case "base64":
                            return base64ToBytes(string).length;
                        default:
                            if (loweredCase) return utf8ToBytes(string).length;
                            encoding = ("" + encoding).toLowerCase();
                            loweredCase = true
                    }
                }
            }
            Buffer.byteLength = byteLength;

            function slowToString(encoding, start, end) {
                var loweredCase = false;
                start = start | 0;
                end = end === undefined || end === Infinity ? this.length : end | 0;
                if (!encoding) encoding = "utf8";
                if (start < 0) start = 0;
                if (end > this.length) end = this.length;
                if (end <= start) return "";
                while (true) {
                    switch (encoding) {
                        case "hex":
                            return hexSlice(this, start, end);
                        case "utf8":
                        case "utf-8":
                            return utf8Slice(this, start, end);
                        case "ascii":
                            return asciiSlice(this, start, end);
                        case "binary":
                            return binarySlice(this, start, end);
                        case "base64":
                            return base64Slice(this, start, end);
                        case "ucs2":
                        case "ucs-2":
                        case "utf16le":
                        case "utf-16le":
                            return utf16leSlice(this, start, end);
                        default:
                            if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
                            encoding = (encoding + "").toLowerCase();
                            loweredCase = true
                    }
                }
            }
            Buffer.prototype.toString = function toString() {
                var length = this.length | 0;
                if (length === 0) return "";
                if (arguments.length === 0) return utf8Slice(this, 0, length);
                return slowToString.apply(this, arguments)
            };
            Buffer.prototype.equals = function equals(b) {
                if (!Buffer.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
                if (this === b) return true;
                return Buffer.compare(this, b) === 0
            };
            Buffer.prototype.inspect = function inspect() {
                var str = "";
                var max = exports.INSPECT_MAX_BYTES;
                if (this.length > 0) {
                    str = this.toString("hex", 0, max).match(/.{2}/g).join(" ");
                    if (this.length > max) str += " ... "
                }
                return "<Buffer " + str + ">"
            };
            Buffer.prototype.compare = function compare(b) {
                if (!Buffer.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
                if (this === b) return 0;
                return Buffer.compare(this, b)
            };
            Buffer.prototype.indexOf = function indexOf(val, byteOffset) {
                if (byteOffset > 2147483647) byteOffset = 2147483647;
                else if (byteOffset < -2147483648) byteOffset = -2147483648;
                byteOffset >>= 0;
                if (this.length === 0) return -1;
                if (byteOffset >= this.length) return -1;
                if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0);
                if (typeof val === "string") {
                    if (val.length === 0) return -1;
                    return String.prototype.indexOf.call(this, val, byteOffset)
                }
                if (Buffer.isBuffer(val)) {
                    return arrayIndexOf(this, val, byteOffset)
                }
                if (typeof val === "number") {
                    if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === "function") {
                        return Uint8Array.prototype.indexOf.call(this, val, byteOffset)
                    }
                    return arrayIndexOf(this, [val], byteOffset)
                }

                function arrayIndexOf(arr, val, byteOffset) {
                    var foundIndex = -1;
                    for (var i = 0; byteOffset + i < arr.length; i++) {
                        if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {
                            if (foundIndex === -1) foundIndex = i;
                            if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex
                        } else {
                            foundIndex = -1
                        }
                    }
                    return -1
                }
                throw new TypeError("val must be string, number or Buffer")
            };
            Buffer.prototype.get = function get(offset) {
                console.log(".get() is deprecated. Access using array indexes instead.");
                return this.readUInt8(offset)
            };
            Buffer.prototype.set = function set(v, offset) {
                console.log(".set() is deprecated. Access using array indexes instead.");
                return this.writeUInt8(v, offset)
            };

            function hexWrite(buf, string, offset, length) {
                offset = Number(offset) || 0;
                var remaining = buf.length - offset;
                if (!length) {
                    length = remaining
                } else {
                    length = Number(length);
                    if (length > remaining) {
                        length = remaining
                    }
                }
                var strLen = string.length;
                if (strLen % 2 !== 0) throw new Error("Invalid hex string");
                if (length > strLen / 2) {
                    length = strLen / 2
                }
                for (var i = 0; i < length; i++) {
                    var parsed = parseInt(string.substr(i * 2, 2), 16);
                    if (isNaN(parsed)) throw new Error("Invalid hex string");
                    buf[offset + i] = parsed
                }
                return i
            }

            function utf8Write(buf, string, offset, length) {
                return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
            }

            function asciiWrite(buf, string, offset, length) {
                return blitBuffer(asciiToBytes(string), buf, offset, length)
            }

            function binaryWrite(buf, string, offset, length) {
                return asciiWrite(buf, string, offset, length)
            }

            function base64Write(buf, string, offset, length) {
                return blitBuffer(base64ToBytes(string), buf, offset, length)
            }

            function ucs2Write(buf, string, offset, length) {
                return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
            }
            Buffer.prototype.write = function write(string, offset, length, encoding) {
                if (offset === undefined) {
                    encoding = "utf8";
                    length = this.length;
                    offset = 0
                } else if (length === undefined && typeof offset === "string") {
                    encoding = offset;
                    length = this.length;
                    offset = 0
                } else if (isFinite(offset)) {
                    offset = offset | 0;
                    if (isFinite(length)) {
                        length = length | 0;
                        if (encoding === undefined) encoding = "utf8"
                    } else {
                        encoding = length;
                        length = undefined
                    }
                } else {
                    var swap = encoding;
                    encoding = offset;
                    offset = length | 0;
                    length = swap
                }
                var remaining = this.length - offset;
                if (length === undefined || length > remaining) length = remaining;
                if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
                    throw new RangeError("attempt to write outside buffer bounds")
                }
                if (!encoding) encoding = "utf8";
                var loweredCase = false;
                for (;;) {
                    switch (encoding) {
                        case "hex":
                            return hexWrite(this, string, offset, length);
                        case "utf8":
                        case "utf-8":
                            return utf8Write(this, string, offset, length);
                        case "ascii":
                            return asciiWrite(this, string, offset, length);
                        case "binary":
                            return binaryWrite(this, string, offset, length);
                        case "base64":
                            return base64Write(this, string, offset, length);
                        case "ucs2":
                        case "ucs-2":
                        case "utf16le":
                        case "utf-16le":
                            return ucs2Write(this, string, offset, length);
                        default:
                            if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
                            encoding = ("" + encoding).toLowerCase();
                            loweredCase = true
                    }
                }
            };
            Buffer.prototype.toJSON = function toJSON() {
                return {
                    type: "Buffer",
                    data: Array.prototype.slice.call(this._arr || this, 0)
                }
            };

            function base64Slice(buf, start, end) {
                if (start === 0 && end === buf.length) {
                    return base64.fromByteArray(buf)
                } else {
                    return base64.fromByteArray(buf.slice(start, end))
                }
            }

            function utf8Slice(buf, start, end) {
                end = Math.min(buf.length, end);
                var res = [];
                var i = start;
                while (i < end) {
                    var firstByte = buf[i];
                    var codePoint = null;
                    var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
                    if (i + bytesPerSequence <= end) {
                        var secondByte, thirdByte, fourthByte, tempCodePoint;
                        switch (bytesPerSequence) {
                            case 1:
                                if (firstByte < 128) {
                                    codePoint = firstByte
                                }
                                break;
                            case 2:
                                secondByte = buf[i + 1];
                                if ((secondByte & 192) === 128) {
                                    tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
                                    if (tempCodePoint > 127) {
                                        codePoint = tempCodePoint
                                    }
                                }
                                break;
                            case 3:
                                secondByte = buf[i + 1];
                                thirdByte = buf[i + 2];
                                if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
                                    tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
                                    if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
                                        codePoint = tempCodePoint
                                    }
                                }
                                break;
                            case 4:
                                secondByte = buf[i + 1];
                                thirdByte = buf[i + 2];
                                fourthByte = buf[i + 3];
                                if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
                                    tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
                                    if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
                                        codePoint = tempCodePoint
                                    }
                                }
                        }
                    }
                    if (codePoint === null) {
                        codePoint = 65533;
                        bytesPerSequence = 1
                    } else if (codePoint > 65535) {
                        codePoint -= 65536;
                        res.push(codePoint >>> 10 & 1023 | 55296);
                        codePoint = 56320 | codePoint & 1023
                    }
                    res.push(codePoint);
                    i += bytesPerSequence
                }
                return decodeCodePointsArray(res)
            }
            var MAX_ARGUMENTS_LENGTH = 4096;

            function decodeCodePointsArray(codePoints) {
                var len = codePoints.length;
                if (len <= MAX_ARGUMENTS_LENGTH) {
                    return String.fromCharCode.apply(String, codePoints)
                }
                var res = "";
                var i = 0;
                while (i < len) {
                    res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH))
                }
                return res
            }

            function asciiSlice(buf, start, end) {
                var ret = "";
                end = Math.min(buf.length, end);
                for (var i = start; i < end; i++) {
                    ret += String.fromCharCode(buf[i] & 127)
                }
                return ret
            }

            function binarySlice(buf, start, end) {
                var ret = "";
                end = Math.min(buf.length, end);
                for (var i = start; i < end; i++) {
                    ret += String.fromCharCode(buf[i])
                }
                return ret
            }

            function hexSlice(buf, start, end) {
                var len = buf.length;
                if (!start || start < 0) start = 0;
                if (!end || end < 0 || end > len) end = len;
                var out = "";
                for (var i = start; i < end; i++) {
                    out += toHex(buf[i])
                }
                return out
            }

            function utf16leSlice(buf, start, end) {
                var bytes = buf.slice(start, end);
                var res = "";
                for (var i = 0; i < bytes.length; i += 2) {
                    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
                }
                return res
            }
            Buffer.prototype.slice = function slice(start, end) {
                var len = this.length;
                start = ~~start;
                end = end === undefined ? len : ~~end;
                if (start < 0) {
                    start += len;
                    if (start < 0) start = 0
                } else if (start > len) {
                    start = len
                }
                if (end < 0) {
                    end += len;
                    if (end < 0) end = 0
                } else if (end > len) {
                    end = len
                }
                if (end < start) end = start;
                var newBuf;
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    newBuf = Buffer._augment(this.subarray(start, end))
                } else {
                    var sliceLen = end - start;
                    newBuf = new Buffer(sliceLen, undefined);
                    for (var i = 0; i < sliceLen; i++) {
                        newBuf[i] = this[i + start]
                    }
                }
                if (newBuf.length) newBuf.parent = this.parent || this;
                return newBuf
            };

            function checkOffset(offset, ext, length) {
                if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
                if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length")
            }
            Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
                offset = offset | 0;
                byteLength = byteLength | 0;
                if (!noAssert) checkOffset(offset, byteLength, this.length);
                var val = this[offset];
                var mul = 1;
                var i = 0;
                while (++i < byteLength && (mul *= 256)) {
                    val += this[offset + i] * mul
                }
                return val
            };
            Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
                offset = offset | 0;
                byteLength = byteLength | 0;
                if (!noAssert) {
                    checkOffset(offset, byteLength, this.length)
                }
                var val = this[offset + --byteLength];
                var mul = 1;
                while (byteLength > 0 && (mul *= 256)) {
                    val += this[offset + --byteLength] * mul
                }
                return val
            };
            Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 1, this.length);
                return this[offset]
            };
            Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 2, this.length);
                return this[offset] | this[offset + 1] << 8
            };
            Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 2, this.length);
                return this[offset] << 8 | this[offset + 1]
            };
            Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length);
                return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216
            };
            Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length);
                return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3])
            };
            Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
                offset = offset | 0;
                byteLength = byteLength | 0;
                if (!noAssert) checkOffset(offset, byteLength, this.length);
                var val = this[offset];
                var mul = 1;
                var i = 0;
                while (++i < byteLength && (mul *= 256)) {
                    val += this[offset + i] * mul
                }
                mul *= 128;
                if (val >= mul) val -= Math.pow(2, 8 * byteLength);
                return val
            };
            Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
                offset = offset | 0;
                byteLength = byteLength | 0;
                if (!noAssert) checkOffset(offset, byteLength, this.length);
                var i = byteLength;
                var mul = 1;
                var val = this[offset + --i];
                while (i > 0 && (mul *= 256)) {
                    val += this[offset + --i] * mul
                }
                mul *= 128;
                if (val >= mul) val -= Math.pow(2, 8 * byteLength);
                return val
            };
            Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 1, this.length);
                if (!(this[offset] & 128)) return this[offset];
                return (255 - this[offset] + 1) * -1
            };
            Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 2, this.length);
                var val = this[offset] | this[offset + 1] << 8;
                return val & 32768 ? val | 4294901760 : val
            };
            Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 2, this.length);
                var val = this[offset + 1] | this[offset] << 8;
                return val & 32768 ? val | 4294901760 : val
            };
            Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length);
                return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24
            };
            Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length);
                return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]
            };
            Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length);
                return ieee754.read(this, offset, true, 23, 4)
            };
            Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 4, this.length);
                return ieee754.read(this, offset, false, 23, 4)
            };
            Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 8, this.length);
                return ieee754.read(this, offset, true, 52, 8)
            };
            Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
                if (!noAssert) checkOffset(offset, 8, this.length);
                return ieee754.read(this, offset, false, 52, 8)
            };

            function checkInt(buf, value, offset, ext, max, min) {
                if (!Buffer.isBuffer(buf)) throw new TypeError("buffer must be a Buffer instance");
                if (value > max || value < min) throw new RangeError("value is out of bounds");
                if (offset + ext > buf.length) throw new RangeError("index out of range")
            }
            Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
                value = +value;
                offset = offset | 0;
                byteLength = byteLength | 0;
                if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0);
                var mul = 1;
                var i = 0;
                this[offset] = value & 255;
                while (++i < byteLength && (mul *= 256)) {
                    this[offset + i] = value / mul & 255
                }
                return offset + byteLength
            };
            Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
                value = +value;
                offset = offset | 0;
                byteLength = byteLength | 0;
                if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0);
                var i = byteLength - 1;
                var mul = 1;
                this[offset + i] = value & 255;
                while (--i >= 0 && (mul *= 256)) {
                    this[offset + i] = value / mul & 255
                }
                return offset + byteLength
            };
            Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
                value = +value;
                offset = offset | 0;
                if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
                if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
                this[offset] = value & 255;
                return offset + 1
            };

            function objectWriteUInt16(buf, value, offset, littleEndian) {
                if (value < 0) value = 65535 + value + 1;
                for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
                    buf[offset + i] = (value & 255 << 8 * (littleEndian ? i : 1 - i)) >>> (littleEndian ? i : 1 - i) * 8
                }
            }
            Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
                value = +value;
                offset = offset | 0;
                if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = value & 255;
                    this[offset + 1] = value >>> 8
                } else {
                    objectWriteUInt16(this, value, offset, true)
                }
                return offset + 2
            };
            Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
                value = +value;
                offset = offset | 0;
                if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = value >>> 8;
                    this[offset + 1] = value & 255
                } else {
                    objectWriteUInt16(this, value, offset, false)
                }
                return offset + 2
            };

            function objectWriteUInt32(buf, value, offset, littleEndian) {
                if (value < 0) value = 4294967295 + value + 1;
                for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
                    buf[offset + i] = value >>> (littleEndian ? i : 3 - i) * 8 & 255
                }
            }
            Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
                value = +value;
                offset = offset | 0;
                if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset + 3] = value >>> 24;
                    this[offset + 2] = value >>> 16;
                    this[offset + 1] = value >>> 8;
                    this[offset] = value & 255
                } else {
                    objectWriteUInt32(this, value, offset, true)
                }
                return offset + 4
            };
            Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
                value = +value;
                offset = offset | 0;
                if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = value >>> 24;
                    this[offset + 1] = value >>> 16;
                    this[offset + 2] = value >>> 8;
                    this[offset + 3] = value & 255
                } else {
                    objectWriteUInt32(this, value, offset, false)
                }
                return offset + 4
            };
            Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
                value = +value;
                offset = offset | 0;
                if (!noAssert) {
                    var limit = Math.pow(2, 8 * byteLength - 1);
                    checkInt(this, value, offset, byteLength, limit - 1, -limit)
                }
                var i = 0;
                var mul = 1;
                var sub = value < 0 ? 1 : 0;
                this[offset] = value & 255;
                while (++i < byteLength && (mul *= 256)) {
                    this[offset + i] = (value / mul >> 0) - sub & 255
                }
                return offset + byteLength
            };
            Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
                value = +value;
                offset = offset | 0;
                if (!noAssert) {
                    var limit = Math.pow(2, 8 * byteLength - 1);
                    checkInt(this, value, offset, byteLength, limit - 1, -limit)
                }
                var i = byteLength - 1;
                var mul = 1;
                var sub = value < 0 ? 1 : 0;
                this[offset + i] = value & 255;
                while (--i >= 0 && (mul *= 256)) {
                    this[offset + i] = (value / mul >> 0) - sub & 255
                }
                return offset + byteLength
            };
            Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
                value = +value;
                offset = offset | 0;
                if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
                if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
                if (value < 0) value = 255 + value + 1;
                this[offset] = value & 255;
                return offset + 1
            };
            Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
                value = +value;
                offset = offset | 0;
                if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = value & 255;
                    this[offset + 1] = value >>> 8
                } else {
                    objectWriteUInt16(this, value, offset, true)
                }
                return offset + 2
            };
            Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
                value = +value;
                offset = offset | 0;
                if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = value >>> 8;
                    this[offset + 1] = value & 255
                } else {
                    objectWriteUInt16(this, value, offset, false)
                }
                return offset + 2
            };
            Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
                value = +value;
                offset = offset | 0;
                if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = value & 255;
                    this[offset + 1] = value >>> 8;
                    this[offset + 2] = value >>> 16;
                    this[offset + 3] = value >>> 24
                } else {
                    objectWriteUInt32(this, value, offset, true)
                }
                return offset + 4
            };
            Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
                value = +value;
                offset = offset | 0;
                if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
                if (value < 0) value = 4294967295 + value + 1;
                if (Buffer.TYPED_ARRAY_SUPPORT) {
                    this[offset] = value >>> 24;
                    this[offset + 1] = value >>> 16;
                    this[offset + 2] = value >>> 8;
                    this[offset + 3] = value & 255
                } else {
                    objectWriteUInt32(this, value, offset, false)
                }
                return offset + 4
            };

            function checkIEEE754(buf, value, offset, ext, max, min) {
                if (value > max || value < min) throw new RangeError("value is out of bounds");
                if (offset + ext > buf.length) throw new RangeError("index out of range");
                if (offset < 0) throw new RangeError("index out of range")
            }

            function writeFloat(buf, value, offset, littleEndian, noAssert) {
                if (!noAssert) {
                    checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22)
                }
                ieee754.write(buf, value, offset, littleEndian, 23, 4);
                return offset + 4
            }
            Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
                return writeFloat(this, value, offset, true, noAssert)
            };
            Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
                return writeFloat(this, value, offset, false, noAssert)
            };

            function writeDouble(buf, value, offset, littleEndian, noAssert) {
                if (!noAssert) {
                    checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292)
                }
                ieee754.write(buf, value, offset, littleEndian, 52, 8);
                return offset + 8
            }
            Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
                return writeDouble(this, value, offset, true, noAssert)
            };
            Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
                return writeDouble(this, value, offset, false, noAssert)
            };
            Buffer.prototype.copy = function copy(target, targetStart, start, end) {
                if (!start) start = 0;
                if (!end && end !== 0) end = this.length;
                if (targetStart >= target.length) targetStart = target.length;
                if (!targetStart) targetStart = 0;
                if (end > 0 && end < start) end = start;
                if (end === start) return 0;
                if (target.length === 0 || this.length === 0) return 0;
                if (targetStart < 0) {
                    throw new RangeError("targetStart out of bounds")
                }
                if (start < 0 || start >= this.length) throw new RangeError("sourceStart out of bounds");
                if (end < 0) throw new RangeError("sourceEnd out of bounds");
                if (end > this.length) end = this.length;
                if (target.length - targetStart < end - start) {
                    end = target.length - targetStart + start
                }
                var len = end - start;
                var i;
                if (this === target && start < targetStart && targetStart < end) {
                    for (i = len - 1; i >= 0; i--) {
                        target[i + targetStart] = this[i + start]
                    }
                } else if (len < 1e3 || !Buffer.TYPED_ARRAY_SUPPORT) {
                    for (i = 0; i < len; i++) {
                        target[i + targetStart] = this[i + start]
                    }
                } else {
                    target._set(this.subarray(start, start + len), targetStart)
                }
                return len
            };
            Buffer.prototype.fill = function fill(value, start, end) {
                if (!value) value = 0;
                if (!start) start = 0;
                if (!end) end = this.length;
                if (end < start) throw new RangeError("end < start");
                if (end === start) return;
                if (this.length === 0) return;
                if (start < 0 || start >= this.length) throw new RangeError("start out of bounds");
                if (end < 0 || end > this.length) throw new RangeError("end out of bounds");
                var i;
                if (typeof value === "number") {
                    for (i = start; i < end; i++) {
                        this[i] = value
                    }
                } else {
                    var bytes = utf8ToBytes(value.toString());
                    var len = bytes.length;
                    for (i = start; i < end; i++) {
                        this[i] = bytes[i % len]
                    }
                }
                return this
            };
            Buffer.prototype.toArrayBuffer = function toArrayBuffer() {
                if (typeof Uint8Array !== "undefined") {
                    if (Buffer.TYPED_ARRAY_SUPPORT) {
                        return new Buffer(this).buffer
                    } else {
                        var buf = new Uint8Array(this.length);
                        for (var i = 0, len = buf.length; i < len; i += 1) {
                            buf[i] = this[i]
                        }
                        return buf.buffer
                    }
                } else {
                    throw new TypeError("Buffer.toArrayBuffer not supported in this browser")
                }
            };
            var BP = Buffer.prototype;
            Buffer._augment = function _augment(arr) {
                arr.constructor = Buffer;
                arr._isBuffer = true;
                arr._set = arr.set;
                arr.get = BP.get;
                arr.set = BP.set;
                arr.write = BP.write;
                arr.toString = BP.toString;
                arr.toLocaleString = BP.toString;
                arr.toJSON = BP.toJSON;
                arr.equals = BP.equals;
                arr.compare = BP.compare;
                arr.indexOf = BP.indexOf;
                arr.copy = BP.copy;
                arr.slice = BP.slice;
                arr.readUIntLE = BP.readUIntLE;
                arr.readUIntBE = BP.readUIntBE;
                arr.readUInt8 = BP.readUInt8;
                arr.readUInt16LE = BP.readUInt16LE;
                arr.readUInt16BE = BP.readUInt16BE;
                arr.readUInt32LE = BP.readUInt32LE;
                arr.readUInt32BE = BP.readUInt32BE;
                arr.readIntLE = BP.readIntLE;
                arr.readIntBE = BP.readIntBE;
                arr.readInt8 = BP.readInt8;
                arr.readInt16LE = BP.readInt16LE;
                arr.readInt16BE = BP.readInt16BE;
                arr.readInt32LE = BP.readInt32LE;
                arr.readInt32BE = BP.readInt32BE;
                arr.readFloatLE = BP.readFloatLE;
                arr.readFloatBE = BP.readFloatBE;
                arr.readDoubleLE = BP.readDoubleLE;
                arr.readDoubleBE = BP.readDoubleBE;
                arr.writeUInt8 = BP.writeUInt8;
                arr.writeUIntLE = BP.writeUIntLE;
                arr.writeUIntBE = BP.writeUIntBE;
                arr.writeUInt16LE = BP.writeUInt16LE;
                arr.writeUInt16BE = BP.writeUInt16BE;
                arr.writeUInt32LE = BP.writeUInt32LE;
                arr.writeUInt32BE = BP.writeUInt32BE;
                arr.writeIntLE = BP.writeIntLE;
                arr.writeIntBE = BP.writeIntBE;
                arr.writeInt8 = BP.writeInt8;
                arr.writeInt16LE = BP.writeInt16LE;
                arr.writeInt16BE = BP.writeInt16BE;
                arr.writeInt32LE = BP.writeInt32LE;
                arr.writeInt32BE = BP.writeInt32BE;
                arr.writeFloatLE = BP.writeFloatLE;
                arr.writeFloatBE = BP.writeFloatBE;
                arr.writeDoubleLE = BP.writeDoubleLE;
                arr.writeDoubleBE = BP.writeDoubleBE;
                arr.fill = BP.fill;
                arr.inspect = BP.inspect;
                arr.toArrayBuffer = BP.toArrayBuffer;
                return arr
            };
            var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;

            function base64clean(str) {
                str = stringtrim(str).replace(INVALID_BASE64_RE, "");
                if (str.length < 2) return "";
                while (str.length % 4 !== 0) {
                    str = str + "="
                }
                return str
            }

            function stringtrim(str) {
                if (str.trim) return str.trim();
                return str.replace(/^\s+|\s+$/g, "")
            }

            function toHex(n) {
                if (n < 16) return "0" + n.toString(16);
                return n.toString(16)
            }

            function utf8ToBytes(string, units) {
                units = units || Infinity;
                var codePoint;
                var length = string.length;
                var leadSurrogate = null;
                var bytes = [];
                for (var i = 0; i < length; i++) {
                    codePoint = string.charCodeAt(i);
                    if (codePoint > 55295 && codePoint < 57344) {
                        if (!leadSurrogate) {
                            if (codePoint > 56319) {
                                if ((units -= 3) > -1) bytes.push(239, 191, 189);
                                continue
                            } else if (i + 1 === length) {
                                if ((units -= 3) > -1) bytes.push(239, 191, 189);
                                continue
                            }
                            leadSurrogate = codePoint;
                            continue
                        }
                        if (codePoint < 56320) {
                            if ((units -= 3) > -1) bytes.push(239, 191, 189);
                            leadSurrogate = codePoint;
                            continue
                        }
                        codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536
                    } else if (leadSurrogate) {
                        if ((units -= 3) > -1) bytes.push(239, 191, 189)
                    }
                    leadSurrogate = null;
                    if (codePoint < 128) {
                        if ((units -= 1) < 0) break;
                        bytes.push(codePoint)
                    } else if (codePoint < 2048) {
                        if ((units -= 2) < 0) break;
                        bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128)
                    } else if (codePoint < 65536) {
                        if ((units -= 3) < 0) break;
                        bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128)
                    } else if (codePoint < 1114112) {
                        if ((units -= 4) < 0) break;
                        bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128)
                    } else {
                        throw new Error("Invalid code point")
                    }
                }
                return bytes
            }

            function asciiToBytes(str) {
                var byteArray = [];
                for (var i = 0; i < str.length; i++) {
                    byteArray.push(str.charCodeAt(i) & 255)
                }
                return byteArray
            }

            function utf16leToBytes(str, units) {
                var c, hi, lo;
                var byteArray = [];
                for (var i = 0; i < str.length; i++) {
                    if ((units -= 2) < 0) break;
                    c = str.charCodeAt(i);
                    hi = c >> 8;
                    lo = c % 256;
                    byteArray.push(lo);
                    byteArray.push(hi)
                }
                return byteArray
            }

            function base64ToBytes(str) {
                return base64.toByteArray(base64clean(str))
            }

            function blitBuffer(src, dst, offset, length) {
                for (var i = 0; i < length; i++) {
                    if (i + offset >= dst.length || i >= src.length) break;
                    dst[i + offset] = src[i]
                }
                return i
            }
        }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
    }, {
        "base64-js": 281,
        ieee754: 282,
        isarray: 283
    }],
    281: [function(require, module, exports) {
        var lookup = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        (function(exports) {
            "use strict";
            var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
            var PLUS = "+".charCodeAt(0);
            var SLASH = "/".charCodeAt(0);
            var NUMBER = "0".charCodeAt(0);
            var LOWER = "a".charCodeAt(0);
            var UPPER = "A".charCodeAt(0);
            var PLUS_URL_SAFE = "-".charCodeAt(0);
            var SLASH_URL_SAFE = "_".charCodeAt(0);

            function decode(elt) {
                var code = elt.charCodeAt(0);
                if (code === PLUS || code === PLUS_URL_SAFE) return 62;
                if (code === SLASH || code === SLASH_URL_SAFE) return 63;
                if (code < NUMBER) return -1;
                if (code < NUMBER + 10) return code - NUMBER + 26 + 26;
                if (code < UPPER + 26) return code - UPPER;
                if (code < LOWER + 26) return code - LOWER + 26
            }

            function b64ToByteArray(b64) {
                var i, j, l, tmp, placeHolders, arr;
                if (b64.length % 4 > 0) {
                    throw new Error("Invalid string. Length must be a multiple of 4")
                }
                var len = b64.length;
                placeHolders = "=" === b64.charAt(len - 2) ? 2 : "=" === b64.charAt(len - 1) ? 1 : 0;
                arr = new Arr(b64.length * 3 / 4 - placeHolders);
                l = placeHolders > 0 ? b64.length - 4 : b64.length;
                var L = 0;

                function push(v) {
                    arr[L++] = v
                }
                for (i = 0, j = 0; i < l; i += 4, j += 3) {
                    tmp = decode(b64.charAt(i)) << 18 | decode(b64.charAt(i + 1)) << 12 | decode(b64.charAt(i + 2)) << 6 | decode(b64.charAt(i + 3));
                    push((tmp & 16711680) >> 16);
                    push((tmp & 65280) >> 8);
                    push(tmp & 255)
                }
                if (placeHolders === 2) {
                    tmp = decode(b64.charAt(i)) << 2 | decode(b64.charAt(i + 1)) >> 4;
                    push(tmp & 255)
                } else if (placeHolders === 1) {
                    tmp = decode(b64.charAt(i)) << 10 | decode(b64.charAt(i + 1)) << 4 | decode(b64.charAt(i + 2)) >> 2;
                    push(tmp >> 8 & 255);
                    push(tmp & 255)
                }
                return arr
            }

            function uint8ToBase64(uint8) {
                var i, extraBytes = uint8.length % 3,
                    output = "",
                    temp, length;

                function encode(num) {
                    return lookup.charAt(num)
                }

                function tripletToBase64(num) {
                    return encode(num >> 18 & 63) + encode(num >> 12 & 63) + encode(num >> 6 & 63) + encode(num & 63)
                }
                for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
                    temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2];
                    output += tripletToBase64(temp)
                }
                switch (extraBytes) {
                    case 1:
                        temp = uint8[uint8.length - 1];
                        output += encode(temp >> 2);
                        output += encode(temp << 4 & 63);
                        output += "==";
                        break;
                    case 2:
                        temp = (uint8[uint8.length - 2] << 8) + uint8[uint8.length - 1];
                        output += encode(temp >> 10);
                        output += encode(temp >> 4 & 63);
                        output += encode(temp << 2 & 63);
                        output += "=";
                        break
                }
                return output
            }
            exports.toByteArray = b64ToByteArray;
            exports.fromByteArray = uint8ToBase64
        })(typeof exports === "undefined" ? this.base64js = {} : exports)
    }, {}],
    282: [function(require, module, exports) {
        exports.read = function(buffer, offset, isLE, mLen, nBytes) {
            var e, m;
            var eLen = nBytes * 8 - mLen - 1;
            var eMax = (1 << eLen) - 1;
            var eBias = eMax >> 1;
            var nBits = -7;
            var i = isLE ? nBytes - 1 : 0;
            var d = isLE ? -1 : 1;
            var s = buffer[offset + i];
            i += d;
            e = s & (1 << -nBits) - 1;
            s >>= -nBits;
            nBits += eLen;
            for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
            m = e & (1 << -nBits) - 1;
            e >>= -nBits;
            nBits += mLen;
            for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
            if (e === 0) {
                e = 1 - eBias
            } else if (e === eMax) {
                return m ? NaN : (s ? -1 : 1) * Infinity
            } else {
                m = m + Math.pow(2, mLen);
                e = e - eBias
            }
            return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
        };
        exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
            var e, m, c;
            var eLen = nBytes * 8 - mLen - 1;
            var eMax = (1 << eLen) - 1;
            var eBias = eMax >> 1;
            var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
            var i = isLE ? 0 : nBytes - 1;
            var d = isLE ? 1 : -1;
            var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
            value = Math.abs(value);
            if (isNaN(value) || value === Infinity) {
                m = isNaN(value) ? 1 : 0;
                e = eMax
            } else {
                e = Math.floor(Math.log(value) / Math.LN2);
                if (value * (c = Math.pow(2, -e)) < 1) {
                    e--;
                    c *= 2
                }
                if (e + eBias >= 1) {
                    value += rt / c
                } else {
                    value += rt * Math.pow(2, 1 - eBias)
                }
                if (value * c >= 2) {
                    e++;
                    c /= 2
                }
                if (e + eBias >= eMax) {
                    m = 0;
                    e = eMax
                } else if (e + eBias >= 1) {
                    m = (value * c - 1) * Math.pow(2, mLen);
                    e = e + eBias
                } else {
                    m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
                    e = 0
                }
            }
            for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {}
            e = e << mLen | m;
            eLen += mLen;
            for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {}
            buffer[offset + i - d] |= s * 128
        }
    }, {}],
    283: [function(require, module, exports) {
        var toString = {}.toString;
        module.exports = Array.isArray || function(arr) {
            return toString.call(arr) == "[object Array]"
        }
    }, {}],
    284: [function(require, module, exports) {
        arguments[4][1][0].apply(exports, arguments)
    }, {
        "./ac-console/log": 285,
        dup: 1
    }],
    285: [function(require, module, exports) {
        arguments[4][2][0].apply(exports, arguments)
    }, {
        dup: 2
    }],
    286: [function(require, module, exports) {
        arguments[4][3][0].apply(exports, arguments)
    }, {
        "./shared/getEventType": 296,
        "./utils/addEventListener": 300,
        dup: 3
    }],
    287: [function(require, module, exports) {
        arguments[4][232][0].apply(exports, arguments)
    }, {
        "./shared/getEventType": 296,
        "./utils/dispatchEvent": 301,
        dup: 232
    }],
    288: [function(require, module, exports) {
        arguments[4][233][0].apply(exports, arguments)
    }, {
        "./addEventListener": 286,
        "./dispatchEvent": 287,
        "./preventDefault": 294,
        "./removeEventListener": 295,
        "./stop": 297,
        "./stopPropagation": 298,
        "./target": 299,
        dup: 233
    }],
    289: [function(require, module, exports) {
        arguments[4][4][0].apply(exports, arguments)
    }, {
        "./shared/camelCasedEventTypes": 290,
        "./shared/prefixHelper": 291,
        "./shared/windowFallbackEventTypes": 292,
        "./utils/eventTypeAvailable": 293,
        dup: 4
    }],
    290: [function(require, module, exports) {
        arguments[4][5][0].apply(exports, arguments)
    }, {
        dup: 5
    }],
    291: [function(require, module, exports) {
        arguments[4][6][0].apply(exports, arguments)
    }, {
        dup: 6
    }],
    292: [function(require, module, exports) {
        arguments[4][7][0].apply(exports, arguments)
    }, {
        dup: 7
    }],
    293: [function(require, module, exports) {
        arguments[4][8][0].apply(exports, arguments)
    }, {
        dup: 8
    }],
    294: [function(require, module, exports) {
        arguments[4][239][0].apply(exports, arguments)
    }, {
        dup: 239
    }],
    295: [function(require, module, exports) {
        arguments[4][9][0].apply(exports, arguments)
    }, {
        "./shared/getEventType": 296,
        "./utils/removeEventListener": 302,
        dup: 9
    }],
    296: [function(require, module, exports) {
        arguments[4][10][0].apply(exports, arguments)
    }, {
        "@marcom/ac-prefixer/getEventType": 289,
        dup: 10
    }],
    297: [function(require, module, exports) {
        arguments[4][242][0].apply(exports, arguments)
    }, {
        "./preventDefault": 294,
        "./stopPropagation": 298,
        dup: 242
    }],
    298: [function(require, module, exports) {
        arguments[4][243][0].apply(exports, arguments)
    }, {
        dup: 243
    }],
    299: [function(require, module, exports) {
        arguments[4][200][0].apply(exports, arguments)
    }, {
        dup: 200
    }],
    300: [function(require, module, exports) {
        arguments[4][11][0].apply(exports, arguments)
    }, {
        dup: 11
    }],
    301: [function(require, module, exports) {
        arguments[4][246][0].apply(exports, arguments)
    }, {
        "@marcom/ac-polyfills/CustomEvent": 391,
        dup: 246
    }],
    302: [function(require, module, exports) {
        arguments[4][12][0].apply(exports, arguments)
    }, {
        dup: 12
    }],
    303: [function(require, module, exports) {
        "use strict";
        module.exports = {
            getContentDimensions: require("./getContentDimensions"),
            getDimensions: require("./getDimensions"),
            getPagePosition: require("./getPagePosition"),
            getPercentInViewport: require("./getPercentInViewport"),
            getPixelsInViewport: require("./getPixelsInViewport"),
            getPosition: require("./getPosition"),
            getScrollX: require("./getScrollX"),
            getScrollY: require("./getScrollY"),
            getViewportPosition: require("./getViewportPosition"),
            isInViewport: require("./isInViewport")
        }
    }, {
        "./getContentDimensions": 304,
        "./getDimensions": 305,
        "./getPagePosition": 306,
        "./getPercentInViewport": 307,
        "./getPixelsInViewport": 308,
        "./getPosition": 309,
        "./getScrollX": 310,
        "./getScrollY": 311,
        "./getViewportPosition": 312,
        "./isInViewport": 313
    }],
    304: [function(require, module, exports) {
        "use strict";
        var getBoundingClientRect = require("./utils/getBoundingClientRect");
        module.exports = function getContentDimensions(el, rendered) {
            var scale = 1;
            if (rendered) {
                scale = getBoundingClientRect(el).width / el.offsetWidth
            }
            return {
                width: el.scrollWidth * scale,
                height: el.scrollHeight * scale
            }
        }
    }, {
        "./utils/getBoundingClientRect": 314
    }],
    305: [function(require, module, exports) {
        arguments[4][69][0].apply(exports, arguments)
    }, {
        "./utils/getBoundingClientRect": 314,
        dup: 69
    }],
    306: [function(require, module, exports) {
        "use strict";
        var getDimensions = require("./getDimensions");
        var getBoundingClientRect = require("./utils/getBoundingClientRect");
        var getScrollX = require("./getScrollX");
        var getScrollY = require("./getScrollY");
        module.exports = function getPagePosition(el, rendered) {
            var rect;
            var scrollX;
            var scrollY;
            var dimensions;
            if (rendered) {
                rect = getBoundingClientRect(el);
                scrollX = getScrollX();
                scrollY = getScrollY();
                return {
                    top: rect.top + scrollY,
                    right: rect.right + scrollX,
                    bottom: rect.bottom + scrollY,
                    left: rect.left + scrollX
                }
            }
            dimensions = getDimensions(el, rendered);
            rect = {
                top: el.offsetTop,
                left: el.offsetLeft,
                width: dimensions.width,
                height: dimensions.height
            };
            while (el = el.offsetParent) {
                rect.top += el.offsetTop;
                rect.left += el.offsetLeft
            }
            return {
                top: rect.top,
                right: rect.left + rect.width,
                bottom: rect.top + rect.height,
                left: rect.left
            }
        }
    }, {
        "./getDimensions": 305,
        "./getScrollX": 310,
        "./getScrollY": 311,
        "./utils/getBoundingClientRect": 314
    }],
    307: [function(require, module, exports) {
        "use strict";
        var getDimensions = require("./getDimensions");
        var getPixelsInViewport = require("./getPixelsInViewport");
        module.exports = function getPercentInViewport(el, rendered) {
            var inViewport = getPixelsInViewport(el, rendered);
            var height = getDimensions(el, rendered).height;
            return inViewport / height
        }
    }, {
        "./getDimensions": 305,
        "./getPixelsInViewport": 308
    }],
    308: [function(require, module, exports) {
        "use strict";
        var getViewportPosition = require("./getViewportPosition");
        module.exports = function getPixelsInViewport(el, rendered) {
            var vh = document.documentElement.clientHeight;
            var position = getViewportPosition(el, rendered);
            var pixels;
            if (position.top >= vh || position.bottom <= 0) {
                return 0
            }
            pixels = position.bottom - position.top;
            if (position.top < 0) {
                pixels += position.top
            }
            if (position.bottom > vh) {
                pixels -= position.bottom - vh
            }
            return pixels
        }
    }, {
        "./getViewportPosition": 312
    }],
    309: [function(require, module, exports) {
        "use strict";
        var getDimensions = require("./getDimensions");
        var getBoundingClientRect = require("./utils/getBoundingClientRect");
        module.exports = function getPosition(el, rendered) {
            var rect;
            var parentRect;
            var dimensions;
            if (rendered) {
                rect = getBoundingClientRect(el);
                if (el.offsetParent) {
                    parentRect = getBoundingClientRect(el.offsetParent);
                    rect.top -= parentRect.top;
                    rect.left -= parentRect.left
                }
            } else {
                dimensions = getDimensions(el, rendered);
                rect = {
                    top: el.offsetTop,
                    left: el.offsetLeft,
                    width: dimensions.width,
                    height: dimensions.height
                }
            }
            return {
                top: rect.top,
                right: rect.left + rect.width,
                bottom: rect.top + rect.height,
                left: rect.left
            }
        }
    }, {
        "./getDimensions": 305,
        "./utils/getBoundingClientRect": 314
    }],
    310: [function(require, module, exports) {
        arguments[4][203][0].apply(exports, arguments)
    }, {
        dup: 203
    }],
    311: [function(require, module, exports) {
        arguments[4][204][0].apply(exports, arguments)
    }, {
        dup: 204
    }],
    312: [function(require, module, exports) {
        "use strict";
        var getPagePosition = require("./getPagePosition");
        var getBoundingClientRect = require("./utils/getBoundingClientRect");
        var getScrollX = require("./getScrollX");
        var getScrollY = require("./getScrollY");
        module.exports = function getViewportPosition(el, rendered) {
            var position;
            var scrollX;
            var scrollY;
            if (rendered) {
                position = getBoundingClientRect(el);
                return {
                    top: position.top,
                    right: position.right,
                    bottom: position.bottom,
                    left: position.left
                }
            }
            position = getPagePosition(el);
            scrollX = getScrollX();
            scrollY = getScrollY();
            return {
                top: position.top - scrollY,
                right: position.right - scrollX,
                bottom: position.bottom - scrollY,
                left: position.left - scrollX
            }
        }
    }, {
        "./getPagePosition": 306,
        "./getScrollX": 310,
        "./getScrollY": 311,
        "./utils/getBoundingClientRect": 314
    }],
    313: [function(require, module, exports) {
        "use strict";
        var getPixelsInViewport = require("./getPixelsInViewport");
        var getPercentInViewport = require("./getPercentInViewport");
        module.exports = function isInViewport(el, rendered, threshold) {
            var inViewport;
            threshold = threshold || 0;
            if (typeof threshold === "string" && threshold.slice(-2) === "px") {
                threshold = parseInt(threshold, 10);
                inViewport = getPixelsInViewport(el, rendered)
            } else {
                inViewport = getPercentInViewport(el, rendered)
            }
            return inViewport > 0 && inViewport >= threshold
        }
    }, {
        "./getPercentInViewport": 307,
        "./getPixelsInViewport": 308
    }],
    314: [function(require, module, exports) {
        arguments[4][70][0].apply(exports, arguments)
    }, {
        dup: 70
    }],
    315: [function(require, module, exports) {
        arguments[4][15][0].apply(exports, arguments)
    }, {
        dup: 15
    }],
    316: [function(require, module, exports) {
        arguments[4][215][0].apply(exports, arguments)
    }, {
        "./extend": 317,
        dup: 215
    }],
    317: [function(require, module, exports) {
        arguments[4][16][0].apply(exports, arguments)
    }, {
        "@marcom/ac-polyfills/Array/prototype.forEach": 387,
        dup: 16
    }],
    318: [function(require, module, exports) {
        var ElementEngagement = require("./ac-element-engagement/ElementEngagement");
        module.exports = new ElementEngagement;
        module.exports.ElementEngagement = ElementEngagement
    }, {
        "./ac-element-engagement/ElementEngagement": 319
    }],
    319: [function(require, module, exports) {
        "use strict";
        var proto;
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var ac_Object = {
            create: require("@marcom/ac-object/create"),
            defaults: require("@marcom/ac-object/defaults"),
            extend: require("@marcom/ac-object/extend")
        };
        var Super = require("@marcom/ac-element-tracker").ElementTracker;
        var trackedElementDefaults = {
            timeToEngage: 500,
            inViewThreshold: .75,
            stopOnEngaged: true
        };
        var extendedTrackedElementProps = {
            thresholdEnterTime: 0,
            thresholdExitTime: 0,
            inThreshold: false,
            engaged: false,
            tracking: true
        };
        var ElementEngagement = function(options) {
            Super.call(this, null, options);
            EventEmitterMicro.call(this);
            this._thresholdEnter = this._thresholdEnter.bind(this);
            this._thresholdExit = this._thresholdExit.bind(this);
            this._enterView = this._enterView.bind(this);
            this._exitView = this._exitView.bind(this)
        };
        proto = ElementEngagement.prototype = ac_Object.create(Super.prototype);
        proto = ac_Object.extend(proto, EventEmitterMicro.prototype);
        proto._decorateTrackedElement = function(trackedElement, options) {
            var extendedDefaults;
            extendedDefaults = ac_Object.defaults(trackedElementDefaults, options || {});
            ac_Object.extend(trackedElement, extendedDefaults);
            ac_Object.extend(trackedElement, extendedTrackedElementProps)
        };
        proto._attachElementListeners = function(trackedElement) {
            trackedElement.on("thresholdenter", this._thresholdEnter, this);
            trackedElement.on("thresholdexit", this._thresholdExit, this);
            trackedElement.on("enterview", this._enterView, this);
            trackedElement.on("exitview", this._exitView, this)
        };
        proto._removeElementListeners = function(trackedElement) {
            trackedElement.off("thresholdenter", this._thresholdEnter);
            trackedElement.off("thresholdexit", this._thresholdExit);
            trackedElement.off("enterview", this._enterView);
            trackedElement.off("exitview", this._exitView)
        };
        proto._attachAllElementListeners = function() {
            this.elements.forEach(function(trackedElement) {
                if (!trackedElement.stopOnEngaged) {
                    this._attachElementListeners(trackedElement)
                } else if (!trackedElement.engaged) {
                    this._attachElementListeners(trackedElement)
                }
            }, this)
        };
        proto._removeAllElementListeners = function() {
            this.elements.forEach(function(trackedElement) {
                this._removeElementListeners(trackedElement)
            }, this)
        };
        proto._elementInViewPastThreshold = function(trackedElement) {
            var winHeight = document.documentElement.clientHeight || window.innerHeight;
            var isIt = false;
            if (trackedElement.pixelsInView === winHeight) {
                isIt = true
            } else {
                isIt = trackedElement.percentInView > trackedElement.inViewThreshold
            }
            return isIt
        };
        proto._ifInView = function(trackedElement, alreadyInView) {
            var alreadyInThreshold = trackedElement.inThreshold;
            Super.prototype._ifInView.apply(this, arguments);
            if (!alreadyInThreshold && this._elementInViewPastThreshold(trackedElement)) {
                trackedElement.inThreshold = true;
                trackedElement.trigger("thresholdenter", trackedElement);
                if (typeof trackedElement.timeToEngage === "number" && trackedElement.timeToEngage >= 0) {
                    trackedElement.engagedTimeout = window.setTimeout(this._engaged.bind(this, trackedElement), trackedElement.timeToEngage)
                }
            }
        };
        proto._ifAlreadyInView = function(trackedElement) {
            var alreadyInThreshold = trackedElement.inThreshold;
            Super.prototype._ifAlreadyInView.apply(this, arguments);
            if (alreadyInThreshold && !this._elementInViewPastThreshold(trackedElement)) {
                trackedElement.inThreshold = false;
                trackedElement.trigger("thresholdexit", trackedElement);
                if (trackedElement.engagedTimeout) {
                    window.clearTimeout(trackedElement.engagedTimeout);
                    trackedElement.engagedTimeout = null
                }
            }
        };
        proto._engaged = function(trackedElement) {
            trackedElement.engagedTimeout = null;
            this._elementEngaged(trackedElement);
            trackedElement.trigger("engaged", trackedElement);
            this.trigger("engaged", trackedElement)
        };
        proto._thresholdEnter = function(trackedElement) {
            trackedElement.thresholdEnterTime = Date.now();
            trackedElement.thresholdExitTime = 0;
            this.trigger("thresholdenter", trackedElement)
        };
        proto._thresholdExit = function(trackedElement) {
            trackedElement.thresholdExitTime = Date.now();
            this.trigger("thresholdexit", trackedElement)
        };
        proto._enterView = function(trackedElement) {
            this.trigger("enterview", trackedElement)
        };
        proto._exitView = function(trackedElement) {
            this.trigger("exitview", trackedElement)
        };
        proto._elementEngaged = function(trackedElement) {
            trackedElement.engaged = true;
            if (trackedElement.stopOnEngaged) {
                this.stop(trackedElement)
            }
        };
        proto.stop = function(trackedElement) {
            if (this.tracking && !trackedElement) {
                this._removeAllElementListeners();
                Super.prototype.stop.call(this)
            }
            if (trackedElement && trackedElement.tracking) {
                trackedElement.tracking = false;
                this._removeElementListeners(trackedElement)
            }
        };
        proto.start = function(trackedElement) {
            if (!trackedElement) {
                this._attachAllElementListeners()
            }
            if (trackedElement && !trackedElement.tracking) {
                if (!trackedElement.stopOnEngaged) {
                    trackedElement.tracking = true;
                    this._attachElementListeners(trackedElement)
                } else if (!trackedElement.engaged) {
                    trackedElement.tracking = true;
                    this._attachElementListeners(trackedElement)
                }
            }
            if (!this.tracking) {
                Super.prototype.start.call(this)
            } else {
                this.refreshAllElementMetrics();
                this.refreshAllElementStates()
            }
        };
        proto.addElement = function(element, options) {
            options = options || {};
            var trackedElement = Super.prototype.addElement.call(this, element, options.useRenderedPosition);
            this._decorateTrackedElement(trackedElement, options);
            return trackedElement
        };
        proto.addElements = function(collection, options) {
            [].forEach.call(collection, function(element) {
                this.addElement(element, options)
            }, this)
        };
        module.exports = ElementEngagement
    }, {
        "@marcom/ac-element-tracker": 366,
        "@marcom/ac-event-emitter-micro": 369,
        "@marcom/ac-object/create": 315,
        "@marcom/ac-object/defaults": 316,
        "@marcom/ac-object/extend": 317
    }],
    320: [function(require, module, exports) {
        "use strict";
        module.exports = {
            flatten: require("./flatten"),
            intersection: require("./intersection"),
            shuffle: require("./shuffle"),
            toArray: require("./toArray"),
            union: require("./union"),
            unique: require("./unique"),
            without: require("./without")
        }
    }, {
        "./flatten": 321,
        "./intersection": 322,
        "./shuffle": 323,
        "./toArray": 324,
        "./union": 325,
        "./unique": 326,
        "./without": 327
    }],
    321: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/isArray");
        require("@marcom/ac-polyfills/Array/prototype.forEach");
        module.exports = function flatten(array) {
            var flattenedArray = [];
            var callback = function(item) {
                if (Array.isArray(item)) {
                    item.forEach(callback)
                } else {
                    flattenedArray.push(item)
                }
            };
            array.forEach(callback);
            return flattenedArray
        }
    }, {
        "@marcom/ac-polyfills/Array/isArray": 384,
        "@marcom/ac-polyfills/Array/prototype.forEach": 387
    }],
    322: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.indexOf");
        module.exports = function intersection(array) {
            if (!array) {
                return []
            }
            var argsLength = arguments.length;
            var i = 0;
            var len = array.length;
            var result = [];
            var item;
            for (i; i < len; i++) {
                item = array[i];
                if (result.indexOf(item) > -1) {
                    continue
                }
                for (var j = 1; j < argsLength; j++) {
                    if (arguments[j].indexOf(item) < 0) {
                        break
                    }
                }
                if (j === argsLength) {
                    result.push(item)
                }
            }
            return result
        }
    }, {
        "@marcom/ac-polyfills/Array/prototype.indexOf": 388
    }],
    323: [function(require, module, exports) {
        "use strict";
        module.exports = function shuffle(array) {
            var len = array.length;
            var index;
            var temp;
            while (len) {
                index = Math.floor(Math.random() * len--);
                temp = array[len];
                array[len] = array[index];
                array[index] = temp
            }
            return array
        }
    }, {}],
    324: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.slice");
        module.exports = function toArray(arrayLike) {
            return Array.prototype.slice.call(arrayLike)
        }
    }, {
        "@marcom/ac-polyfills/Array/prototype.slice": 390
    }],
    325: [function(require, module, exports) {
        "use strict";
        var flatten = require("./flatten");
        var toArray = require("./toArray");
        var unique = require("./unique");
        module.exports = function union(array) {
            return unique(flatten(toArray(arguments)))
        }
    }, {
        "./flatten": 321,
        "./toArray": 324,
        "./unique": 326
    }],
    326: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.indexOf");
        require("@marcom/ac-polyfills/Array/prototype.reduce");
        module.exports = function unique(array) {
            var _unique = function(prev, current) {
                if (prev.indexOf(current) < 0) {
                    prev.push(current)
                }
                return prev
            };
            return array.reduce(_unique, [])
        }
    }, {
        "@marcom/ac-polyfills/Array/prototype.indexOf": 388,
        "@marcom/ac-polyfills/Array/prototype.reduce": 389
    }],
    327: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.indexOf");
        require("@marcom/ac-polyfills/Array/prototype.slice");
        module.exports = function without(arr, value, recurse) {
            var newArr;
            var index = arr.indexOf(value);
            var length = arr.length;
            if (index >= 0) {
                if (recurse) {
                    newArr = arr.slice(0, length);
                    var amountRemoved = 0;
                    for (var i = index; i < length; i++) {
                        if (arr[i] === value) {
                            newArr.splice(i - amountRemoved, 1);
                            amountRemoved++
                        }
                    }
                } else if (index === length - 1) {
                    newArr = arr.slice(0, length - 1)
                } else if (index === 0) {
                    newArr = arr.slice(1)
                } else {
                    newArr = arr.slice(0, index);
                    newArr = newArr.concat(arr.slice(index + 1))
                }
            } else {
                return arr
            }
            return newArr
        }
    }, {
        "@marcom/ac-polyfills/Array/prototype.indexOf": 388,
        "@marcom/ac-polyfills/Array/prototype.slice": 390
    }],
    328: [function(require, module, exports) {
        arguments[4][24][0].apply(exports, arguments)
    }, {
        dup: 24
    }],
    329: [function(require, module, exports) {
        arguments[4][25][0].apply(exports, arguments)
    }, {
        dup: 25
    }],
    330: [function(require, module, exports) {
        arguments[4][26][0].apply(exports, arguments)
    }, {
        dup: 26
    }],
    331: [function(require, module, exports) {
        "use strict";
        module.exports = 10
    }, {}],
    332: [function(require, module, exports) {
        arguments[4][27][0].apply(exports, arguments)
    }, {
        dup: 27
    }],
    333: [function(require, module, exports) {
        arguments[4][28][0].apply(exports, arguments)
    }, {
        dup: 28
    }],
    334: [function(require, module, exports) {
        "use strict";
        module.exports = {
            createDocumentFragment: require("./createDocumentFragment"),
            filterByNodeType: require("./filterByNodeType"),
            hasAttribute: require("./hasAttribute"),
            indexOf: require("./indexOf"),
            insertAfter: require("./insertAfter"),
            insertBefore: require("./insertBefore"),
            insertFirstChild: require("./insertFirstChild"),
            insertLastChild: require("./insertLastChild"),
            isComment: require("./isComment"),
            isDocument: require("./isDocument"),
            isDocumentFragment: require("./isDocumentFragment"),
            isDocumentType: require("./isDocumentType"),
            isElement: require("./isElement"),
            isNode: require("./isNode"),
            isNodeList: require("./isNodeList"),
            isTextNode: require("./isTextNode"),
            remove: require("./remove"),
            replace: require("./replace"),
            COMMENT_NODE: require("./COMMENT_NODE"),
            DOCUMENT_FRAGMENT_NODE: require("./DOCUMENT_FRAGMENT_NODE"),
            DOCUMENT_NODE: require("./DOCUMENT_NODE"),
            DOCUMENT_TYPE_NODE: require("./DOCUMENT_TYPE_NODE"),
            ELEMENT_NODE: require("./ELEMENT_NODE"),
            TEXT_NODE: require("./TEXT_NODE")
        }
    }, {
        "./COMMENT_NODE": 328,
        "./DOCUMENT_FRAGMENT_NODE": 329,
        "./DOCUMENT_NODE": 330,
        "./DOCUMENT_TYPE_NODE": 331,
        "./ELEMENT_NODE": 332,
        "./TEXT_NODE": 333,
        "./createDocumentFragment": 335,
        "./filterByNodeType": 336,
        "./hasAttribute": 337,
        "./indexOf": 338,
        "./insertAfter": 339,
        "./insertBefore": 340,
        "./insertFirstChild": 341,
        "./insertLastChild": 342,
        "./isComment": 345,
        "./isDocument": 346,
        "./isDocumentFragment": 347,
        "./isDocumentType": 348,
        "./isElement": 349,
        "./isNode": 350,
        "./isNodeList": 351,
        "./isTextNode": 352,
        "./remove": 353,
        "./replace": 354
    }],
    335: [function(require, module, exports) {
        "use strict";
        module.exports = function createDocumentFragment(html) {
            var fragment = document.createDocumentFragment();
            var div;
            if (html) {
                div = document.createElement("div");
                div.innerHTML = html;
                while (div.firstChild) {
                    fragment.appendChild(div.firstChild)
                }
            }
            return fragment
        }
    }, {}],
    336: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.slice");
        require("@marcom/ac-polyfills/Array/prototype.filter");
        var isNodeType = require("./internal/isNodeType");
        var ELEMENT_NODE = require("./ELEMENT_NODE");
        module.exports = function filterByNodeType(nodes, nodeType) {
            nodeType = nodeType || ELEMENT_NODE;
            nodes = Array.prototype.slice.call(nodes);
            return nodes.filter(function(node) {
                return isNodeType(node, nodeType)
            })
        }
    }, {
        "./ELEMENT_NODE": 332,
        "./internal/isNodeType": 343,
        "@marcom/ac-polyfills/Array/prototype.filter": 386,
        "@marcom/ac-polyfills/Array/prototype.slice": 390
    }],
    337: [function(require, module, exports) {
        "use strict";
        module.exports = function hasAttribute(el, attr) {
            if ("hasAttribute" in el) {
                return el.hasAttribute(attr)
            }
            return el.attributes.getNamedItem(attr) !== null
        }
    }, {}],
    338: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Array/prototype.indexOf");
        require("@marcom/ac-polyfills/Array/prototype.slice");
        var validate = require("./internal/validate");
        var filterByNodeType = require("./filterByNodeType");
        module.exports = function indexOf(node, nodeType) {
            var parentNode = node.parentNode;
            var nodes;
            if (!parentNode) {
                return 0
            }
            nodes = parentNode.childNodes;
            if (nodeType !== false) {
                nodes = filterByNodeType(nodes, nodeType)
            } else {
                nodes = Array.prototype.slice.call(nodes)
            }
            return nodes.indexOf(node)
        }
    }, {
        "./filterByNodeType": 336,
        "./internal/validate": 344,
        "@marcom/ac-polyfills/Array/prototype.indexOf": 388,
        "@marcom/ac-polyfills/Array/prototype.slice": 390
    }],
    339: [function(require, module, exports) {
        "use strict";
        var validate = require("./internal/validate");
        module.exports = function insertAfter(node, target) {
            validate.insertNode(node, true, "insertAfter");
            validate.childNode(target, true, "insertAfter");
            validate.hasParentNode(target, "insertAfter");
            if (!target.nextSibling) {
                return target.parentNode.appendChild(node)
            }
            return target.parentNode.insertBefore(node, target.nextSibling)
        }
    }, {
        "./internal/validate": 344
    }],
    340: [function(require, module, exports) {
        "use strict";
        var validate = require("./internal/validate");
        module.exports = function insertBefore(node, target) {
            validate.insertNode(node, true, "insertBefore");
            validate.childNode(target, true, "insertBefore");
            validate.hasParentNode(target, "insertBefore");
            return target.parentNode.insertBefore(node, target)
        }
    }, {
        "./internal/validate": 344
    }],
    341: [function(require, module, exports) {
        "use strict";
        var validate = require("./internal/validate");
        module.exports = function insertFirstChild(node, target) {
            validate.insertNode(node, true, "insertFirstChild");
            validate.parentNode(target, true, "insertFirstChild");
            if (!target.firstChild) {
                return target.appendChild(node)
            }
            return target.insertBefore(node, target.firstChild)
        }
    }, {
        "./internal/validate": 344
    }],
    342: [function(require, module, exports) {
        "use strict";
        var validate = require("./internal/validate");
        module.exports = function insertLastChild(node, target) {
            validate.insertNode(node, true, "insertLastChild");
            validate.parentNode(target, true, "insertLastChild");
            return target.appendChild(node)
        }
    }, {
        "./internal/validate": 344
    }],
    343: [function(require, module, exports) {
        arguments[4][29][0].apply(exports, arguments)
    }, {
        "../isNode": 350,
        dup: 29
    }],
    344: [function(require, module, exports) {
        arguments[4][30][0].apply(exports, arguments)
    }, {
        "../COMMENT_NODE": 328,
        "../DOCUMENT_FRAGMENT_NODE": 329,
        "../ELEMENT_NODE": 332,
        "../TEXT_NODE": 333,
        "./isNodeType": 343,
        dup: 30
    }],
    345: [function(require, module, exports) {
        "use strict";
        var isNodeType = require("./internal/isNodeType");
        var COMMENT_NODE = require("./COMMENT_NODE");
        module.exports = function isComment(obj) {
            return isNodeType(obj, COMMENT_NODE)
        }
    }, {
        "./COMMENT_NODE": 328,
        "./internal/isNodeType": 343
    }],
    346: [function(require, module, exports) {
        "use strict";
        var isNodeType = require("./internal/isNodeType");
        var DOCUMENT_NODE = require("./DOCUMENT_NODE");
        module.exports = function isDocument(obj) {
            return isNodeType(obj, DOCUMENT_NODE)
        }
    }, {
        "./DOCUMENT_NODE": 330,
        "./internal/isNodeType": 343
    }],
    347: [function(require, module, exports) {
        arguments[4][31][0].apply(exports, arguments)
    }, {
        "./DOCUMENT_FRAGMENT_NODE": 329,
        "./internal/isNodeType": 343,
        dup: 31
    }],
    348: [function(require, module, exports) {
        "use strict";
        var isNodeType = require("./internal/isNodeType");
        var DOCUMENT_TYPE_NODE = require("./DOCUMENT_TYPE_NODE");
        module.exports = function isDocumentType(obj) {
            return isNodeType(obj, DOCUMENT_TYPE_NODE)
        }
    }, {
        "./DOCUMENT_TYPE_NODE": 331,
        "./internal/isNodeType": 343
    }],
    349: [function(require, module, exports) {
        arguments[4][32][0].apply(exports, arguments)
    }, {
        "./ELEMENT_NODE": 332,
        "./internal/isNodeType": 343,
        dup: 32
    }],
    350: [function(require, module, exports) {
        arguments[4][33][0].apply(exports, arguments)
    }, {
        dup: 33
    }],
    351: [function(require, module, exports) {
        "use strict";
        var nodeListToStringPattern = /^\[object (HTMLCollection|NodeList|Object)\]$/;
        module.exports = function isNodeList(obj) {
            if (!obj) {
                return false
            }
            if (typeof obj.length !== "number") {
                return false
            }
            if (typeof obj[0] === "object" && (!obj[0] || !obj[0].nodeType)) {
                return false
            }
            return nodeListToStringPattern.test(Object.prototype.toString.call(obj))
        }
    }, {}],
    352: [function(require, module, exports) {
        "use strict";
        var isNodeType = require("./internal/isNodeType");
        var TEXT_NODE = require("./TEXT_NODE");
        module.exports = function isTextNode(obj) {
            return isNodeType(obj, TEXT_NODE)
        }
    }, {
        "./TEXT_NODE": 333,
        "./internal/isNodeType": 343
    }],
    353: [function(require, module, exports) {
        arguments[4][34][0].apply(exports, arguments)
    }, {
        "./internal/validate": 344,
        dup: 34
    }],
    354: [function(require, module, exports) {
        "use strict";
        var validate = require("./internal/validate");
        module.exports = function replace(newNode, oldNode) {
            validate.insertNode(newNode, true, "insertFirstChild", "newNode");
            validate.childNode(oldNode, true, "insertFirstChild", "oldNode");
            validate.hasParentNode(oldNode, "insertFirstChild", "oldNode");
            return oldNode.parentNode.replaceChild(newNode, oldNode)
        }
    }, {
        "./internal/validate": 344
    }],
    355: [function(require, module, exports) {
        arguments[4][250][0].apply(exports, arguments)
    }, {
        dup: 250
    }],
    356: [function(require, module, exports) {
        arguments[4][251][0].apply(exports, arguments)
    }, {
        "./clone": 357,
        "./create": 358,
        "./defaults": 359,
        "./extend": 360,
        "./getPrototypeOf": 361,
        "./isDate": 362,
        "./isEmpty": 363,
        "./isRegExp": 364,
        "./toQueryParameters": 365,
        dup: 251
    }],
    357: [function(require, module, exports) {
        arguments[4][94][0].apply(exports, arguments)
    }, {
        "./extend": 360,
        "@marcom/ac-polyfills/Array/isArray": 384,
        dup: 94
    }],
    358: [function(require, module, exports) {
        arguments[4][15][0].apply(exports, arguments)
    }, {
        dup: 15
    }],
    359: [function(require, module, exports) {
        arguments[4][215][0].apply(exports, arguments)
    }, {
        "./extend": 360,
        dup: 215
    }],
    360: [function(require, module, exports) {
        arguments[4][16][0].apply(exports, arguments)
    }, {
        "@marcom/ac-polyfills/Array/prototype.forEach": 387,
        dup: 16
    }],
    361: [function(require, module, exports) {
        arguments[4][256][0].apply(exports, arguments)
    }, {
        dup: 256
    }],
    362: [function(require, module, exports) {
        arguments[4][257][0].apply(exports, arguments)
    }, {
        dup: 257
    }],
    363: [function(require, module, exports) {
        arguments[4][258][0].apply(exports, arguments)
    }, {
        dup: 258
    }],
    364: [function(require, module, exports) {
        arguments[4][259][0].apply(exports, arguments)
    }, {
        dup: 259
    }],
    365: [function(require, module, exports) {
        arguments[4][260][0].apply(exports, arguments)
    }, {
        "@marcom/ac-url/joinSearchParams": 355,
        dup: 260
    }],
    366: [function(require, module, exports) {
        var ElementTracker = require("./ac-element-tracker/ElementTracker");
        module.exports = new ElementTracker;
        module.exports.ElementTracker = ElementTracker
    }, {
        "./ac-element-tracker/ElementTracker": 367
    }],
    367: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Function/prototype.bind");
        var ac_Array = require("@marcom/ac-array");
        var ac_dom_nodes = require("@marcom/ac-dom-nodes");
        var ac_dom_metrics = {
            getDimensions: require("@marcom/ac-dom-metrics/getDimensions"),
            getPagePosition: require("@marcom/ac-dom-metrics/getPagePosition"),
            getScrollY: require("@marcom/ac-dom-metrics/getScrollY")
        };
        var ac_dom_events = require("@marcom/ac-dom-events");
        var ac_Object = require("@marcom/ac-object");
        var TrackedElement = require("./TrackedElement");
        var defaultOptions = {
            autoStart: false,
            useRenderedPosition: false
        };

        function ElementTracker(elements, options) {
            this.options = ac_Object.clone(defaultOptions);
            this.options = typeof options === "object" ? ac_Object.extend(this.options, options) : this.options;
            this._scrollY = this._getScrollY();
            this._windowHeight = this._getWindowHeight();
            this.tracking = false;
            this.elements = [];
            if (elements && (Array.isArray(elements) || ac_dom_nodes.isNodeList(elements) || ac_dom_nodes.isElement(elements))) {
                this.addElements(elements)
            }
            this.refreshAllElementStates = this.refreshAllElementStates.bind(this);
            this.refreshAllElementMetrics = this.refreshAllElementMetrics.bind(this);
            if (this.options.autoStart) {
                this.start()
            }
        }
        var proto = ElementTracker.prototype;
        proto.destroy = function() {
            var i, len;
            this.stop();
            for (i = 0, len = this.elements.length; i < len; i++) {
                this.elements[i].destroy()
            }
            this.elements = null;
            this.options = null
        };
        proto._registerElements = function(elements) {
            elements = [].concat(elements);
            elements.forEach(function(element) {
                if (this._elementInDOM(element)) {
                    var trackedElement = new TrackedElement(element, this.options.useRenderedPosition);
                    trackedElement.offsetTop = trackedElement.element.offsetTop;
                    this.elements.push(trackedElement)
                }
            }, this)
        };
        proto._registerTrackedElements = function(trackedElements) {
            var objects = [].concat(trackedElements);
            objects.forEach(function(object) {
                if (this._elementInDOM(object.element)) {
                    object.offsetTop = object.element.offsetTop;
                    this.elements.push(object)
                }
            }, this)
        };
        proto._elementInDOM = function(element) {
            var assertion = false;
            var body = document.getElementsByTagName("body")[0];
            if (ac_dom_nodes.isElement(element) && body.contains(element)) {
                assertion = true
            }
            return assertion
        };
        proto._elementPercentInView = function(trackedElement) {
            return trackedElement.pixelsInView / trackedElement.height
        };
        proto._elementPixelsInView = function(trackedElement) {
            var elementTop = trackedElement.top - this._scrollY;
            var elementBottom = trackedElement.bottom - this._scrollY;
            if (elementTop > this._windowHeight || elementBottom < 0) {
                return 0
            }
            return Math.min(elementBottom, this._windowHeight) - Math.max(elementTop, 0)
        };
        proto._ifInView = function(trackedElement, alreadyInView) {
            if (!alreadyInView) {
                trackedElement.trigger("enterview", trackedElement)
            }
        };
        proto._ifAlreadyInView = function(trackedElement) {
            if (!trackedElement.inView) {
                trackedElement.trigger("exitview", trackedElement)
            }
        };
        proto.addElements = function(collection, useRenderedPosition) {
            if (typeof useRenderedPosition === "undefined") {
                useRenderedPosition = this.options.useRenderedPosition
            }
            collection = ac_dom_nodes.isNodeList(collection) ? ac_Array.toArray(collection) : [].concat(collection);
            for (var i = 0, len = collection.length; i < len; i++) {
                this.addElement(collection[i], useRenderedPosition)
            }
        };
        proto.addElement = function(element, useRenderedPosition) {
            var trackedElement = null;
            if (typeof useRenderedPosition === "undefined") {
                useRenderedPosition = this.options.useRenderedPosition
            }
            if (ac_dom_nodes.isElement(element)) {
                trackedElement = new TrackedElement(element, useRenderedPosition);
                this._registerTrackedElements(trackedElement);
                this.refreshElementMetrics(trackedElement);
                this.refreshElementState(trackedElement)
            } else {
                throw new TypeError("ElementTracker: " + element + " is not a valid DOM element")
            }
            return trackedElement
        };
        proto.removeElement = function(element) {
            var indexes = [];
            var filtered;
            this.elements.forEach(function(trackedElement, i) {
                if (trackedElement === element || trackedElement.element === element) {
                    indexes.push(i)
                }
            });
            filtered = this.elements.filter(function(element, i) {
                return indexes.indexOf(i) < 0
            });
            this.elements = filtered
        };
        proto.start = function() {
            if (this.tracking === false) {
                this.tracking = true;
                ac_dom_events.addEventListener(window, "resize", this.refreshAllElementMetrics);
                ac_dom_events.addEventListener(window, "orientationchange", this.refreshAllElementMetrics);
                ac_dom_events.addEventListener(window, "scroll", this.refreshAllElementStates);
                this.refreshAllElementMetrics()
            }
        };
        proto.stop = function() {
            if (this.tracking === true) {
                this.tracking = false;
                ac_dom_events.removeEventListener(window, "resize", this.refreshAllElementMetrics);
                ac_dom_events.removeEventListener(window, "orientationchange", this.refreshAllElementMetrics);
                ac_dom_events.removeEventListener(window, "scroll", this.refreshAllElementStates)
            }
        };
        proto.refreshAllElementMetrics = function(currentScrollY, windowHeight) {
            if (typeof currentScrollY !== "number") {
                currentScrollY = this._getScrollY()
            }
            if (typeof windowHeight !== "number") {
                windowHeight = this._getWindowHeight()
            }
            this._scrollY = currentScrollY;
            this._windowHeight = windowHeight;
            this.elements.forEach(this.refreshElementMetrics, this)
        };
        proto.refreshElementMetrics = function(trackedElement) {
            var dimensions = ac_dom_metrics.getDimensions(trackedElement.element, trackedElement.useRenderedPosition);
            var position = ac_dom_metrics.getPagePosition(trackedElement.element, trackedElement.useRenderedPosition);
            trackedElement = ac_Object.extend(trackedElement, dimensions, position);
            return this.refreshElementState(trackedElement)
        };
        proto.refreshAllElementStates = function(currentScrollY) {
            if (typeof currentScrollY !== "number") {
                currentScrollY = this._getScrollY()
            }
            this._scrollY = currentScrollY;
            this.elements.forEach(this.refreshElementState, this)
        };
        proto.refreshElementState = function(trackedElement) {
            var alreadyInView = trackedElement.inView;
            trackedElement.pixelsInView = this._elementPixelsInView(trackedElement);
            trackedElement.percentInView = this._elementPercentInView(trackedElement);
            trackedElement.inView = trackedElement.pixelsInView > 0;
            if (trackedElement.inView) {
                this._ifInView(trackedElement, alreadyInView)
            }
            if (alreadyInView) {
                this._ifAlreadyInView(trackedElement)
            }
            return trackedElement
        };
        proto._getWindowHeight = function() {
            return document.documentElement.clientHeight || window.innerHeight
        };
        proto._getScrollY = function() {
            return ac_dom_metrics.getScrollY()
        };
        module.exports = ElementTracker
    }, {
        "./TrackedElement": 368,
        "@marcom/ac-array": 320,
        "@marcom/ac-dom-events": 288,
        "@marcom/ac-dom-metrics/getDimensions": 305,
        "@marcom/ac-dom-metrics/getPagePosition": 306,
        "@marcom/ac-dom-metrics/getScrollY": 311,
        "@marcom/ac-dom-nodes": 334,
        "@marcom/ac-object": 356,
        "@marcom/ac-polyfills/Function/prototype.bind": 394
    }],
    368: [function(require, module, exports) {
        "use strict";
        var objCreate = require("@marcom/ac-object").create;
        var ac_dom_nodes = require("@marcom/ac-dom-nodes");
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var superclass = EventEmitterMicro.prototype;

        function TrackedElement(element, useRenderedPosition) {
            if (!ac_dom_nodes.isElement(element)) {
                throw new TypeError("TrackedElement: " + element + " is not a valid DOM element")
            }
            EventEmitterMicro.call(this);
            this.element = element;
            this.inView = false;
            this.percentInView = 0;
            this.pixelsInView = 0;
            this.offsetTop = 0;
            this.top = 0;
            this.right = 0;
            this.bottom = 0;
            this.left = 0;
            this.width = 0;
            this.height = 0;
            this.useRenderedPosition = useRenderedPosition || false
        }
        var proto = TrackedElement.prototype = objCreate(superclass);
        proto.destroy = function() {
            this.element = null;
            superclass.destroy.call(this)
        };
        module.exports = TrackedElement
    }, {
        "@marcom/ac-dom-nodes": 334,
        "@marcom/ac-event-emitter-micro": 369,
        "@marcom/ac-object": 356
    }],
    369: [function(require, module, exports) {
        arguments[4][13][0].apply(exports, arguments)
    }, {
        "./ac-event-emitter-micro/EventEmitterMicro": 370,
        dup: 13
    }],
    370: [function(require, module, exports) {
        arguments[4][14][0].apply(exports, arguments)
    }, {
        dup: 14
    }],
    371: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Object/create");
        require("@marcom/ac-polyfills/Element/prototype.classList");
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var superclass = EventEmitterMicro.prototype;

        function BaseComponent(section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index) {
            if (arguments.length !== 7) {
                throw new Error("Incorrect number of arguments passed to BaseComponent check the constructor or BaseComponent.call method - argument's should be (section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index)")
            }
            EventEmitterMicro.call(this);
            this.section = section;
            this.element = componentElement;
            this.componentName = componentName;
            this.index = index;
            this.isEnabled = true;
            this.rafWhenVisible = this.rafWhenVisible || false
        }
        var proto = BaseComponent.prototype = Object.create(EventEmitterMicro.prototype);
        BaseComponent.prototype.constructor = BaseComponent;
        proto.destroy = function() {
            this.teardownEvents();
            this.section = null;
            superclass.destroy.call(this)
        };
        proto.setupEvents = function() {};
        proto.teardownEvents = function() {};
        proto.onSectionWillAppear = function(scrollPosition, windowHeight) {};
        proto.activate = function() {};
        proto.animateIn = function() {};
        proto.onRequestAnimationFrame = function() {};
        proto.deactivate = function() {};
        proto.onScroll = function(e, scrollPosition, windowHeight) {};
        proto.onSectionWillDisappear = function(scrollPosition, windowHeight) {};
        proto.onResizeDebounced = function(e, scrollPosition, windowHeight) {};
        proto.onResizeImmediate = function(e, scrollPosition, windowHeight) {};
        proto.onOrientationChange = function(e, orientation, scrollPosition, windowHeight) {};
        proto.onBreakpoint = function(newBreakPoint, oldBreakPoint, scrollPosition, windowHeight) {};
        proto.onRetinaChange = function(isRetina, currentBreakpoint, scrollPosition, windowHeight) {};
        module.exports = BaseComponent
    }, {
        "@marcom/ac-event-emitter-micro": 369,
        "@marcom/ac-polyfills/Element/prototype.classList": 393,
        "@marcom/ac-polyfills/Object/create": 396
    }],
    372: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Element/prototype.classList");
        require("@marcom/ac-polyfills/Object/assign");
        require("@marcom/ac-polyfills/Object/assign");
        require("@marcom/ac-polyfills/console.log");
        var querySelector = require("@marcom/ac-dom-traversal/querySelector");
        var querySelectorAll = require("@marcom/ac-dom-traversal/querySelectorAll");
        var ac_addEventListener = require("@marcom/ac-dom-events/addEventListener");
        var ac_removeEventListener = require("@marcom/ac-dom-events/removeEventListener");
        var ElementTracker = require("@marcom/ac-element-tracker").ElementTracker;
        var ViewportEmitter = require("@marcom/ac-viewport-emitter");
        if (!ViewportEmitter.viewport) {
            console.log("Jetpack Error: Required module `ac-viewport-emitter` not initialized properly (missing required css styles). Please see `ac-viewport-emitter` documentation.");
            console.log("Jetpack Error: Breakpoint will always be 'large' and no `onBreakPoint` events will be fired");
            ViewportEmitter = require("../utils/ViewportEmitterStub")()
        }
        var LocalNavStyleChanger = require("./LocalNavStyleChanger");
        var PageUtils = require("../utils/Page");
        var SectionMap = require("../model/SectionMap");
        var DataAttributes = require("../model/DataAttributes");
        var EnabledFeatures = require("../model/EnabledFeatures");

        function BasePage(el) {
            EnabledFeatures.init();
            this.name = this.name || "[NOT SET]";
            this._mainEl = querySelector("main,.main");
            this._sections = [];
            this._visibleSections = [];
            this._elementTracker = new ElementTracker(null, {
                autoStart: true
            });
            this._currentSection = null;
            this._sectionUnderLocalNav = null;
            this._currentBreakpoint = ViewportEmitter.viewport;
            this.isRetina = ViewportEmitter.retina;
            this._cachedScrollY = this._getScrollY(true);
            this._cachedWindowHeight = this._getWindowHeight(true);
            this._rafId = -1;
            this._resizeTimeout = -1;
            this._resizeTimeoutDelay = this._resizeTimeoutDelay || 250;
            this.setupSections();
            this.setupLocalNavStyleChanger();
            this.setupEvents();
            this._updateSectionVisibility();
            this._updateLocalNavTheme();
            this._onRequestAnimationFrame()
        }
        var proto = BasePage.prototype;
        proto.destroy = function() {
            for (var i = 0, len = this._sections.length; i < len; i++) {
                this._sections[i].destroy()
            }
            this.teardownEvents();
            this._elementTracker.destroy();
            this._elementTracker = null;
            this._sections = null;
            this._currentSection = null;
            this._sectionUnderLocalNav = null;
            this._visibleSections = null;
            this._mainEl = null
        };
        proto.setupEvents = function() {
            this._onScroll = this._onScroll.bind(this);
            this._onBreakpoint = this._onBreakpoint.bind(this);
            this._onRetinaChange = this._onRetinaChange.bind(this);
            this._onPageDidAppear = this._onPageDidAppear.bind(this);
            this._onResizeImmediate = this._onResizeImmediate.bind(this);
            this._onOrientationChange = this._onOrientationChange.bind(this);
            this._onPageWillDisappear = this._onPageWillDisappear.bind(this);
            this._onRequestAnimationFrame = this._onRequestAnimationFrame.bind(this);
            this.performDeepMetricsRefresh = this.performDeepMetricsRefresh.bind(this);
            ac_addEventListener(window, "scroll", this._onScroll);
            ac_addEventListener(window, "resize", this._onResizeImmediate);
            ac_addEventListener(window, "orientationchange", this._onOrientationChange);
            ViewportEmitter.on("change", this._onBreakpoint);
            ViewportEmitter.on("retinachange", this._onRetinaChange);
            PageUtils.on(PageUtils.DEEP_REFRESH_ALL_METRICS, this.performDeepMetricsRefresh)
        };
        proto.teardownEvents = function() {
            ac_removeEventListener(window, "scroll", this._onScroll);
            ac_removeEventListener(window, "resize", this._onResizeImmediate);
            ac_removeEventListener(window, "orientationchange", this._onOrientationChange);
            ViewportEmitter.off("change", this._onBreakpoint);
            ViewportEmitter.off("retinachange", this._onRetinaChange);
            PageUtils.off(PageUtils.DEEP_REFRESH_ALL_METRICS, this.performDeepMetricsRefresh);
            this._elementTracker.stop();
            clearTimeout(this._resizeTimeout);
            cancelAnimationFrame(this._rafId)
        };
        proto.setupSections = function() {
            var nodes = querySelectorAll("section,.section,[data-section-type]", this._mainEl);
            for (var i = 0, len = nodes.length; i < len; i++) {
                if (nodes[i].parentElement !== this._mainEl) {
                    console.warn("BasePage::addSection - Jetpack does not support nested BaseSections, consider using a component instead.", nodes[i]);
                    continue
                }
                var element = nodes[i];
                this._addSectionImp(element)
            }
        };
        proto.addSection = function(element) {
            var baseSection = this.getBaseSectionForElement(element);
            if (baseSection) {
                return baseSection
            }
            baseSection = this._addSectionImp(element);
            this._updateSectionVisibility();
            this._updateLocalNavTheme();
            return baseSection
        };
        proto.removeSection = function(elementOrBaseSection) {
            var isBaseSectionInstance = elementOrBaseSection instanceof SectionMap.BaseSection;
            var sectionInstance = isBaseSectionInstance ? elementOrBaseSection : this.getBaseSectionForElement(elementOrBaseSection);
            if (sectionInstance) {
                this._sections.splice(this._sections.indexOf(sectionInstance), 1)
            }
            this._updateSectionVisibility();
            this._updateLocalNavTheme();
            return sectionInstance
        };
        proto._addSectionImp = function(element) {
            if (element.parentNode !== this._mainEl && this._isNestedSection(element)) {
                console.warn("BasePage::addSection - Jetpack does not support nested BaseSections, consider using a component instead.", element);
                return null
            }
            var trackedElement = this._elementTracker.addElement(element);
            this._elementTracker.refreshElementState(trackedElement);
            var sectionType = element.hasAttribute(DataAttributes.SECTION_TYPE) ? element.getAttribute(DataAttributes.SECTION_TYPE) : "BaseSection";
            if (sectionType === "") {
                sectionType = "BaseSection"
            }
            if (!SectionMap.hasOwnProperty(sectionType)) {
                throw "BasePage::setupSections parsing '#" + element.id + " ." + element.className + "' no section type '" + sectionType + "'found!"
            }
            var SectionConstructor = SectionMap[sectionType];
            var section = new SectionConstructor(element, trackedElement, this._getCurrentBreakpoint(), this._getScrollY(), this._getWindowHeight(), this._sections.length);
            section.setupEvents();
            this._sections.push(section);
            return section
        };
        proto.setupLocalNavStyleChanger = function() {
            LocalNavStyleChanger.setCurrentSection(this._currentSection);
            if (EnabledFeatures.PAGE_JUMP) {
                var pageName = this._mainEl.getAttribute("data-page-type");
                LocalNavStyleChanger.setCurrentPage(pageName)
            }
        };
        proto._activateSection = function(section) {
            if (this._currentSection === section) {
                return
            }
            if (this._currentSection) {
                this._currentSection.deactivate()
            }
            this._currentSection = section;
            this._currentSection.activate()
        };
        proto._updateSectionVisibility = function() {
            var scrollPosition = this._getScrollY();
            var windowHeight = this._getWindowHeight();
            var closestSection = this._sections[0];
            var newVisibleSections = [];
            var mostPixelsInView = 0;
            for (var i = 0, len = this._sections.length; i < len; i++) {
                var section = this._sections[i];
                var pixelsInView = section.trackedElement.pixelsInView;
                if (section.isFixedHero) {
                    pixelsInView = windowHeight - scrollPosition
                }
                if (pixelsInView > mostPixelsInView) {
                    closestSection = section;
                    mostPixelsInView = pixelsInView
                }
                if (pixelsInView > 1e-6) {
                    newVisibleSections.push(section)
                }
            }
            for (i = 0, len = Math.max(this._visibleSections.length, newVisibleSections.length); i < len; i++) {
                if (this._visibleSections[i] && newVisibleSections.indexOf(this._visibleSections[i]) === -1) {
                    this._visibleSections[i].onSectionWillDisappear(scrollPosition, windowHeight)
                }
                if (newVisibleSections[i] && this._visibleSections.indexOf(newVisibleSections[i]) === -1) {
                    newVisibleSections[i].onSectionWillAppear(scrollPosition, windowHeight)
                }
            }
            this._visibleSections = newVisibleSections;
            this._activateSection(closestSection)
        };
        proto._updateLocalNavTheme = function() {
            var scrollPosition = this._getScrollY();
            this._sectionUnderLocalNav = this._visibleSections[0];
            for (var i = 0, len = this._visibleSections.length; i < len; i++) {
                if (scrollPosition + LocalNavStyleChanger.height > this._visibleSections[i].scrollToPosition) {
                    this._sectionUnderLocalNav = this._visibleSections[i]
                }
            }
            if (this._sectionUnderLocalNav) {
                LocalNavStyleChanger.setCurrentSection(this._sectionUnderLocalNav)
            }
        };
        proto._onPageDidAppear = function(data) {};
        proto._onPageWillDisappear = function(data) {
            this.destroy()
        };
        proto._onBreakpoint = function(e) {
            var incoming = e.to;
            var outgoing = e.from;
            this._currentBreakpoint = incoming;
            var scrollPosition = this._getScrollY();
            var windowHeight = this._getWindowHeight();
            this._elementTracker.refreshAllElementMetrics(scrollPosition, windowHeight);
            for (var i = 0, len = this._sections.length; i < len; i++) {
                this._sections[i].onBreakpoint(incoming, outgoing, scrollPosition, windowHeight)
            }
            this.performDeepMetricsRefresh()
        };
        proto._onRetinaChange = function(e) {
            var scrollPosition = this._getScrollY(true);
            var windowHeight = this._getWindowHeight(true);
            this.isRetina = ViewportEmitter.retina;
            var currentBreakpoint = this._currentBreakpoint;
            this._elementTracker.refreshAllElementMetrics(scrollPosition, windowHeight);
            for (var i = 0, len = this._sections.length; i < len; i++) {
                this._sections[i].onRetinaChange(this.isRetina, currentBreakpoint, scrollPosition, windowHeight)
            }
        };
        proto._onScroll = function(e) {
            var scrollPosition = this._getScrollY(true);
            var windowHeight = this._getWindowHeight();
            this._updateSectionVisibility();
            this._updateLocalNavTheme();
            for (var i = 0, len = this._visibleSections.length; i < len; i++) {
                this._visibleSections[i].onScroll(e, scrollPosition, windowHeight)
            }
        };
        proto._onResizeDebounced = function(e) {
            var scrollPosition = this._getScrollY();
            var windowHeight = this._getWindowHeight();
            var didDoDeprecationWarning = false;
            for (var i = 0, len = this._sections.length; i < len; i++) {
                if (!didDoDeprecationWarning && this._sections[i]["onResize"]) {
                    console.warn("Jetpack: onResize has been removed please use `onResizeImmediate` or `onResizeDebounced` instead.");
                    didDoDeprecationWarning = true
                }
                this._sections[i].onResizeDebounced(e, scrollPosition, windowHeight)
            }
            this._updateSectionVisibility();
            this._updateLocalNavTheme()
        };
        proto.performDeepMetricsRefresh = function() {
            var scrollPosition = this._getScrollY();
            var windowHeight = this._getWindowHeight();
            this._elementTracker.refreshAllElementMetrics(scrollPosition, windowHeight);
            for (var i = 0, len = this._sections.length; i < len; i++) {
                this._sections[i].elementEngagement.refreshAllElementMetrics(scrollPosition, windowHeight);
                this._sections[i].updateScrollToPosition()
            }
            this._updateSectionVisibility();
            this._updateLocalNavTheme()
        };
        proto._onOrientationChange = function(e) {
            var scrollPosition = this._getScrollY(true);
            var windowHeight = this._getWindowHeight(true);
            var orientation = e.orientation;
            for (var i = 0, len = this._sections.length; i < len; i++) {
                this._sections[i].onOrientationChange(e, orientation, scrollPosition, windowHeight)
            }
        };
        proto._onResizeImmediate = function(e) {
            var scrollPosition = this._getScrollY();
            var windowHeight = this._getWindowHeight(true);
            var didDoDeprecationWarning = false;
            for (var i = 0, len = this._sections.length; i < len; i++) {
                if (!didDoDeprecationWarning && this._sections[i]["onResizeWillBeCalledAfterDelay"]) {
                    console.warn("Jetpack: onResizeWillBeCalledAfterDelay has been removed please use `onResizeImmediate` or `onResizeDebounced` instead.");
                    didDoDeprecationWarning = true
                }
                this._sections[i].onResizeImmediate(e, scrollPosition, windowHeight)
            }
            window.clearTimeout(this._resizeTimeout);
            this._resizeTimeout = window.setTimeout(this._onResizeDebounced.bind(this, e), this._resizeTimeoutDelay)
        };
        proto._onRequestAnimationFrame = function() {
            this._rafId = requestAnimationFrame(this._onRequestAnimationFrame);
            for (var i = 0, len = this._visibleSections.length; i < len; i++) {
                var visibleSection = this._visibleSections[i];
                if (visibleSection.rafWhenVisible || visibleSection.isActive) {
                    visibleSection.onRequestAnimationFrame()
                }
            }
        };
        proto._getScrollY = function(needsUpdate) {
            if (needsUpdate) {
                this._cachedScrollY = window.pageYOffset || (document.documentElement || document.body).scrollTop
            }
            return this._cachedScrollY
        };
        proto._getWindowHeight = function(needsUpdate) {
            if (needsUpdate) {
                this._cachedWindowHeight = document.documentElement.clientHeight || window.innerHeight
            }
            return this._cachedWindowHeight
        };
        proto._getVisibleBottomOfPage = function() {
            return this._getScrollY() + this._getWindowHeight()
        };
        proto._getCurrentBreakpoint = function() {
            return this._currentBreakpoint
        };
        proto._isNestedSection = function(element) {
            var parent = element;
            var len = this._sections.length;
            while (parent = parent.parentElement) {
                for (var i = 0; i < len; i++) {
                    if (this._sections[i].element === parent) {
                        return true
                    }
                }
            }
            return false
        };
        proto.getBaseSectionForElement = function(element) {
            for (var i = 0, len = this._sections.length; i < len; i++) {
                if (this._sections[i].element === element) {
                    return this._sections[i]
                }
            }
            return null
        };
        module.exports = BasePage
    }, {
        "../model/DataAttributes": 376,
        "../model/EnabledFeatures": 377,
        "../model/SectionMap": 378,
        "../utils/Page": 379,
        "../utils/ViewportEmitterStub": 380,
        "./LocalNavStyleChanger": 374,
        "@marcom/ac-dom-events/addEventListener": 286,
        "@marcom/ac-dom-events/removeEventListener": 295,
        "@marcom/ac-dom-traversal/querySelector": 38,
        "@marcom/ac-dom-traversal/querySelectorAll": 39,
        "@marcom/ac-element-tracker": 366,
        "@marcom/ac-polyfills/Element/prototype.classList": 393,
        "@marcom/ac-polyfills/Object/assign": 395,
        "@marcom/ac-polyfills/console.log": 398,
        "@marcom/ac-viewport-emitter": 564
    }],
    373: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Object/create");
        require("@marcom/ac-polyfills/Element/prototype.classList");
        var acConsole = require("@marcom/ac-console");
        var DomMetrics = require("@marcom/ac-dom-metrics");
        var ElementEngagement = require("@marcom/ac-element-engagement").ElementEngagement;
        var querySelectorAll = require("@marcom/ac-dom-traversal/querySelectorAll");
        var DataAttributes = require("./../model/DataAttributes");
        var ComponentMap = require("./../model/ComponentMap");
        var BaseComponent = require("./BaseComponent");
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var superclass = EventEmitterMicro.prototype;

        function BaseSection(element, trackedElement, currentBreakpoint, scrollPosition, windowHeight, index) {
            if (arguments.length !== 6) {
                throw new Error("Incorrect number of arguments passed to BaseSection")
            }
            EventEmitterMicro.call(this);
            this.element = element;
            this.trackedElement = trackedElement;
            this.elementEngagement = new ElementEngagement(null, {
                autoStart: false
            });
            this.rafWhenVisible = this.rafWhenVisible || false;
            this.index = index;
            this.isVisible = this.trackedElement.pixelsInView > 0;
            this.hasAnimatedIn = false;
            this.isActive = false;
            this.isFixedHero = false;
            this.cachedBreakpoint = currentBreakpoint;
            this.cachedScrollPosition = scrollPosition;
            this.cachedWindowHeight = windowHeight;
            this.name = this.name || this.element.className;
            this.scrollToPosition = 0;
            this.updateScrollToPosition();
            this._components = [];
            this.setupComponents(currentBreakpoint, scrollPosition, windowHeight);
            this.setIsFixedHero();
            this.performDeprecatedMethodCheck()
        }
        var proto = BaseSection.prototype = Object.create(EventEmitterMicro.prototype);
        BaseSection.prototype.constructor = BaseSection;
        proto.performDeprecatedMethodCheck = function() {
            if (this["onViewWillAppear"]) {
                throw new Error("Section.onViewWillAppear is now `onSectionWillAppear`, please update your BaseSection subclass")
            }
            if (this["onViewWillDisappear"]) {
                throw new Error("Section.onViewWillDisappear is now `onSectionWillDisappear`, please update your BaseSection subclass")
            }
            return true
        };
        proto.destroy = function() {
            this.teardownEvents();
            this.elementEngagement.stop();
            this.elementEngagement = null;
            for (var i = 0, len = this._components.length; i < len; i++) {
                this._components[i].destroy()
            }
            this._components = null;
            this.trackedElement = null;
            this.element = null;
            superclass.destroy.call(this)
        };
        proto.setupEvents = function() {
            for (var i = 0, len = this._components.length; i < len; i++) {
                this._components[i].setupEvents()
            }
        };
        proto.teardownEvents = function() {
            for (var i = 0, len = this._components.length; i < len; i++) {
                this._components[i].teardownEvents()
            }
        };
        proto.setupComponents = function() {
            var componentElements = querySelectorAll("[" + DataAttributes.COMPONENT_LIST + "]", this.element);
            if (this.element.hasAttribute(DataAttributes.COMPONENT_LIST)) {
                componentElements.push(this.element)
            }
            for (var i = 0; i < componentElements.length; i++) {
                var componentElement = componentElements[i];
                var componentListString = componentElement.getAttribute(DataAttributes.COMPONENT_LIST);
                if (componentListString.indexOf("|") !== -1) {
                    throw "BaseSection::setupComponents component list should be space delimited, pipe character is no longer supported. Error at: '" + componentListString + "'"
                }
                var componentList = componentListString.split(" ");
                for (var j = 0, len = componentList.length; j < len; j++) {
                    var componentType = componentList[j];
                    if (componentType === "" || componentType === " ") {
                        continue
                    }
                    this.addComponentOfType(componentType, componentElement)
                }
                setTimeout(this.elementEngagement.refreshAllElementStates.bind(this.elementEngagement), 100)
            }
        };
        proto.addComponentOfType = function(componentType, componentElement) {
            if (!ComponentMap.hasOwnProperty(componentType)) {
                throw "BaseSection::setupComponents parsing '#" + componentElement.id + " ." + componentElement.className + "' no component type '" + componentType + "'found!"
            }
            var ComponentConstructor = ComponentMap[componentType];
            if (!this.componentIsSupported(ComponentConstructor, componentType)) {
                acConsole.log("BaseSection::setupComponents unsupported component '" + componentType + "'. Reason: '" + componentType + ".IS_SUPPORTED' returned false");
                return
            }
            var component = new ComponentConstructor(this, componentElement, componentType, this.cachedBreakpoint, this.cachedScrollPosition, this.cachedWindowHeight, this._components.length);
            this.rafWhenVisible = component.rafWhenVisible || this.rafWhenVisible;
            this._components.push(component);
            return component
        };
        proto.removeComponentOfType = function(componentType) {
            var componentInstanceToRemove = this.getComponentOfType(componentType);
            if (componentInstanceToRemove === null) {
                return
            }
            this.removeComponent(componentInstanceToRemove)
        };
        proto.removeComponent = function(componentInstanceToRemove) {
            var index = this._components.indexOf(componentInstanceToRemove);
            if (index === -1) return;
            this._components.splice(index, 1);
            componentInstanceToRemove.destroy()
        };
        proto.activate = function() {
            this.element.classList.add("active");
            for (var i = 0, len = this._components.length; i < len; i++) {
                if (!this._components[i].isEnabled) {
                    continue
                }
                this._components[i].activate()
            }
            this.isActive = true;
            if (!this.hasAnimatedIn) {
                this.element.classList.add("animated");
                this.animateIn();
                this.hasAnimatedIn = true
            }
        };
        proto.deactivate = function() {
            this.element.classList.remove("active");
            this.isActive = false;
            for (var i = 0, len = this._components.length; i < len; i++) {
                if (!this._components[i].isEnabled) {
                    continue
                }
                this._components[i].deactivate()
            }
        };
        proto.animateIn = function() {
            for (var i = 0, len = this._components.length; i < len; i++) {
                if (!this._components[i].isEnabled) {
                    continue
                }
                this._components[i].animateIn()
            }
        };
        proto.onRequestAnimationFrame = function() {
            for (var i = 0, len = this._components.length; i < len; i++) {
                var component = this._components[i];
                if (!component.isEnabled) {
                    continue
                }
                if (component.rafWhenVisible || this.isActive) {
                    component.onRequestAnimationFrame()
                }
            }
        };
        proto.onResizeImmediate = function(e, scrollPosition, windowHeight) {
            this.cachedScrollPosition = scrollPosition;
            this.cachedWindowHeight = windowHeight;
            var didDoDeprecationWarning = false;
            for (var i = 0, len = this._components.length; i < len; i++) {
                if (!this._components[i].isEnabled) {
                    continue
                }
                if (!didDoDeprecationWarning && this._components[i]["onResizeWillBeCalledAfterDelay"]) {
                    console.warn("Jetpack: onResizeWillBeCalledAfterDelay has been removed please use `onResizeImmediate` or `onResizeDebounced` instead.");
                    didDoDeprecationWarning = true
                }
                this._components[i].onResizeImmediate(e, scrollPosition, windowHeight)
            }
        };
        proto.onResizeDebounced = function(e, scrollPosition, windowHeight) {
            this.updateScrollToPosition();
            var didDoDeprecationWarning = false;
            for (var i = 0, len = this._components.length; i < len; i++) {
                if (!this._components[i].isEnabled) {
                    continue
                }
                if (!didDoDeprecationWarning && this._components[i]["onResize"]) {
                    console.warn("Jetpack: onResize has been removed please use `onResizeImmediate` or `onResizeDebounced` instead.");
                    didDoDeprecationWarning = true
                }
                this._components[i].onResizeDebounced(e, scrollPosition, windowHeight)
            }
            this.elementEngagement.refreshAllElementMetrics(scrollPosition, windowHeight)
        };
        proto.onBreakpoint = function(newBreakPoint, oldBreakPoint, scrollPosition, windowHeight) {
            this.cachedBreakpoint = newBreakPoint;
            for (var i = 0, len = this._components.length; i < len; i++) {
                if (!this._components[i].isEnabled) {
                    continue
                }
                this._components[i].onBreakpoint(newBreakPoint, oldBreakPoint, scrollPosition, windowHeight)
            }
        };
        proto.onRetinaChange = function(isRetina, currentBreakpoint, scrollPosition, windowHeight) {
            for (var i = 0, len = this._components.length; i < len; i++) {
                if (!this._components[i].isEnabled) {
                    continue
                }
                this._components[i].onRetinaChange(isRetina, currentBreakpoint, scrollPosition, windowHeight)
            }
            this.elementEngagement.refreshAllElementMetrics(scrollPosition, windowHeight)
        };
        proto.onOrientationChange = function(e, orientation, scrollPosition, windowHeight) {
            this.cachedScrollPosition = scrollPosition;
            this.cachedWindowHeight = windowHeight;
            for (var i = 0, len = this._components.length; i < len; i++) {
                if (!this._components[i].isEnabled) {
                    continue
                }
                this._components[i].onOrientationChange(e, orientation, scrollPosition, windowHeight)
            }
        };
        proto.onScroll = function(e, scrollPosition, windowHeight) {
            this.cachedScrollPosition = scrollPosition;
            this.elementEngagement.refreshAllElementStates(scrollPosition);
            for (var i = 0, len = this._components.length; i < len; i++) {
                if (!this._components[i].isEnabled) {
                    continue
                }
                this._components[i].onScroll(e, scrollPosition, windowHeight)
            }
        };
        proto.onSectionWillAppear = function(scrollPosition, windowHeight) {
            this.cachedScrollPosition = scrollPosition;
            this.isVisible = true;
            this.elementEngagement.refreshAllElementStates(scrollPosition);
            for (var i = 0, len = this._components.length; i < len; i++) {
                this._components[i].onSectionWillAppear(scrollPosition, windowHeight)
            }
        };
        proto.onSectionWillDisappear = function(scrollPosition, windowHeight) {
            this.cachedScrollPosition = scrollPosition;
            this.isVisible = false;
            for (var i = 0, len = this._components.length; i < len; i++) {
                this._components[i].onSectionWillDisappear(scrollPosition, windowHeight)
            }
        };
        proto.getComponentOfType = function(componentType) {
            if (!ComponentMap.hasOwnProperty(componentType)) {
                throw "BaseSection::getComponentOfType no component type '" + componentType + "' exist in ComponentMap!"
            }
            for (var i = 0, len = this._components.length; i < len; i++) {
                if (this._components[i].componentName === componentType) {
                    return this._components[i]
                }
            }
            return null
        };
        proto.getAllComponentsOfType = function(componentType) {
            if (!ComponentMap.hasOwnProperty(componentType)) {
                throw "BaseSection::getAllComponentsOfType no component type '" + componentType + "' exist in ComponentMap!"
            }
            var matches = [];
            for (var i = 0, len = this._components.length; i < len; i++) {
                if (this._components[i].componentName === componentType) {
                    matches.push(this._components[i])
                }
            }
            return matches
        };
        proto.updateScrollToPosition = function() {
            return this.scrollToPosition = DomMetrics.getPagePosition(this.element).top
        };
        proto.setIsFixedHero = function() {
            if (this.index !== 0) {
                this.isFixedHero = false
            } else {
                var style = window.getComputedStyle(this.element);
                this.isFixedHero = style.position === "fixed"
            }
        };
        BaseSection.prototype.componentIsSupported = function(ComponentConstructor, componentName) {
            var isSupportedMethod = ComponentConstructor["IS_SUPPORTED"];
            if (isSupportedMethod === undefined) {
                return true
            }
            if (typeof isSupportedMethod !== "function") {
                console.error('BaseSection::setupComponents error in "' + componentName + '".IS_SUPPORTED - it should be a function which returns true/false');
                return true
            }
            var value = ComponentConstructor["IS_SUPPORTED"]();
            if (value === undefined) {
                console.error('BaseSection::setupComponents error in "' + componentName + '".IS_SUPPORTED - it should be a function which returns true/false');
                return true
            }
            return value
        };
        module.exports = BaseSection
    }, {
        "./../model/ComponentMap": 375,
        "./../model/DataAttributes": 376,
        "./BaseComponent": 371,
        "@marcom/ac-console": 284,
        "@marcom/ac-dom-metrics": 303,
        "@marcom/ac-dom-traversal/querySelectorAll": 39,
        "@marcom/ac-element-engagement": 318,
        "@marcom/ac-event-emitter-micro": 369,
        "@marcom/ac-polyfills/Element/prototype.classList": 393,
        "@marcom/ac-polyfills/Object/create": 396
    }],
    374: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Element/prototype.classList");
        var DataAttributes = require("./../model/DataAttributes");
        var hasConstructedSingleton = false;
        var LocalNavStyleChanger = function() {
            if (hasConstructedSingleton) {
                throw new Error("Do not call the constructor, use LocalNavStyleChanger.initialize(settings)")
            }
            hasConstructedSingleton = true;
            this._currentTheme = "";
            this.defaultTheme = "theme-light";
            this._currentPageNavLink = null;
            this._section = null;
            this.elementToApplyClassesAgainst = null;
            this.height = 0
        };
        var proto = LocalNavStyleChanger.prototype;
        proto.initialize = function(settings) {
            this.elementToApplyClassesAgainst = settings.elementToApplyClassesAgainst;
            this.sectionThemeMap = settings.sectionThemeMap;
            this.defaultTheme = settings.defaultTheme;
            this.height = settings.localNavHeight
        };
        proto.setCurrentPage = function(pageName) {
            var el = document.querySelector(".localnav-link[" + DataAttributes.JUMP_SECTION_NAME + "=" + pageName + "]");
            if (el === this._currentPageNavLink) {
                return
            }
            if (this._currentPageNavLink) {
                this._currentPageNavLink.classList.remove("current")
            }
            if (el) {
                el.classList.add("current");
                this._currentPageNavLink = el
            }
        };
        proto.setCurrentSection = function(section) {
            if (this.elementToApplyClassesAgainst === null) {
                return
            }
            if (this._section && this._section === section) {
                return
            }
            this._section = section;
            for (var i = 0, len = this._section.element.classList.length; i < len; i++) {
                var key = this._section.element.classList[i];
                if (this.sectionThemeMap.hasOwnProperty(key)) {
                    this.setTheme(this.sectionThemeMap[key]);
                    return
                }
            }
            this.setTheme(this.defaultTheme)
        };
        proto.setTheme = function(newTheme) {
            if (this._currentTheme === newTheme) {
                return
            }
            for (var key in this.sectionThemeMap) {
                var prevTheme = this.sectionThemeMap[key];
                if (prevTheme !== newTheme) {
                    this.elementToApplyClassesAgainst.classList.remove(prevTheme)
                }
            }
            this.elementToApplyClassesAgainst.classList.add(newTheme);
            this._currentTheme = newTheme
        };
        proto.removeThemes = function() {
            this._currentTheme = null;
            for (var key in this.sectionThemeMap) {
                this.elementToApplyClassesAgainst.classList.remove(this.sectionThemeMap[key])
            }
        };
        module.exports = new LocalNavStyleChanger
    }, {
        "./../model/DataAttributes": 376,
        "@marcom/ac-polyfills/Element/prototype.classList": 393
    }],
    375: [function(require, module, exports) {
        "use strict";
        module.exports = {
            BaseComponent: require("../core/BaseComponent")
        }
    }, {
        "../core/BaseComponent": 371
    }],
    376: [function(require, module, exports) {
        "use strict";
        module.exports = {
            PAGE_TYPE: "data-page-type",
            SECTION_TYPE: "data-section-type",
            JUMP_SECTION_NAME: "data-page-jump-name",
            COMPONENT_LIST: "data-component-list"
        }
    }, {}],
    377: [function(require, module, exports) {
        "use strict";
        var ac_feature = {
            isDesktop: require("@marcom/ac-feature/isDesktop"),
            isRetina: require("@marcom/ac-feature/isRetina")
        };
        module.exports = {
            TOUCH: undefined,
            SVG: undefined,
            PAGE_JUMP: undefined,
            IS_IE8: undefined,
            IS_DESKTOP: undefined,
            IS_RETINA: undefined,
            init: function() {
                var htmlEl = document.getElementsByTagName("html")[0];
                this.TOUCH = htmlEl.classList.contains("touch");
                this.SVG = htmlEl.classList.contains("svg");
                this.PAGE_JUMP = htmlEl.classList.contains("pageJump");
                this.IS_IE8 = htmlEl.classList.contains("ie8");
                this.IS_DESKTOP = ac_feature.isDesktop();
                this.IS_RETINA = ac_feature.isRetina()
            },
            extend: function(otherObject) {
                if (!otherObject.hasOwnProperty("init") || typeof otherObject.init !== "function") {
                    throw new TypeError("The object extended Jetpack.model.EnabledFeatures must contain an init function")
                }
                var originalInit = this.init;
                var extendedInit = otherObject.init;
                var extended = Object.assign(this, otherObject);
                extended.init = function() {
                    if (this.HAS_INITIALIZED) {
                        return
                    }
                    this.HAS_INITIALIZED = true;
                    originalInit.call(extended);
                    extendedInit.call(extended)
                };
                return extended
            },
            HAS_INITIALIZED: false
        }
    }, {
        "@marcom/ac-feature/isDesktop": 161,
        "@marcom/ac-feature/isRetina": 163
    }],
    378: [function(require, module, exports) {
        "use strict";
        module.exports = {
            BaseSection: require("../core/BaseSection")
        }
    }, {
        "../core/BaseSection": 373
    }],
    379: [function(require, module, exports) {
        "use strict";
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;

        function Page() {
            EventEmitterMicro.call(this)
        }
        var proto = Page.prototype = Object.create(EventEmitterMicro.prototype);
        Page.prototype.constructor = Page;
        proto.deepRefreshAllElementMetrics = function() {
            this.trigger(Page.prototype.DEEP_REFRESH_ALL_METRICS)
        };
        proto.DEEP_REFRESH_ALL_METRICS = "page.deep_refresh_all_metrics";
        module.exports = new Page
    }, {
        "@marcom/ac-event-emitter-micro": 369
    }],
    380: [function(require, module, exports) {
        "use strict";
        module.exports = function() {
            var ViewportEmitter;
            if (window.ViewportEmitterTestProxy) {
                ViewportEmitter = window.ViewportEmitterTestProxy
            } else {
                ViewportEmitter = {};
                ViewportEmitter.viewport = "large";
                ViewportEmitter.on = ViewportEmitter.off = function() {}
            }
            return ViewportEmitter
        }
    }, {}],
    381: [function(require, module, exports) {
        (function(global) {
            "use strict";
            if (!global.console) {
                global.console = {}
            }
            var con = global.console;
            var prop, method;
            var dummy = function() {};
            var properties = ["memory"];
            var methods = ("assert,clear,count,debug,dir,dirxml,error,exception,group," + "groupCollapsed,groupEnd,info,log,markTimeline,profile,profiles,profileEnd," + "show,table,time,timeEnd,timeline,timelineEnd,timeStamp,trace,warn").split(",");
            while (prop = properties.pop())
                if (!con[prop]) con[prop] = {};
            while (method = methods.pop())
                if (typeof con[method] !== "function") con[method] = dummy
        })(typeof window === "undefined" ? this : window)
    }, {}],
    382: [function(require, module, exports) {
        (function() {
            if (window.matchMedia && window.matchMedia("all").addListener) {
                return false
            }
            var localMatchMedia = window.matchMedia,
                hasMediaQueries = localMatchMedia("only all").matches,
                isListening = false,
                timeoutID = 0,
                queries = [],
                handleChange = function(evt) {
                    clearTimeout(timeoutID);
                    timeoutID = setTimeout(function() {
                        for (var i = 0, il = queries.length; i < il; i++) {
                            var mql = queries[i].mql,
                                listeners = queries[i].listeners || [],
                                matches = localMatchMedia(mql.media).matches;
                            if (matches !== mql.matches) {
                                mql.matches = matches;
                                for (var j = 0, jl = listeners.length; j < jl; j++) {
                                    listeners[j].call(window, mql)
                                }
                            }
                        }
                    }, 30)
                };
            window.matchMedia = function(media) {
                var mql = localMatchMedia(media),
                    listeners = [],
                    index = 0;
                mql.addListener = function(listener) {
                    if (!hasMediaQueries) {
                        return
                    }
                    if (!isListening) {
                        isListening = true;
                        window.addEventListener("resize", handleChange, true)
                    }
                    if (index === 0) {
                        index = queries.push({
                            mql: mql,
                            listeners: listeners
                        })
                    }
                    listeners.push(listener)
                };
                mql.removeListener = function(listener) {
                    for (var i = 0, il = listeners.length; i < il; i++) {
                        if (listeners[i] === listener) {
                            listeners.splice(i, 1)
                        }
                    }
                };
                return mql
            }
        })()
    }, {}],
    383: [function(require, module, exports) {
        window.matchMedia || (window.matchMedia = function() {
            "use strict";
            var styleMedia = window.styleMedia || window.media;
            if (!styleMedia) {
                var style = document.createElement("style"),
                    script = document.getElementsByTagName("script")[0],
                    info = null;
                style.type = "text/css";
                style.id = "matchmediajs-test";
                script.parentNode.insertBefore(style, script);
                info = "getComputedStyle" in window && window.getComputedStyle(style, null) || style.currentStyle;
                styleMedia = {
                    matchMedium: function(media) {
                        var text = "@media " + media + "{ #matchmediajs-test { width: 1px; } }";
                        if (style.styleSheet) {
                            style.styleSheet.cssText = text
                        } else {
                            style.textContent = text
                        }
                        return info.width === "1px"
                    }
                }
            }
            return function(media) {
                return {
                    matches: styleMedia.matchMedium(media || "all"),
                    media: media || "all"
                }
            }
        }())
    }, {}],
    384: [function(require, module, exports) {
        if (!Array.isArray) {
            Array.isArray = function(arg) {
                return Object.prototype.toString.call(arg) === "[object Array]"
            }
        }
    }, {}],
    385: [function(require, module, exports) {
        if (!Array.prototype.every) {
            Array.prototype.every = function every(callback, thisObj) {
                var arrayObject = Object(this);
                var len = arrayObject.length >>> 0;
                var i;
                if (typeof callback !== "function") {
                    throw new TypeError(callback + " is not a function")
                }
                for (i = 0; i < len; i += 1) {
                    if (i in arrayObject && !callback.call(thisObj, arrayObject[i], i, arrayObject)) {
                        return false
                    }
                }
                return true
            }
        }
    }, {}],
    386: [function(require, module, exports) {
        if (!Array.prototype.filter) {
            Array.prototype.filter = function filter(callback, thisObj) {
                var arrayObject = Object(this);
                var len = arrayObject.length >>> 0;
                var i;
                var results = [];
                if (typeof callback !== "function") {
                    throw new TypeError(callback + " is not a function")
                }
                for (i = 0; i < len; i += 1) {
                    if (i in arrayObject && callback.call(thisObj, arrayObject[i], i, arrayObject)) {
                        results.push(arrayObject[i])
                    }
                }
                return results
            }
        }
    }, {}],
    387: [function(require, module, exports) {
        if (!Array.prototype.forEach) {
            Array.prototype.forEach = function forEach(callback, thisObj) {
                var arrayObject = Object(this);
                var i;
                var currentValue;
                if (typeof callback !== "function") {
                    throw new TypeError("No function object passed to forEach.")
                }
                var length = this.length;
                for (i = 0; i < length; i += 1) {
                    currentValue = arrayObject[i];
                    callback.call(thisObj, currentValue, i, arrayObject)
                }
            }
        }
    }, {}],
    388: [function(require, module, exports) {
        if (!Array.prototype.indexOf) {
            Array.prototype.indexOf = function indexOf(searchElement, fromIndex) {
                var startIndex = fromIndex || 0;
                var currentIndex = 0;
                if (startIndex < 0) {
                    startIndex = this.length + fromIndex - 1;
                    if (startIndex < 0) {
                        throw "Wrapped past beginning of array while looking up a negative start index."
                    }
                }
                for (currentIndex = 0; currentIndex < this.length; currentIndex++) {
                    if (this[currentIndex] === searchElement) {
                        return currentIndex
                    }
                }
                return -1
            }
        }
    }, {}],
    389: [function(require, module, exports) {
        if (!Array.prototype.reduce) {
            Array.prototype.reduce = function reduce(callback, initialValue) {
                var arrayObj = Object(this);
                var len = arrayObj.length >>> 0;
                var i = 0;
                var result;
                if (typeof callback !== "function") {
                    throw new TypeError(callback + " is not a function")
                }
                if (typeof initialValue === "undefined") {
                    if (!len) {
                        throw new TypeError("Reduce of empty array with no initial value")
                    }
                    result = arrayObj[0];
                    i = 1
                } else {
                    result = initialValue
                }
                while (i < len) {
                    if (i in arrayObj) {
                        result = callback.call(undefined, result, arrayObj[i], i, arrayObj);
                        i += 1
                    }
                }
                return result
            }
        }
    }, {}],
    390: [function(require, module, exports) {
        (function() {
            "use strict";
            var _slice = Array.prototype.slice;
            try {
                _slice.call(document.documentElement)
            } catch (e) {
                Array.prototype.slice = function(begin, end) {
                    end = typeof end !== "undefined" ? end : this.length;
                    if (Object.prototype.toString.call(this) === "[object Array]") {
                        return _slice.call(this, begin, end)
                    }
                    var i, cloned = [],
                        size, len = this.length;
                    var start = begin || 0;
                    start = start >= 0 ? start : len + start;
                    var upTo = end ? end : len;
                    if (end < 0) {
                        upTo = len + end
                    }
                    size = upTo - start;
                    if (size > 0) {
                        cloned = new Array(size);
                        if (this.charAt) {
                            for (i = 0; i < size; i++) {
                                cloned[i] = this.charAt(start + i)
                            }
                        } else {
                            for (i = 0; i < size; i++) {
                                cloned[i] = this[start + i]
                            }
                        }
                    }
                    return cloned
                }
            }
        })()
    }, {}],
    391: [function(require, module, exports) {
        if (document.createEvent) {
            try {
                new window.CustomEvent("click")
            } catch (err) {
                window.CustomEvent = function() {
                    function CustomEvent(event, params) {
                        params = params || {
                            bubbles: false,
                            cancelable: false,
                            detail: undefined
                        };
                        var evt = document.createEvent("CustomEvent");
                        evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
                        return evt
                    }
                    CustomEvent.prototype = window.Event.prototype;
                    return CustomEvent
                }()
            }
        }
    }, {}],
    392: [function(require, module, exports) {
        if (!Date.now) {
            Date.now = function now() {
                return (new Date).getTime()
            }
        }
    }, {}],
    393: [function(require, module, exports) {
        if ("document" in self) {
            if (!("classList" in document.createElement("_"))) {
                (function(view) {
                    "use strict";
                    if (!("Element" in view)) return;
                    var classListProp = "classList",
                        protoProp = "prototype",
                        elemCtrProto = view.Element[protoProp],
                        objCtr = Object,
                        strTrim = String[protoProp].trim || function() {
                            return this.replace(/^\s+|\s+$/g, "")
                        },
                        arrIndexOf = Array[protoProp].indexOf || function(item) {
                            var i = 0,
                                len = this.length;
                            for (; i < len; i++) {
                                if (i in this && this[i] === item) {
                                    return i
                                }
                            }
                            return -1
                        },
                        DOMEx = function(type, message) {
                            this.name = type;
                            this.code = DOMException[type];
                            this.message = message
                        },
                        checkTokenAndGetIndex = function(classList, token) {
                            if (token === "") {
                                throw new DOMEx("SYNTAX_ERR", "An invalid or illegal string was specified")
                            }
                            if (/\s/.test(token)) {
                                throw new DOMEx("INVALID_CHARACTER_ERR", "String contains an invalid character")
                            }
                            return arrIndexOf.call(classList, token)
                        },
                        ClassList = function(elem) {
                            var trimmedClasses = strTrim.call(elem.getAttribute("class") || ""),
                                classes = trimmedClasses ? trimmedClasses.split(/\s+/) : [],
                                i = 0,
                                len = classes.length;
                            for (; i < len; i++) {
                                this.push(classes[i])
                            }
                            this._updateClassName = function() {
                                elem.setAttribute("class", this.toString())
                            }
                        },
                        classListProto = ClassList[protoProp] = [],
                        classListGetter = function() {
                            return new ClassList(this)
                        };
                    DOMEx[protoProp] = Error[protoProp];
                    classListProto.item = function(i) {
                        return this[i] || null
                    };
                    classListProto.contains = function(token) {
                        token += "";
                        return checkTokenAndGetIndex(this, token) !== -1
                    };
                    classListProto.add = function() {
                        var tokens = arguments,
                            i = 0,
                            l = tokens.length,
                            token, updated = false;
                        do {
                            token = tokens[i] + "";
                            if (checkTokenAndGetIndex(this, token) === -1) {
                                this.push(token);
                                updated = true
                            }
                        } while (++i < l);
                        if (updated) {
                            this._updateClassName()
                        }
                    };
                    classListProto.remove = function() {
                        var tokens = arguments,
                            i = 0,
                            l = tokens.length,
                            token, updated = false,
                            index;
                        do {
                            token = tokens[i] + "";
                            index = checkTokenAndGetIndex(this, token);
                            while (index !== -1) {
                                this.splice(index, 1);
                                updated = true;
                                index = checkTokenAndGetIndex(this, token)
                            }
                        } while (++i < l);
                        if (updated) {
                            this._updateClassName()
                        }
                    };
                    classListProto.toggle = function(token, force) {
                        token += "";
                        var result = this.contains(token),
                            method = result ? force !== true && "remove" : force !== false && "add";
                        if (method) {
                            this[method](token)
                        }
                        if (force === true || force === false) {
                            return force
                        } else {
                            return !result
                        }
                    };
                    classListProto.toString = function() {
                        return this.join(" ")
                    };
                    if (objCtr.defineProperty) {
                        var classListPropDesc = {
                            get: classListGetter,
                            enumerable: true,
                            configurable: true
                        };
                        try {
                            objCtr.defineProperty(elemCtrProto, classListProp, classListPropDesc)
                        } catch (ex) {
                            if (ex.number === -2146823252) {
                                classListPropDesc.enumerable = false;
                                objCtr.defineProperty(elemCtrProto, classListProp, classListPropDesc)
                            }
                        }
                    } else if (objCtr[protoProp].__defineGetter__) {
                        elemCtrProto.__defineGetter__(classListProp, classListGetter)
                    }
                })(self)
            } else {
                (function() {
                    "use strict";
                    var testElement = document.createElement("_");
                    testElement.classList.add("c1", "c2");
                    if (!testElement.classList.contains("c2")) {
                        var createMethod = function(method) {
                            var original = DOMTokenList.prototype[method];
                            DOMTokenList.prototype[method] = function(token) {
                                var i, len = arguments.length;
                                for (i = 0; i < len; i++) {
                                    token = arguments[i];
                                    original.call(this, token)
                                }
                            }
                        };
                        createMethod("add");
                        createMethod("remove")
                    }
                    testElement.classList.toggle("c3", false);
                    if (testElement.classList.contains("c3")) {
                        var _toggle = DOMTokenList.prototype.toggle;
                        DOMTokenList.prototype.toggle = function(token, force) {
                            if (1 in arguments && !this.contains(token) === !force) {
                                return force
                            } else {
                                return _toggle.call(this, token)
                            }
                        }
                    }
                    testElement = null
                })()
            }
        }
    }, {}],
    394: [function(require, module, exports) {
        if (!Function.prototype.bind) {
            Function.prototype.bind = function(originalContext) {
                if (typeof this !== "function") {
                    throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable")
                }
                var applicableArgs = Array.prototype.slice.call(arguments, 1);
                var functionToBind = this;
                var fnOriginalPrototype = function() {};
                var fnBound = function() {
                    return functionToBind.apply(this instanceof fnOriginalPrototype && originalContext ? this : originalContext, applicableArgs.concat(Array.prototype.slice.call(arguments)))
                };
                fnOriginalPrototype.prototype = this.prototype;
                fnBound.prototype = new fnOriginalPrototype;
                return fnBound
            }
        }
    }, {}],
    395: [function(require, module, exports) {
        if (typeof Object.assign != "function") {
            Object.assign = function(target) {
                "use strict";
                if (target == null) {
                    throw new TypeError("Cannot convert undefined or null to object")
                }
                target = Object(target);
                for (var index = 1; index < arguments.length; index++) {
                    var source = arguments[index];
                    if (source != null) {
                        for (var key in source) {
                            if (Object.prototype.hasOwnProperty.call(source, key)) {
                                target[key] = source[key]
                            }
                        }
                    }
                }
                return target
            }
        }
    }, {}],
    396: [function(require, module, exports) {
        if (!Object.create) {
            var F = function() {};
            Object.create = function(proto) {
                if (arguments.length > 1) {
                    throw new Error("Second argument not supported")
                }
                if (proto === null || typeof proto !== "object") {
                    throw new TypeError("Object prototype may only be an Object.")
                }
                F.prototype = proto;
                return new F
            }
        }
    }, {}],
    397: [function(require, module, exports) {
        if (!Object.keys) {
            Object.keys = function keys(obj) {
                var keysArray = [];
                var currentKey;
                if (!obj || typeof obj.hasOwnProperty !== "function") {
                    throw "Object.keys called on non-object."
                }
                for (currentKey in obj) {
                    if (obj.hasOwnProperty(currentKey)) {
                        keysArray.push(currentKey)
                    }
                }
                return keysArray
            }
        }
    }, {}],
    398: [function(require, module, exports) {
        require("console-polyfill")
    }, {
        "console-polyfill": 381
    }],
    399: [function(require, module, exports) {
        require("matchmedia-polyfill");
        require("matchmedia-polyfill/matchMedia.addListener")
    }, {
        "matchmedia-polyfill": 383,
        "matchmedia-polyfill/matchMedia.addListener": 382
    }],
    400: [function(require, module, exports) {
        require("../Date/now");
        (function() {
            if ("performance" in window == false) {
                window.performance = {}
            }
            if ("now" in window.performance == false) {
                var nowOffset = Date.now();
                if (performance.timing && performance.timing.navigationStart) {
                    nowOffset = performance.timing.navigationStart
                }
                window.performance.now = function now() {
                    return Date.now() - nowOffset
                }
            }
        })()
    }, {
        "../Date/now": 392
    }],
    401: [function(require, module, exports) {
        (function() {
            var lastTime = 0;
            var vendors = ["ms", "moz", "webkit", "o"];
            for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
                window.requestAnimationFrame = window[vendors[x] + "RequestAnimationFrame"];
                window.cancelAnimationFrame = window[vendors[x] + "CancelAnimationFrame"] || window[vendors[x] + "CancelRequestAnimationFrame"]
            }
            if (!window.requestAnimationFrame) window.requestAnimationFrame = function(callback, element) {
                var currTime = Date.now();
                var timeToCall = Math.max(0, 16 - (currTime - lastTime));
                var id = window.setTimeout(function() {
                    callback(currTime + timeToCall)
                }, timeToCall);
                lastTime = currTime + timeToCall;
                return id
            };
            if (!window.cancelAnimationFrame) window.cancelAnimationFrame = function(id) {
                clearTimeout(id)
            }
        })()
    }, {}],
    402: [function(require, module, exports) {
        "use strict";
        module.exports = function supplant(str, obj, pattern) {
            if (!obj) {
                return str
            }
            pattern = pattern || /{([^{}]*)}/g;
            return str.replace(pattern, function(a, b) {
                var r = obj[b];
                return typeof r === "string" || typeof r === "number" || typeof r === "boolean" ? r : a
            })
        }
    }, {}],
    403: [function(require, module, exports) {
        "use strict";
        var navigatorObj = {
            ua: window.navigator.userAgent,
            platform: window.navigator.platform,
            vendor: window.navigator.vendor
        };
        module.exports = require("./parseUserAgent")(navigatorObj)
    }, {
        "./parseUserAgent": 406
    }],
    404: [function(require, module, exports) {
        "use strict";
        module.exports = {
            browser: {
                safari: false,
                chrome: false,
                firefox: false,
                ie: false,
                opera: false,
                android: false,
                edge: false,
                version: {
                    name: "",
                    major: 0,
                    minor: 0,
                    patch: 0,
                    documentMode: false
                }
            },
            os: {
                osx: false,
                ios: false,
                android: false,
                windows: false,
                linux: false,
                fireos: false,
                chromeos: false,
                version: {
                    name: "",
                    major: 0,
                    minor: 0,
                    patch: 0
                }
            }
        }
    }, {}],
    405: [function(require, module, exports) {
        "use strict";
        module.exports = {
            browser: [{
                name: "edge",
                userAgent: "Edge",
                version: ["rv", "Edge"],
                test: function(navigatorObj) {
                    return navigatorObj.ua.indexOf("Edge") > -1 || navigatorObj.ua === "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
                }
            }, {
                name: "chrome",
                userAgent: "Chrome"
            }, {
                name: "firefox",
                test: function(navigatorObj) {
                    return navigatorObj.ua.indexOf("Firefox") > -1 && navigatorObj.ua.indexOf("Opera") === -1
                },
                version: "Firefox"
            }, {
                name: "android",
                userAgent: "Android"
            }, {
                name: "safari",
                test: function(navigatorObj) {
                    return navigatorObj.ua.indexOf("Safari") > -1 && navigatorObj.vendor.indexOf("Apple") > -1
                },
                version: "Version"
            }, {
                name: "ie",
                test: function(navigatorObj) {
                    return navigatorObj.ua.indexOf("IE") > -1 || navigatorObj.ua.indexOf("Trident") > -1
                },
                version: ["MSIE", "rv"],
                parseDocumentMode: function() {
                    var documentModeForIE = false;
                    if (document.documentMode) {
                        documentModeForIE = parseInt(document.documentMode, 10)
                    }
                    return documentModeForIE
                }
            }, {
                name: "opera",
                userAgent: "Opera",
                version: ["Version", "Opera"]
            }],
            os: [{
                name: "windows",
                test: function(navigatorObj) {
                    return navigatorObj.platform.indexOf("Win") > -1
                },
                version: "Windows NT"
            }, {
                name: "osx",
                userAgent: "Mac",
                test: function(navigatorObj) {
                    return navigatorObj.platform.indexOf("Mac") > -1
                }
            }, {
                name: "ios",
                test: function(navigatorObj) {
                    return navigatorObj.ua.indexOf("iPhone") > -1 || navigatorObj.ua.indexOf("iPad") > -1
                },
                version: ["iPhone OS", "CPU OS"]
            }, {
                name: "linux",
                userAgent: "Linux",
                test: function(navigatorObj) {
                    return navigatorObj.platform.indexOf("Linux") > -1 && navigatorObj.ua.indexOf("Android") === -1
                }
            }, {
                name: "fireos",
                test: function(navigatorObj) {
                    return navigatorObj.ua.indexOf("Firefox") > -1 && navigatorObj.ua.indexOf("Mobile") > -1
                },
                version: "rv"
            }, {
                name: "android",
                userAgent: "Android"
            }, {
                name: "chromeos",
                userAgent: "CrOS"
            }]
        }
    }, {}],
    406: [function(require, module, exports) {
        "use strict";
        var defaults = require("./defaults");
        var dictionary = require("./dictionary");

        function _matchVersionStrRegExp(str) {
            return new RegExp(str + "[a-zA-Z\\s/:]+([0-9_.]+)", "i")
        }

        function _parseVersion(data, ua) {
            if (typeof data.parseVersion === "function") {
                return data.parseVersion(ua)
            } else {
                var versionSearchStr = data.version || data.userAgent;
                if (typeof versionSearchStr === "string") {
                    versionSearchStr = [versionSearchStr]
                }
                var versionSearchStrLength = versionSearchStr.length;
                var match;
                for (var i = 0; i < versionSearchStrLength; i++) {
                    match = ua.match(_matchVersionStrRegExp(versionSearchStr[i]));
                    if (match && match.length > 1) {
                        return match[1].replace(/_/g, ".")
                    }
                }
            }
        }

        function _parseUserAgent(dictionaryData, defaultObj, navigatorObj) {
            var dictionaryDataLength = dictionaryData.length;
            var current;
            var currentVersion;
            for (var i = 0; i < dictionaryDataLength; i++) {
                if (typeof dictionaryData[i].test === "function") {
                    if (dictionaryData[i].test(navigatorObj) === true) {
                        current = dictionaryData[i].name
                    }
                } else {
                    if (navigatorObj.ua.indexOf(dictionaryData[i].userAgent) > -1) {
                        current = dictionaryData[i].name
                    }
                }
                if (current) {
                    defaultObj[current] = true;
                    currentVersion = _parseVersion(dictionaryData[i], navigatorObj.ua);
                    if (typeof currentVersion === "string") {
                        var versionBreakdown = currentVersion.split(".");
                        defaultObj.version.name = currentVersion;
                        if (versionBreakdown && versionBreakdown.length > 0) {
                            defaultObj.version.major = parseInt(versionBreakdown[0] || 0);
                            defaultObj.version.minor = parseInt(versionBreakdown[1] || 0);
                            defaultObj.version.patch = parseInt(versionBreakdown[2] || 0)
                        }
                    } else if (current === "edge") {
                        defaultObj.version.name = "12.0.0";
                        defaultObj.version.major = "12";
                        defaultObj.version.minor = "0";
                        defaultObj.version.patch = "0"
                    }
                    if (typeof dictionaryData[i].parseDocumentMode === "function") {
                        defaultObj.version.documentMode = dictionaryData[i].parseDocumentMode()
                    }
                    return defaultObj
                }
            }
            return defaultObj
        }

        function parseUserAgent(navigatorObj) {
            var userAgent = {};
            userAgent.browser = _parseUserAgent(dictionary.browser, defaults.browser, navigatorObj);
            userAgent.os = _parseUserAgent(dictionary.os, defaults.os, navigatorObj);
            return userAgent
        }
        module.exports = parseUserAgent
    }, {
        "./defaults": 404,
        "./dictionary": 405
    }],
    407: [function(require, module, exports) {
        arguments[4][170][0].apply(exports, arguments)
    }, {
        "./../maps/focusableElement": 413,
        dup: 170
    }],
    408: [function(require, module, exports) {
        arguments[4][171][0].apply(exports, arguments)
    }, {
        "./../maps/ariaMap": 412,
        "./TabManager": 407,
        "./setAttributes": 410,
        dup: 171
    }],
    409: [function(require, module, exports) {
        arguments[4][173][0].apply(exports, arguments)
    }, {
        dup: 173
    }],
    410: [function(require, module, exports) {
        arguments[4][174][0].apply(exports, arguments)
    }, {
        dup: 174
    }],
    411: [function(require, module, exports) {
        arguments[4][175][0].apply(exports, arguments)
    }, {
        "./../maps/ariaMap": 412,
        "./removeAttributes": 409,
        "./setAttributes": 410,
        dup: 175
    }],
    412: [function(require, module, exports) {
        arguments[4][177][0].apply(exports, arguments)
    }, {
        dup: 177
    }],
    413: [function(require, module, exports) {
        arguments[4][178][0].apply(exports, arguments)
    }, {
        dup: 178
    }],
    414: [function(require, module, exports) {
        "use strict";
        var getTransport = require("./request/factory");
        var DEFAULT_SETTINGS = {
            complete: function(xhr, status) {},
            error: function(xhr, status) {},
            method: "GET",
            headers: {},
            success: function(data, status, xhr) {},
            timeout: 5e3
        };
        var extend = function() {
            for (var i = 1; i < arguments.length; i++) {
                for (var key in arguments[i]) {
                    if (arguments[i].hasOwnProperty(key)) {
                        arguments[0][key] = arguments[i][key]
                    }
                }
            }
            return arguments[0]
        };
        var ac_ajax_xhr = {
            ajax: function(url, settings) {
                settings = extend({}, DEFAULT_SETTINGS, settings);
                if (url.substr(0, 2) === "//") {
                    url = window.location.protocol + url
                }
                var transport = getTransport(url);
                transport.open(settings.method, url);
                transport.setTransportHeaders(settings.headers);
                transport.setReadyStateChangeHandlers(settings.complete, settings.error, settings.success);
                transport.setTimeout(settings.timeout, settings.error, settings.complete);
                transport.send(settings.data);
                return transport
            },
            get: function(url, settings) {
                settings.method = "GET";
                return ac_ajax_xhr.ajax(url, settings)
            },
            head: function(url, settings) {
                settings.method = "HEAD";
                return ac_ajax_xhr.ajax(url, settings)
            },
            post: function(url, settings) {
                settings.method = "POST";
                return ac_ajax_xhr.ajax(url, settings)
            }
        };
        module.exports = ac_ajax_xhr
    }, {
        "./request/factory": 415
    }],
    415: [function(require, module, exports) {
        "use strict";
        var XMLRequest = require("./xmlhttprequest");
        var XDRequest = require("./xdomainrequest");
        var PROTOCOL_PATTERN = /.*(?=:\/\/)/;
        var HOST_NAME_PATTERN = /^.*:\/\/|\/.+$/g;
        var IS_OLD_IE = window.XDomainRequest && document.documentMode < 10;
        var isCrossDomain = function(url) {
            if (!url.match(PROTOCOL_PATTERN)) {
                return false
            }
            var urlHostName = url.replace(HOST_NAME_PATTERN, "");
            return urlHostName !== window.location.hostname
        };
        module.exports = function(url, data) {
            var Transport = IS_OLD_IE && isCrossDomain(url) ? XDRequest : XMLRequest;
            return new Transport
        }
    }, {
        "./xdomainrequest": 417,
        "./xmlhttprequest": 418
    }],
    416: [function(require, module, exports) {
        "use strict";
        var Request = function() {};
        Request.create = function() {
            var F = function() {};
            F.prototype = Request.prototype;
            return new F
        };
        Request.prototype.open = function(method, url) {
            method = method.toUpperCase();
            this.xhr.open(method, url)
        };
        Request.prototype.send = function(data) {
            this.xhr.send(data)
        };
        Request.prototype.setTimeout = function(duration, error, complete) {
            this.xhr.ontimeout = function() {
                error(this.xhr, this.status);
                complete(this.xhr, this.status)
            }.bind(this)
        };
        Request.prototype.setTransportHeaders = function(headers) {
            for (var header in headers) {
                this.xhr.setRequestHeader(header, headers[header])
            }
        };
        module.exports = Request
    }, {}],
    417: [function(require, module, exports) {
        "use strict";
        var Request = require("./request");
        var toQueryParameters = require("@marcom/ac-object/toQueryParameters");
        var XDRequest = function() {
            this.xhr = new XDomainRequest
        };
        XDRequest.prototype = Request.create();
        XDRequest.prototype.setReadyStateChangeHandlers = function(complete, error, success) {
            this.xhr.onerror = function() {
                error(this.xhr, this.status);
                complete(this.xhr, this.status)
            }.bind(this);
            this.xhr.onload = function() {
                success(this.xhr.responseText, this.xhr.status, this.xhr);
                complete(this.xhr, this.status)
            }.bind(this)
        };
        XDRequest.prototype.send = function(data) {
            if (data && typeof data === "object") {
                data = toQueryParameters(data)
            }
            this.xhr.send(data)
        };
        XDRequest.prototype.setTransportHeaders = function(headers) {};
        module.exports = XDRequest
    }, {
        "./request": 416,
        "@marcom/ac-object/toQueryParameters": 448
    }],
    418: [function(require, module, exports) {
        "use strict";
        var Request = require("./request");
        var XMLRequest = function() {
            this.xhr = new XMLHttpRequest
        };
        XMLRequest.prototype = Request.create();
        XMLRequest.prototype.setReadyStateChangeHandlers = function(complete, error, success) {
            this.xhr.onreadystatechange = function(e) {
                if (this.xhr.readyState === 4) {
                    clearTimeout(this.timeout);
                    if (this.xhr.status >= 200 && this.xhr.status < 300) {
                        success(this.xhr.responseText, this.xhr.status, this.xhr);
                        complete(this.xhr, this.status)
                    } else {
                        error(this.xhr, this.status);
                        complete(this.xhr, this.status)
                    }
                }
            }.bind(this)
        };
        module.exports = XMLRequest
    }, {
        "./request": 416
    }],
    419: [function(require, module, exports) {
        "use strict";
        module.exports = function select(el) {
            if (typeof el.select === "function") {
                var success = false;
                success = el.select();
                if (!success) {
                    el.setSelectionRange(0, el.value.length)
                }
            } else {
                var range = document.createRange();
                range.selectNodeContents(el);
                var sel = window.getSelection();
                sel.removeAllRanges();
                sel.addRange(range)
            }
        }
    }, {}],
    420: [function(require, module, exports) {
        "use strict";
        var DEBUG_MESSAGING_KEY = "f7c9180f-5c45-47b4-8de4-428015f096c0";
        var allowDebugMessaging = !!window.localStorage.getItem(DEBUG_MESSAGING_KEY);
        module.exports = function expose(funcName) {
            return function() {
                if (allowDebugMessaging && typeof window.console === "object") {
                    return console[funcName].apply(console, Array.prototype.slice.call(arguments, 0))
                }
            }
        }
    }, {}],
    421: [function(require, module, exports) {
        "use strict";
        module.exports = require("./internal/expose")("log")
    }, {
        "./internal/expose": 420
    }],
    422: [function(require, module, exports) {
        arguments[4][13][0].apply(exports, arguments)
    }, {
        "./ac-event-emitter-micro/EventEmitterMicro": 423,
        dup: 13
    }],
    423: [function(require, module, exports) {
        arguments[4][14][0].apply(exports, arguments)
    }, {
        dup: 14
    }],
    424: [function(require, module, exports) {
        arguments[4][3][0].apply(exports, arguments)
    }, {
        "./shared/getEventType": 430,
        "./utils/addEventListener": 431,
        dup: 3
    }],
    425: [function(require, module, exports) {
        arguments[4][4][0].apply(exports, arguments)
    }, {
        "./shared/camelCasedEventTypes": 426,
        "./shared/prefixHelper": 427,
        "./shared/windowFallbackEventTypes": 428,
        "./utils/eventTypeAvailable": 429,
        dup: 4
    }],
    426: [function(require, module, exports) {
        arguments[4][5][0].apply(exports, arguments)
    }, {
        dup: 5
    }],
    427: [function(require, module, exports) {
        arguments[4][6][0].apply(exports, arguments)
    }, {
        dup: 6
    }],
    428: [function(require, module, exports) {
        arguments[4][7][0].apply(exports, arguments)
    }, {
        dup: 7
    }],
    429: [function(require, module, exports) {
        arguments[4][8][0].apply(exports, arguments)
    }, {
        dup: 8
    }],
    430: [function(require, module, exports) {
        arguments[4][10][0].apply(exports, arguments)
    }, {
        "@marcom/ac-prefixer/getEventType": 425,
        dup: 10
    }],
    431: [function(require, module, exports) {
        arguments[4][11][0].apply(exports, arguments)
    }, {
        dup: 11
    }],
    432: [function(require, module, exports) {
        "use strict";
        module.exports = require("./fullscreen")
    }, {
        "./fullscreen": 438
    }],
    433: [function(require, module, exports) {
        module.exports = {
            STANDARD: "standard",
            IOS: "ios"
        }
    }, {}],
    434: [function(require, module, exports) {
        "use strict";
        var addEventListener = require("@marcom/ac-dom-events/addEventListener");
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var eventTypes = require("./../events/types");
        var modes = require("./../consts/modes");
        var desktopFullscreenDelegate = new EventEmitterMicro;

        function onEnterFullscreen(e) {
            desktopFullscreenDelegate.trigger(eventTypes.ENTERFULLSCREEN, e)
        }

        function onExitFullscreen(e) {
            desktopFullscreenDelegate.trigger(eventTypes.EXITFULLSCREEN, e)
        }

        function onFullscreenchange(e) {
            if (desktopFullscreenDelegate.fullscreenElement()) {
                onEnterFullscreen(e)
            } else {
                onExitFullscreen(e)
            }
        }

        function bindFullscreenEvent() {
            addEventListener(document, "fullscreenchange", onFullscreenchange)
        }
        bindFullscreenEvent();
        desktopFullscreenDelegate.fullscreenEnabled = function(el) {
            var fullscreenEnabled = document.fullscreenEnabled || document.webkitFullscreenEnabled || document.mozFullScreenEnabled || document.msFullscreenEnabled;
            return !!fullscreenEnabled
        };
        desktopFullscreenDelegate.fullscreenElement = function() {
            return document.fullscreenElement || document.webkitFullscreenElement || document.mozFullScreenElement || document.msFullscreenElement || document.webkitCurrentFullScreenElement
        };
        desktopFullscreenDelegate.exitFullscreen = function(el) {
            var method;
            if (typeof document.exitFullscreen === "function") {
                method = "exitFullscreen"
            } else if (typeof document.webkitExitFullscreen === "function") {
                method = "webkitExitFullscreen"
            } else if (typeof document.webkitCancelFullScreen === "function") {
                method = "webkitCancelFullScreen"
            } else if (typeof document.mozCancelFullScreen === "function") {
                method = "mozCancelFullScreen"
            } else if (typeof document.msExitFullscreen === "function") {
                method = "msExitFullscreen"
            }
            if (typeof document[method] === "function") {
                document[method].call(document)
            }
        };
        desktopFullscreenDelegate.requestFullscreen = function(el) {
            var method;
            if (typeof el.requestFullscreen === "function") {
                method = "requestFullscreen"
            } else if (typeof el.webkitRequestFullscreen === "function") {
                method = "webkitRequestFullscreen"
            } else if (typeof el.webkitRequestFullScreen === "function") {
                method = "webkitRequestFullScreen"
            } else if (typeof el.mozRequestFullScreen === "function") {
                method = "mozRequestFullScreen"
            } else if (typeof el.msRequestFullscreen === "function") {
                method = "msRequestFullscreen"
            }
            if (typeof el[method] === "function") {
                el[method].call(el)
            }
        };
        desktopFullscreenDelegate.mode = modes.STANDARD;
        module.exports = desktopFullscreenDelegate
    }, {
        "./../consts/modes": 433,
        "./../events/types": 437,
        "@marcom/ac-dom-events/addEventListener": 424,
        "@marcom/ac-event-emitter-micro": 422
    }],
    435: [function(require, module, exports) {
        "use strict";
        var iosFullscreenDelegate = require("./ios");
        var desktopFullscreenDelegate = require("./desktop");
        module.exports = {
            create: function() {
                var delegate = desktopFullscreenDelegate;
                if ("webkitEnterFullscreen" in document.createElement("video") && !("webkitRequestFullScreen" in document.createElement("div"))) {
                    delegate = iosFullscreenDelegate
                }
                return delegate
            }
        }
    }, {
        "./desktop": 434,
        "./ios": 436
    }],
    436: [function(require, module, exports) {
        "use strict";
        var addEventListener = require("@marcom/ac-dom-events/addEventListener");
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var eventTypes = require("./../events/types");
        var modes = require("./../consts/modes");
        var fullscreenElement;
        bindIOSFullscreenEvents();

        function bindIOSFullscreenEvents() {
            addEventListener(document, "webkitbeginfullscreen", onIOSEnterFullscreen, true);
            addEventListener(document, "webkitendfullscreen", onIOSExitFullscreen, true)
        }

        function onIOSEnterFullscreen(e) {
            iosFullscreenDelegate.trigger(eventTypes.ENTERFULLSCREEN, e)
        }

        function onIOSExitFullscreen(e) {
            fullscreenElement = undefined;
            iosFullscreenDelegate.trigger(eventTypes.EXITFULLSCREEN, e)
        }
        var iosFullscreenDelegate = new EventEmitterMicro;
        iosFullscreenDelegate.fullscreenEnabled = function(el) {
            return !!el.webkitSupportsFullscreen
        };
        iosFullscreenDelegate.fullscreenElement = function() {
            return fullscreenElement
        };
        iosFullscreenDelegate.exitFullscreen = function(el) {
            if (el && typeof el.webkitExitFullscreen === "function") {
                el.webkitExitFullscreen()
            }
        };
        iosFullscreenDelegate.requestFullscreen = function(el) {
            if (typeof el.webkitEnterFullscreen === "function") {
                el.webkitEnterFullscreen()
            }
        };
        iosFullscreenDelegate.mode = modes.IOS;
        module.exports = iosFullscreenDelegate
    }, {
        "./../consts/modes": 433,
        "./../events/types": 437,
        "@marcom/ac-dom-events/addEventListener": 424,
        "@marcom/ac-event-emitter-micro": 422
    }],
    437: [function(require, module, exports) {
        module.exports = {
            ENTERFULLSCREEN: "enterfullscreen",
            EXITFULLSCREEN: "exitfullscreen"
        }
    }, {}],
    438: [function(require, module, exports) {
        "use strict";
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var delegateFactory = require("./delegate/factory");
        var MISSING_ELEMENT_ERR = "Error: Element missing. ac-fullscreen requires an element to be specified";
        var delegate = delegateFactory.create();

        function throwMissingElementErr() {
            throw new Error(MISSING_ELEMENT_ERR)
        }
        var fullscreen = {};
        fullscreen.requestFullscreen = function(el) {
            if (!el) {
                throwMissingElementErr()
            }
            return delegate.requestFullscreen(el)
        };
        fullscreen.fullscreenEnabled = function(el) {
            if (!el) {
                throwMissingElementErr()
            }
            return delegate.fullscreenEnabled(el)
        };
        fullscreen.fullscreenElement = function() {
            return delegate.fullscreenElement()
        };
        fullscreen.exitFullscreen = function(el) {
            if (!el) {
                throwMissingElementErr()
            }
            return delegate.exitFullscreen(el)
        };
        fullscreen.getMode = function() {
            return delegate.mode
        };
        fullscreen.on = function() {
            return delegate.on.apply(delegate, arguments)
        };
        fullscreen.off = function() {
            return delegate.off.apply(delegate, arguments)
        };
        fullscreen.once = function() {
            return delegate.once.apply(delegate, arguments)
        };
        module.exports = fullscreen
    }, {
        "./delegate/factory": 435,
        "@marcom/ac-event-emitter-micro": 422
    }],
    439: [function(require, module, exports) {
        "use strict";
        module.exports = function throttle(func, wait) {
            var timeout = null;
            return function() {
                if (timeout === null) {
                    func.apply(this, arguments);
                    timeout = setTimeout(function() {
                        timeout = null
                    }, wait)
                }
            }
        }
    }, {}],
    440: [function(require, module, exports) {
        arguments[4][11][0].apply(exports, arguments)
    }, {
        dup: 11
    }],
    441: [function(require, module, exports) {
        arguments[4][12][0].apply(exports, arguments)
    }, {
        dup: 12
    }],
    442: [function(require, module, exports) {
        arguments[4][188][0].apply(exports, arguments)
    }, {
        "./internal/KeyEvent": 443,
        "@marcom/ac-dom-events/utils/addEventListener": 440,
        "@marcom/ac-dom-events/utils/removeEventListener": 441,
        "@marcom/ac-event-emitter-micro": 422,
        "@marcom/ac-object/create": 446,
        dup: 188
    }],
    443: [function(require, module, exports) {
        arguments[4][190][0].apply(exports, arguments)
    }, {
        dup: 190
    }],
    444: [function(require, module, exports) {
        arguments[4][250][0].apply(exports, arguments)
    }, {
        dup: 250
    }],
    445: [function(require, module, exports) {
        arguments[4][94][0].apply(exports, arguments)
    }, {
        "./extend": 447,
        "@marcom/ac-polyfills/Array/isArray": 384,
        dup: 94
    }],
    446: [function(require, module, exports) {
        arguments[4][15][0].apply(exports, arguments)
    }, {
        dup: 15
    }],
    447: [function(require, module, exports) {
        arguments[4][16][0].apply(exports, arguments)
    }, {
        "@marcom/ac-polyfills/Array/prototype.forEach": 387,
        dup: 16
    }],
    448: [function(require, module, exports) {
        arguments[4][260][0].apply(exports, arguments)
    }, {
        "@marcom/ac-url/joinSearchParams": 444,
        dup: 260
    }],
    449: [function(require, module, exports) {
        "use strict";
        module.exports = {
            SharedInstance: require("./ac-shared-instance/SharedInstance")
        }
    }, {
        "./ac-shared-instance/SharedInstance": 450
    }],
    450: [function(require, module, exports) {
        "use strict";
        var instanceScope = window,
            instanceSharedInstanceNamespace = "AC",
            instanceExportKey = "SharedInstance",
            instanceTarget = instanceScope[instanceSharedInstanceNamespace];
        var SharedInstance = function() {
            var registry = {};
            return {
                get: function(name, version) {
                    var module = null;
                    if (registry[name] && registry[name][version]) {
                        module = registry[name][version]
                    }
                    return module
                },
                set: function(name, version, Module) {
                    if (!registry[name]) {
                        registry[name] = {}
                    }
                    if (typeof Module === "function") {
                        registry[name][version] = new Module
                    } else {
                        registry[name][version] = Module
                    }
                    return registry[name][version]
                },
                share: function(name, version, Module) {
                    var module = this.get(name, version);
                    if (!module) {
                        module = this.set(name, version, Module)
                    }
                    return module
                },
                remove: function(name, version) {
                    var versionType = typeof version;
                    if (versionType === "string" || versionType === "number") {
                        if (!registry[name] || !registry[name][version]) {
                            return
                        }
                        registry[name][version] = null;
                        return
                    }
                    if (registry[name]) {
                        registry[name] = null
                    }
                }
            }
        }();
        if (!instanceTarget) {
            instanceTarget = instanceScope[instanceSharedInstanceNamespace] = {}
        }
        if (!instanceTarget[instanceExportKey]) {
            instanceTarget[instanceExportKey] = SharedInstance
        }
        module.exports = instanceTarget[instanceExportKey]
    }, {}],
    451: [function(require, module, exports) {
        "use strict";
        var SharedInstance = require("@marcom/ac-shared-instance").SharedInstance;
        var sharedInstanceName = "ac-raf-emitter-id-generator:sharedRAFEmitterIDGeneratorInstance",
            sharedInstanceVersion = "1.0.3";
        var RAFEmitterIDGenerator = function() {
            this._currentID = 0
        };
        RAFEmitterIDGenerator.prototype.getNewID = function() {
            this._currentID++;
            return "raf:" + this._currentID
        };
        module.exports = SharedInstance.share(sharedInstanceName, sharedInstanceVersion, RAFEmitterIDGenerator)
    }, {
        "@marcom/ac-shared-instance": 449
    }],
    452: [function(require, module, exports) {
        arguments[4][449][0].apply(exports, arguments)
    }, {
        "./ac-shared-instance/SharedInstance": 453,
        dup: 449
    }],
    453: [function(require, module, exports) {
        arguments[4][450][0].apply(exports, arguments)
    }, {
        dup: 450
    }],
    454: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/performance/now");
        var proto;

        function RAFExecutor(options) {
            options = options || {};
            this._reset();
            this._willRun = false;
            this._totalSubscribeCount = -1;
            this._requestAnimationFrame = window.requestAnimationFrame;
            this._cancelAnimationFrame = window.cancelAnimationFrame;
            this._boundOnAnimationFrame = this._onAnimationFrame.bind(this);
            this._boundOnExternalAnimationFrame = this._onExternalAnimationFrame.bind(this)
        }
        proto = RAFExecutor.prototype;
        proto.subscribe = function(rafEmitter, shouldPrepend) {
            this._totalSubscribeCount++;
            if (!this._nextFrameSubscribers[rafEmitter.id]) {
                if (shouldPrepend) {
                    this._nextFrameSubscribersOrder.unshift(rafEmitter.id)
                } else {
                    this._nextFrameSubscribersOrder.push(rafEmitter.id)
                }
                this._nextFrameSubscribers[rafEmitter.id] = rafEmitter;
                this._nextFrameSubscriberArrayLength++;
                this._nextFrameSubscriberCount++;
                this._run()
            }
            return this._totalSubscribeCount
        };
        proto.unsubscribe = function(rafEmitter) {
            if (!this._nextFrameSubscribers[rafEmitter.id]) {
                return false
            }
            this._nextFrameSubscribers[rafEmitter.id] = null;
            this._nextFrameSubscriberCount--;
            if (this._nextFrameSubscriberCount === 0) {
                this._cancel()
            }
            return true
        };
        proto.trigger = function(evtName, data) {
            var i;
            for (i = 0; i < this._subscriberArrayLength; i++) {
                if (this._subscribers[this._subscribersOrder[i]] !== null && this._subscribers[this._subscribersOrder[i]]._didDestroy === false) {
                    this._subscribers[this._subscribersOrder[i]].trigger(evtName, data)
                }
            }
        };
        proto.destroy = function() {
            var didCancel = this._cancel();
            this._subscribers = null;
            this._subscribersOrder = null;
            this._nextFrameSubscribers = null;
            this._nextFrameSubscribersOrder = null;
            this._rafData = null;
            this._boundOnAnimationFrame = null;
            this._onExternalAnimationFrame = null;
            return didCancel
        };
        proto.useExternalAnimationFrame = function(shouldUseExternalAnimationFrame) {
            if (typeof shouldUseExternalAnimationFrame !== "boolean") {
                return
            }
            var wasUsingExternalAnimationFrame = this._isUsingExternalAnimationFrame;
            if (shouldUseExternalAnimationFrame && this._animationFrame) {
                this._cancelAnimationFrame.call(window, this._animationFrame);
                this._animationFrame = null
            }
            if (this._willRun && !shouldUseExternalAnimationFrame && !this._animationFrame) {
                this._animationFrame = this._requestAnimationFrame.call(window, this._boundOnAnimationFrame)
            }
            this._isUsingExternalAnimationFrame = shouldUseExternalAnimationFrame;
            if (shouldUseExternalAnimationFrame) {
                return this._boundOnExternalAnimationFrame
            }
            return wasUsingExternalAnimationFrame || false
        };
        proto._run = function() {
            if (!this._willRun) {
                this._willRun = true;
                if (this.lastFrameTime === 0) {
                    this.lastFrameTime = performance.now()
                }
                this._animationFrameActive = true;
                if (!this._isUsingExternalAnimationFrame) {
                    this._animationFrame = this._requestAnimationFrame.call(window, this._boundOnAnimationFrame)
                }
                return true
            }
        };
        proto._cancel = function() {
            var result = false;
            if (this._animationFrameActive) {
                if (this._animationFrame) {
                    this._cancelAnimationFrame.call(window, this._animationFrame);
                    this._animationFrame = null
                }
                this._animationFrameActive = false;
                this._willRun = false;
                result = true
            }
            if (!this._isRunning) {
                this._reset()
            }
            return result
        };
        proto._onSubscribersAnimationFrameStart = function(data) {
            var i;
            for (i = 0; i < this._subscriberArrayLength; i++) {
                if (this._subscribers[this._subscribersOrder[i]] !== null && this._subscribers[this._subscribersOrder[i]]._didDestroy === false) {
                    this._subscribers[this._subscribersOrder[i]]._onAnimationFrameStart(data)
                }
            }
        };
        proto._onSubscribersAnimationFrameEnd = function(data) {
            var i;
            for (i = 0; i < this._subscriberArrayLength; i++) {
                if (this._subscribers[this._subscribersOrder[i]] !== null && this._subscribers[this._subscribersOrder[i]]._didDestroy === false) {
                    this._subscribers[this._subscribersOrder[i]]._onAnimationFrameEnd(data)
                }
            }
        };
        proto._onAnimationFrame = function(time) {
            this._subscribers = this._nextFrameSubscribers;
            this._subscribersOrder = this._nextFrameSubscribersOrder;
            this._subscriberArrayLength = this._nextFrameSubscriberArrayLength;
            this._subscriberCount = this._nextFrameSubscriberCount;
            this._nextFrameSubscribers = {};
            this._nextFrameSubscribersOrder = [];
            this._nextFrameSubscriberArrayLength = 0;
            this._nextFrameSubscriberCount = 0;
            this._isRunning = true;
            this._willRun = false;
            this._didRequestNextRAF = false;
            this._rafData.delta = time - this.lastFrameTime;
            this.lastFrameTime = time;
            this._rafData.fps = 0;
            if (this._rafData.delta >= 1e3) {
                this._rafData.delta = 0
            }
            if (this._rafData.delta !== 0) {
                this._rafData.fps = 1e3 / this._rafData.delta
            }
            this._rafData.time = time;
            this._rafData.naturalFps = this._rafData.fps;
            this._rafData.timeNow = Date.now();
            this._onSubscribersAnimationFrameStart(this._rafData);
            this.trigger("update", this._rafData);
            this.trigger("external", this._rafData);
            this.trigger("draw", this._rafData);
            this._onSubscribersAnimationFrameEnd(this._rafData);
            if (!this._willRun) {
                this._reset()
            }
        };
        proto._onExternalAnimationFrame = function(time) {
            if (!this._isUsingExternalAnimationFrame) {
                return
            }
            this._onAnimationFrame(time)
        };
        proto._reset = function() {
            this._rafData = {
                time: 0,
                delta: 0,
                fps: 0,
                naturalFps: 0,
                timeNow: 0
            };
            this._subscribers = {};
            this._subscribersOrder = [];
            this._subscriberArrayLength = 0;
            this._subscriberCount = 0;
            this._nextFrameSubscribers = {};
            this._nextFrameSubscribersOrder = [];
            this._nextFrameSubscriberArrayLength = 0;
            this._nextFrameSubscriberCount = 0;
            this._didEmitFrameData = false;
            this._animationFrame = null;
            this._animationFrameActive = false;
            this._isRunning = false;
            this._shouldReset = false;
            this.lastFrameTime = 0
        };
        module.exports = RAFExecutor
    }, {
        "@marcom/ac-polyfills/performance/now": 400
    }],
    455: [function(require, module, exports) {
        "use strict";
        var SharedInstance = require("@marcom/ac-shared-instance").SharedInstance;
        var sharedInstanceName = "ac-raf-executor:sharedRAFExecutorInstance",
            sharedInstanceVersion = "2.0.1";
        var RAFExecutor = require("./RAFExecutor");
        module.exports = SharedInstance.share(sharedInstanceName, sharedInstanceVersion, RAFExecutor)
    }, {
        "./RAFExecutor": 454,
        "@marcom/ac-shared-instance": 452
    }],
    456: [function(require, module, exports) {
        "use strict";
        var proto;
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var sharedRAFExecutorInstance = require("@marcom/ac-raf-executor/sharedRAFExecutorInstance");
        var sharedRAFEmitterIDGeneratorInstance = require("@marcom/ac-raf-emitter-id-generator/sharedRAFEmitterIDGeneratorInstance");

        function RAFEmitter(options) {
            options = options || {};
            EventEmitterMicro.call(this);
            this.id = sharedRAFEmitterIDGeneratorInstance.getNewID();
            this.executor = options.executor || sharedRAFExecutorInstance;
            this._reset();
            this._willRun = false;
            this._didDestroy = false
        }
        proto = RAFEmitter.prototype = Object.create(EventEmitterMicro.prototype);
        proto.run = function() {
            if (!this._willRun) {
                this._willRun = true
            }
            return this._subscribe()
        };
        proto.cancel = function() {
            this._unsubscribe();
            if (this._willRun) {
                this._willRun = false
            }
            this._reset()
        };
        proto.destroy = function() {
            var didCancel = this.willRun();
            this.cancel();
            this.executor = null;
            EventEmitterMicro.prototype.destroy.call(this);
            this._didDestroy = true;
            return didCancel
        };
        proto.willRun = function() {
            return this._willRun
        };
        proto.isRunning = function() {
            return this._isRunning
        };
        proto._subscribe = function() {
            return this.executor.subscribe(this)
        };
        proto._unsubscribe = function() {
            return this.executor.unsubscribe(this)
        };
        proto._onAnimationFrameStart = function(data) {
            this._isRunning = true;
            this._willRun = false;
            if (!this._didEmitFrameData) {
                this._didEmitFrameData = true;
                this.trigger("start", data)
            }
        };
        proto._onAnimationFrameEnd = function(data) {
            if (!this._willRun) {
                this.trigger("stop", data);
                this._reset()
            }
        };
        proto._reset = function() {
            this._didEmitFrameData = false;
            this._isRunning = false
        };
        module.exports = RAFEmitter
    }, {
        "@marcom/ac-event-emitter-micro": 422,
        "@marcom/ac-raf-emitter-id-generator/sharedRAFEmitterIDGeneratorInstance": 451,
        "@marcom/ac-raf-executor/sharedRAFExecutorInstance": 455
    }],
    457: [function(require, module, exports) {
        "use strict";
        var SingleCallRAFEmitter = require("./SingleCallRAFEmitter");
        var RAFInterface = function(evt) {
            this.rafEmitter = new SingleCallRAFEmitter;
            this.rafEmitter.on(evt, this._onRAFExecuted.bind(this));
            this.requestAnimationFrame = this.requestAnimationFrame.bind(this);
            this.cancelAnimationFrame = this.cancelAnimationFrame.bind(this);
            this._frameCallbacks = [];
            this._nextFrameCallbacks = [];
            this._currentFrameID = -1;
            this._cancelFrameIdx = -1;
            this._frameCallbackLength = 0;
            this._nextFrameCallbacksLength = 0;
            this._frameCallbackIteration = 0
        };
        var proto = RAFInterface.prototype;
        proto.requestAnimationFrame = function(rafCallback) {
            this._currentFrameID = this.rafEmitter.run();
            this._nextFrameCallbacks.push(this._currentFrameID, rafCallback);
            this._nextFrameCallbacksLength += 2;
            return this._currentFrameID
        };
        proto.cancelAnimationFrame = function(id) {
            this._cancelFrameIdx = this._nextFrameCallbacks.indexOf(id);
            if (this._cancelFrameIdx === -1) {
                return
            }
            this._nextFrameCallbacks.splice(this._cancelFrameIdx, 2);
            this._nextFrameCallbacksLength -= 2;
            if (this._nextFrameCallbacksLength === 0) {
                this.rafEmitter.cancel()
            }
        };
        proto._onRAFExecuted = function(e) {
            this._frameCallbacks = this._nextFrameCallbacks;
            this._frameCallbackLength = this._nextFrameCallbacksLength;
            this._nextFrameCallbacks = [];
            this._nextFrameCallbacksLength = 0;
            for (this._frameCallbackIteration = 0; this._frameCallbackIteration < this._frameCallbackLength; this._frameCallbackIteration += 2) {
                this._frameCallbacks[this._frameCallbackIteration + 1](e.time, e)
            }
        };
        module.exports = RAFInterface
    }, {
        "./SingleCallRAFEmitter": 459
    }],
    458: [function(require, module, exports) {
        "use strict";
        var RAFInterface = require("./RAFInterface");
        var RAFInterfaceController = function() {
            this.events = {}
        };
        var proto = RAFInterfaceController.prototype;
        proto.requestAnimationFrame = function(evt) {
            if (!this.events[evt]) {
                this.events[evt] = new RAFInterface(evt)
            }
            return this.events[evt].requestAnimationFrame
        };
        proto.cancelAnimationFrame = function(evt) {
            if (!this.events[evt]) {
                this.events[evt] = new RAFInterface(evt)
            }
            return this.events[evt].cancelAnimationFrame
        };
        module.exports = new RAFInterfaceController
    }, {
        "./RAFInterface": 457
    }],
    459: [function(require, module, exports) {
        "use strict";
        var RAFEmitter = require("./RAFEmitter");
        var SingleCallRAFEmitter = function(options) {
            RAFEmitter.call(this, options)
        };
        var proto = SingleCallRAFEmitter.prototype = Object.create(RAFEmitter.prototype);
        proto._subscribe = function() {
            return this.executor.subscribe(this, true)
        };
        module.exports = SingleCallRAFEmitter
    }, {
        "./RAFEmitter": 456
    }],
    460: [function(require, module, exports) {
        "use strict";
        var RAFInterfaceController = require("./RAFInterfaceController");
        module.exports = RAFInterfaceController.cancelAnimationFrame("draw")
    }, {
        "./RAFInterfaceController": 458
    }],
    461: [function(require, module, exports) {
        "use strict";
        var RAFInterfaceController = require("./RAFInterfaceController");
        module.exports = RAFInterfaceController.requestAnimationFrame("draw")
    }, {
        "./RAFInterfaceController": 458
    }],
    462: [function(require, module, exports) {
        arguments[4][303][0].apply(exports, arguments)
    }, {
        "./getContentDimensions": 463,
        "./getDimensions": 464,
        "./getPagePosition": 465,
        "./getPercentInViewport": 466,
        "./getPixelsInViewport": 467,
        "./getPosition": 468,
        "./getScrollX": 469,
        "./getScrollY": 470,
        "./getViewportPosition": 471,
        "./isInViewport": 472,
        dup: 303
    }],
    463: [function(require, module, exports) {
        arguments[4][304][0].apply(exports, arguments)
    }, {
        "./utils/getBoundingClientRect": 473,
        dup: 304
    }],
    464: [function(require, module, exports) {
        arguments[4][69][0].apply(exports, arguments)
    }, {
        "./utils/getBoundingClientRect": 473,
        dup: 69
    }],
    465: [function(require, module, exports) {
        arguments[4][306][0].apply(exports, arguments)
    }, {
        "./getDimensions": 464,
        "./getScrollX": 469,
        "./getScrollY": 470,
        "./utils/getBoundingClientRect": 473,
        dup: 306
    }],
    466: [function(require, module, exports) {
        arguments[4][307][0].apply(exports, arguments)
    }, {
        "./getDimensions": 464,
        "./getPixelsInViewport": 467,
        dup: 307
    }],
    467: [function(require, module, exports) {
        arguments[4][308][0].apply(exports, arguments)
    }, {
        "./getViewportPosition": 471,
        dup: 308
    }],
    468: [function(require, module, exports) {
        arguments[4][309][0].apply(exports, arguments)
    }, {
        "./getDimensions": 464,
        "./utils/getBoundingClientRect": 473,
        dup: 309
    }],
    469: [function(require, module, exports) {
        arguments[4][203][0].apply(exports, arguments)
    }, {
        dup: 203
    }],
    470: [function(require, module, exports) {
        arguments[4][204][0].apply(exports, arguments)
    }, {
        dup: 204
    }],
    471: [function(require, module, exports) {
        arguments[4][312][0].apply(exports, arguments)
    }, {
        "./getPagePosition": 465,
        "./getScrollX": 469,
        "./getScrollY": 470,
        "./utils/getBoundingClientRect": 473,
        dup: 312
    }],
    472: [function(require, module, exports) {
        arguments[4][313][0].apply(exports, arguments)
    }, {
        "./getPercentInViewport": 466,
        "./getPixelsInViewport": 467,
        dup: 313
    }],
    473: [function(require, module, exports) {
        arguments[4][70][0].apply(exports, arguments)
    }, {
        dup: 70
    }],
    474: [function(require, module, exports) {
        "use strict";
        var ac_event_emitter_micro = require("@marcom/ac-event-emitter-micro");
        var ac_dom_metrics = require("@marcom/ac-dom-metrics");
        var Keyboard = require("@marcom/ac-keyboard/Keyboard");
        var ARROW_LEFT = {
            num: 37,
            string: "ArrowLeft"
        };
        var ARROW_UP = {
            num: 38,
            string: "ArrowUp"
        };
        var ARROW_RIGHT = {
            num: 39,
            string: "ArrowRight"
        };
        var ARROW_DOWN = {
            num: 40,
            string: "ArrowDown"
        };
        var ARROW_KEYS = [ARROW_LEFT, ARROW_RIGHT, ARROW_DOWN, ARROW_RIGHT];
        var keyCodeFromEvent = function(evt) {
            if (evt.which) {
                return evt.which
            }
            var string = evt.key ? evt.key : evt.code;
            var i = 0;
            var len = ARROW_KEYS.length;
            for (; i < len; i++) {
                if (ARROW_KEYS[i].string === string) {
                    return ARROW_KEYS[i].num
                }
            }
            return -1
        };
        var DEFAULT_OPTIONS = {
            min: 0,
            max: 1,
            step: 1,
            value: 0,
            orientation: "horizontal",
            renderedPosition: false,
            template: '<div class="ac-slider-runnable-track">\n\t<div class="ac-slider-thumb"></div>\n</div>',
            keyboardMaxStepPercentage: .05,
            keyboardStepMultiplier: 1.25
        };
        var VALID_KEYS = Object.keys(DEFAULT_OPTIONS);
        var SliderView = function(el, options) {
            this.options = Object.assign({}, DEFAULT_OPTIONS, options);
            this.model = Object.create(this.options);
            this.el = el;
            var keyboardContext = this.options.keyboardContext !== undefined ? this.options.keyboardContext : this.el;
            if (keyboardContext !== null) {
                this._keyboard = new Keyboard(keyboardContext);
                this._keyDown = {}
            }
            el.className += " ac-slider-container";
            el.innerHTML = this.model.template;
            ac_event_emitter_micro.EventEmitterMicro.call(this);
            this.initialize()
        };
        SliderView.prototype = Object.create(ac_event_emitter_micro.EventEmitterMicro.prototype);
        var proto = SliderView.prototype;
        proto.addEventListeners = function() {
            this.addEventListener(this.el, "mousedown", this.onMouseDown);
            this.addEventListener(this.el, "touchstart", this.onTouchStart);
            this.addEventListener(this.el, "mouseover", this.onMouseOver);
            this.addEventListener(this.el, "mouseleave", this.onMouseLeave);
            this.addEventListener(this.el, "touchend", this.onTouchEnd);
            this.addEventListener(document, "touchend", this.onMouseUp);
            if (this._keyboard) {
                if (this.model.orientation === "horizontal") {
                    this._keyboard.onDown(ARROW_RIGHT.num, this.stepUp);
                    this._keyboard.onDown(ARROW_LEFT.num, this.stepDown)
                } else {
                    this._keyboard.onDown(ARROW_DOWN.num, this.stepDown);
                    this._keyboard.onDown(ARROW_UP.num, this.stepUp)
                }
            }
        };
        proto.addEventListener = function(el, evtName, callback) {
            el.addEventListener(evtName, callback)
        };
        proto.bindMethods = function() {
            this.stepDown = this.stepDown.bind(this);
            this.stepUp = this.stepUp.bind(this);
            this._triggerRelease = this._triggerRelease.bind(this);
            this._preventDefault = this._preventDefault.bind(this);
            this.onMouseDown = this.bindMethod(this.onMouseDown, this);
            this.onTouchStart = this.bindMethod(this.onTouchStart, this);
            this.onMouseOver = this.bindMethod(this.onMouseOver, this);
            this.onMouseLeave = this.bindMethod(this.onMouseLeave, this);
            this.onTouchEnd = this.bindMethod(this.onTouchEnd, this);
            this.onMouseUp = this.bindMethod(this.onMouseUp, this);
            this.onMouseMove = this.bindMethod(this.onMouseMove, this);
            this.onTouchMove = this.bindMethod(this.onTouchMove, this)
        };
        proto.bindMethod = function(method, context) {
            return method.bind(context)
        };
        proto.correctValueMinMax = function(value, min, max) {
            if (value > max) {
                value = max
            }
            if (value < min) {
                value = min
            }
            return value
        };
        proto.calculateStepsToValue = function(value, min) {
            return Math.abs(value - min)
        };
        proto.calculateMaxSteps = function(min, max) {
            return Math.abs(max - min)
        };
        proto.calculateStepsEqualToPercentage = function(percentage, numberOfSteps) {
            return percentage / 100 * numberOfSteps
        };
        proto.calculateNextStepInRange = function(value, min, max, step) {
            var stepsInRange = this.calculateMaxSteps(min, max);
            var stepsToValue = this.calculateStepsToValue(value, min);
            var stepToGreaterValue = min + Math.floor(stepsInRange / step) * step;
            value = Math.min(stepToGreaterValue, min + Math.round(stepsToValue / step) * step);
            return value
        };
        proto.dispatchEvent = function(el, evtName) {
            el.dispatchEvent(new CustomEvent(evtName))
        };
        proto.disableUserControls = function() {
            this.removeEventListeners()
        };
        proto.enableUserControls = function() {
            this.addEventListeners()
        };
        proto.getNextValue = function(value, min, max, step) {
            value = this.correctValueMinMax(value, min, max);
            if (step !== "auto") {
                value = this.calculateNextStepInRange(value, min, max, step)
            }
            return value
        };
        proto.getOrientation = function() {
            return this.model.orientation
        };
        proto.getValue = function() {
            return this.model.value
        };
        proto.getMin = function() {
            return this.model.min
        };
        proto.getMax = function() {
            return this.model.max
        };
        proto.getStep = function() {
            return this.model.step
        };
        proto.getClientXValue = function(e, offsetEl) {
            var clientX = this.getClientXFromEvent(e);
            var thumbDimensions = offsetEl !== null ? ac_dom_metrics.getDimensions(offsetEl || this.thumbElement) : {
                width: 0,
                height: 0
            };
            var trackDimensions = ac_dom_metrics.getDimensions(this.runnableTrackElement);
            var left = clientX - this.runnableTrackElement.getBoundingClientRect().left - Math.round(thumbDimensions.width / 2);
            var usableTrack = trackDimensions.width - thumbDimensions.width;
            var offsetPercentage = left / usableTrack * 100;
            var maxSteps = this.calculateMaxSteps(this.getMin(), this.getMax());
            var stepsEqualToPercentage = this.calculateStepsEqualToPercentage(offsetPercentage, maxSteps);
            return this.getMin() + stepsEqualToPercentage
        };
        proto.getClientYValue = function(e) {
            var clientY = this.getClientYFromEvent(e);
            var thumbDimensions = ac_dom_metrics.getDimensions(this.thumbElement);
            var trackDimensions = ac_dom_metrics.getDimensions(this.runnableTrackElement);
            var trackPosition = ac_dom_metrics.getViewportPosition(this.runnableTrackElement, this.model.renderedPosition);
            var usableTrack = trackDimensions.height - thumbDimensions.height;
            var top = usableTrack - (clientY - trackPosition.top - thumbDimensions.height / 2);
            var offsetPercentage = top / (trackDimensions.height - thumbDimensions.height) * 100;
            var maxSteps = this.calculateMaxSteps(this.model.min, this.model.max);
            var stepsEqualToPercentage = this.calculateStepsEqualToPercentage(offsetPercentage, maxSteps);
            return this.model.min + stepsEqualToPercentage
        };
        proto.getClientValue = function(e) {
            e = e.originalEvent || e;
            var offsetValue;
            if (this.model.orientation === "horizontal") {
                offsetValue = this.getClientXValue(e)
            } else {
                offsetValue = this.getClientYValue(e)
            }
            return offsetValue
        };
        proto.getClientXFromEvent = function(e) {
            return e.touches ? e.touches[0].clientX : e.clientX
        };
        proto.getClientYFromEvent = function(e) {
            return e.touches ? e.touches[0].clientY : e.clientY
        };
        proto.initialize = function() {
            this.setNodeReferences();
            this.setValue(this.model.value);
            this.bindMethods();
            this.addEventListeners()
        };
        proto.onMouseLeave = function() {
            this.preventDocumentMouseUpDispatch = false
        };
        proto.onMouseDown = function(e) {
            var clientValue = this.getClientValue(e);
            this.addEventListener(document, "mouseup", this.onMouseUp);
            this.addEventListener(document, "mousemove", this.onMouseMove);
            this.trigger("grab", this.getValue());
            this.setValue(clientValue)
        };
        proto.onMouseUp = function() {
            this.removeEventListener(document, "mouseup", this.onMouseUp);
            this.removeEventListener(document, "mousemove", this.onMouseMove);
            this.trigger("release", this.getValue());
            if (!this.preventDocumentMouseUpDispatch) {
                this.dispatchEvent(this.el, "mouseup")
            }
        };
        proto.onMouseOver = function() {
            this.preventDocumentMouseUpDispatch = true
        };
        proto.onTouchEnd = function() {
            this.removeEventListener(document, "touchend", this.onTouchEnd);
            this.removeEventListener(document, "touchmove", this.onTouchMove);
            this.trigger("release", this.getValue());
            if (!this.preventDocumentMouseUpDispatch) {
                this.dispatchEvent(this.el, "touchend")
            }
        };
        proto.onTouchStart = function(e) {
            var clientValue = this.getClientValue(e);
            this.addEventListener(document, "touchend", this.onMouseUp);
            this.addEventListener(document, "touchmove", this.onTouchMove);
            this.trigger("grab", this.getValue());
            this.setValue(clientValue)
        };
        proto.onMouseMove = function(e) {
            var clientValue = this.getClientValue(e);
            this.setValue(clientValue)
        };
        proto.onTouchMove = function(e) {
            if (e.preventDefault) {
                e.preventDefault()
            }
            var clientValue = this.getClientValue(e);
            this.setValue(clientValue)
        };
        proto.getElementOrientationOffsetValue = function(el, orientation) {
            if (orientation === "horizontal") {
                return ac_dom_metrics.getDimensions(el).width
            }
            return ac_dom_metrics.getDimensions(el).height
        };
        proto.getAvailableRunnableTrack = function(runnableTrackOffsetValue, orientation) {
            var thumbOffsetValue = this.getElementOrientationOffsetValue(this.thumbElement, orientation);
            return runnableTrackOffsetValue - thumbOffsetValue
        };
        proto.getPercentageByValue = function(value, valueToFindPercentageOf) {
            value = this.calculateStepsToValue(value, this.getMin());
            valueToFindPercentageOf = this.calculateMaxSteps(this.getMin(), this.getMax());
            return value / valueToFindPercentageOf * 100
        };
        proto.getPercentageOfRunnableTrack = function(value) {
            var orientation = this.getOrientation();
            var runnableTrackOffsetValue = this.getElementOrientationOffsetValue(this.runnableTrackElement, orientation);
            var usableTrackOffsetValue = this.getAvailableRunnableTrack(runnableTrackOffsetValue, orientation);
            var percentageOfMax = this.getPercentageByValue(value, this.getMax());
            var valueInPx = percentageOfMax / 100 * usableTrackOffsetValue;
            return valueInPx / runnableTrackOffsetValue * 100
        };
        proto.onChange = function(value) {
            var valueInPercent = this.getPercentageOfRunnableTrack(value);
            if (isNaN(valueInPercent)) {
                return
            }
            if (this.getOrientation() === "horizontal") {
                this.thumbElement.style.left = valueInPercent + "%"
            } else {
                this.thumbElement.style.bottom = valueInPercent + "%"
            }
            this.trigger("change", this.getValue())
        };
        proto.removeEventListeners = function() {
            this.removeEventListener(this.el, "mousedown", this.onMouseDown);
            this.removeEventListener(this.el, "touchstart", this.onTouchStart);
            this.removeEventListener(this.el, "mouseover", this.onMouseOver);
            this.removeEventListener(this.el, "mouseleave", this.onMouseLeave);
            this.removeEventListener(this.el, "touchend", this.onTouchEnd);
            this.removeEventListener(document, "touchend", this.onMouseUp)
        };
        proto.removeEventListener = function(el, evtName, callback) {
            el.removeEventListener(evtName, callback)
        };
        proto.setNodeReferences = function() {
            this.runnableTrackElement = this.el.querySelector(".ac-slider-runnable-track");
            this.thumbElement = this.el.querySelector(".ac-slider-thumb")
        };
        proto.setOrientation = function(orientation) {
            this.set("orientation", orientation)
        };
        proto._triggerRelease = function(evt) {
            this._preventDefault(evt);
            this.trigger("release", this.getValue());
            this._keyDown[keyCodeFromEvent(evt)] = 0
        };
        proto._preventDefault = function(evt) {
            evt.preventDefault();
            evt.stopPropagation()
        };
        proto._step = function(evt, up) {
            this._preventDefault(evt);
            this.el.focus();
            var currentStep = this._keyDown[keyCodeFromEvent(evt)] || 0;
            if (!currentStep) {
                this.trigger("grab", this.getValue());
                currentStep = this.getStep();
                currentStep = currentStep !== "auto" ? currentStep : this._cachedMaxStep;
                if (!up) {
                    currentStep *= -1
                }
                this._keyboard.onceUp(keyCodeFromEvent(evt), this._triggerRelease)
            } else if (Math.abs(this._keyDown[keyCodeFromEvent(evt)]) < Math.abs(this.model.max * this.model.keyboardMaxStepPercentage)) {
                currentStep *= this.model.keyboardStepMultiplier
            }
            this._keyDown[keyCodeFromEvent(evt)] = currentStep;
            this.setValue(this.getValue() + currentStep)
        };
        proto.stepUp = function(evt) {
            this._step(evt, true)
        };
        proto.stepDown = function(evt) {
            this._step(evt, false)
        };
        proto.setValue = function(value) {
            value = this.getNextValue(value, this.getMin(), this.getMax(), this.getStep());
            this.set("value", value);
            this.el.setAttribute("aria-valuenow", value);
            this.onChange(value)
        };
        proto.setMin = function(min) {
            this.set("min", min);
            this.el.setAttribute("aria-valuemin", min)
        };
        proto.setMax = function(max) {
            this.set("max", max);
            this.el.setAttribute("aria-valuemax", max);
            this._cachedMaxStep = max / 100
        };
        proto.setStep = function(step) {
            this.set("step", step)
        };
        proto.set = function(key, value) {
            if (VALID_KEYS.indexOf(key) > -1 && this.model[key] !== value) {
                var previous = this.model[key];
                this.model[key] = value;
                this.trigger("change:model:" + key, {
                    previous: previous,
                    current: value
                })
            }
        };
        proto._removeEventListeners = function() {
            this.removeEventListener(this.el, "mousedown", this.onMouseDown);
            this.removeEventListener(this.el, "touchstart", this.onTouchStart);
            this.removeEventListener(this.el, "mouseover", this.onMouseOver);
            this.removeEventListener(this.el, "mouseleave", this.onMouseLeave);
            this.removeEventListener(this.el, "touchend", this.onTouchEnd);
            this.removeEventListener(document, "touchend", this.onMouseUp);
            if (this.model.orientation === "horizontal") {
                this._keyboard.offDown(ARROW_RIGHT.num, this.stepUp);
                this._keyboard.offDown(ARROW_LEFT.num, this.stepDown);
                this._keyboard.offUp(ARROW_LEFT.num, this._triggerRelease);
                this._keyboard.offUp(ARROW_RIGHT.num, this._triggerRelease)
            } else {
                this._keyboard.offDown(ARROW_DOWN.num, this.stepDown);
                this._keyboard.offDown(ARROW_UP.num, this.stepUp);
                this._keyboard.offUp(ARROW_DOWN.num, this._triggerRelease);
                this._keyboard.offUp(ARROW_UP.num, this._triggerRelease)
            }
        };
        proto.destroy = function() {
            this._removeEventListeners();
            if (this._keyboard) {
                this._keyboard.destroy()
            }
            ac_event_emitter_micro.EventEmitterMicro.prototype.destroy.call(this)
        };
        module.exports = SliderView
    }, {
        "@marcom/ac-dom-metrics": 462,
        "@marcom/ac-event-emitter-micro": 422,
        "@marcom/ac-keyboard/Keyboard": 442
    }],
    475: [function(require, module, exports) {
        "use strict";
        module.exports.Slider = require("./Slider")
    }, {
        "./Slider": 474
    }],
    476: [function(require, module, exports) {
        module.exports = require("./lib/")
    }, {
        "./lib/": 477
    }],
    477: [function(require, module, exports) {
        var Stringify = require("./stringify");
        var Parse = require("./parse");
        var internals = {};
        module.exports = {
            stringify: Stringify,
            parse: Parse
        }
    }, {
        "./parse": 478,
        "./stringify": 479
    }],
    478: [function(require, module, exports) {
        var Utils = require("./utils");
        var internals = {
            delimiter: "&",
            depth: 5,
            arrayLimit: 20,
            parameterLimit: 1e3
        };
        internals.parseValues = function(str, options) {
            var obj = {};
            var parts = str.split(options.delimiter, options.parameterLimit === Infinity ? undefined : options.parameterLimit);
            for (var i = 0, il = parts.length; i < il; ++i) {
                var part = parts[i];
                var pos = part.indexOf("]=") === -1 ? part.indexOf("=") : part.indexOf("]=") + 1;
                if (pos === -1) {
                    obj[Utils.decode(part)] = ""
                } else {
                    var key = Utils.decode(part.slice(0, pos));
                    var val = Utils.decode(part.slice(pos + 1));
                    if (!obj.hasOwnProperty(key)) {
                        obj[key] = val
                    } else {
                        obj[key] = [].concat(obj[key]).concat(val)
                    }
                }
            }
            return obj
        };
        internals.parseObject = function(chain, val, options) {
            if (!chain.length) {
                return val
            }
            var root = chain.shift();
            var obj = {};
            if (root === "[]") {
                obj = [];
                obj = obj.concat(internals.parseObject(chain, val, options))
            } else {
                var cleanRoot = root[0] === "[" && root[root.length - 1] === "]" ? root.slice(1, root.length - 1) : root;
                var index = parseInt(cleanRoot, 10);
                var indexString = "" + index;
                if (!isNaN(index) && root !== cleanRoot && indexString === cleanRoot && index >= 0 && index <= options.arrayLimit) {
                    obj = [];
                    obj[index] = internals.parseObject(chain, val, options)
                } else {
                    obj[cleanRoot] = internals.parseObject(chain, val, options)
                }
            }
            return obj
        };
        internals.parseKeys = function(key, val, options) {
            if (!key) {
                return
            }
            var parent = /^([^\[\]]*)/;
            var child = /(\[[^\[\]]*\])/g;
            var segment = parent.exec(key);
            if (Object.prototype.hasOwnProperty(segment[1])) {
                return
            }
            var keys = [];
            if (segment[1]) {
                keys.push(segment[1])
            }
            var i = 0;
            while ((segment = child.exec(key)) !== null && i < options.depth) {
                ++i;
                if (!Object.prototype.hasOwnProperty(segment[1].replace(/\[|\]/g, ""))) {
                    keys.push(segment[1])
                }
            }
            if (segment) {
                keys.push("[" + key.slice(segment.index) + "]")
            }
            return internals.parseObject(keys, val, options)
        };
        module.exports = function(str, options) {
            if (str === "" || str === null || typeof str === "undefined") {
                return {}
            }
            options = options || {};
            options.delimiter = typeof options.delimiter === "string" || Utils.isRegExp(options.delimiter) ? options.delimiter : internals.delimiter;
            options.depth = typeof options.depth === "number" ? options.depth : internals.depth;
            options.arrayLimit = typeof options.arrayLimit === "number" ? options.arrayLimit : internals.arrayLimit;
            options.parameterLimit = typeof options.parameterLimit === "number" ? options.parameterLimit : internals.parameterLimit;
            var tempObj = typeof str === "string" ? internals.parseValues(str, options) : str;
            var obj = {};
            var keys = Object.keys(tempObj);
            for (var i = 0, il = keys.length; i < il; ++i) {
                var key = keys[i];
                var newObj = internals.parseKeys(key, tempObj[key], options);
                obj = Utils.merge(obj, newObj)
            }
            return Utils.compact(obj)
        }
    }, {
        "./utils": 480
    }],
    479: [function(require, module, exports) {
        var Utils = require("./utils");
        var internals = {
            delimiter: "&",
            indices: true
        };
        internals.stringify = function(obj, prefix, options) {
            if (Utils.isBuffer(obj)) {
                obj = obj.toString()
            } else if (obj instanceof Date) {
                obj = obj.toISOString()
            } else if (obj === null) {
                obj = ""
            }
            if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean") {
                return [encodeURIComponent(prefix) + "=" + encodeURIComponent(obj)]
            }
            var values = [];
            if (typeof obj === "undefined") {
                return values
            }
            var objKeys = Object.keys(obj);
            for (var i = 0, il = objKeys.length; i < il; ++i) {
                var key = objKeys[i];
                if (!options.indices && Array.isArray(obj)) {
                    values = values.concat(internals.stringify(obj[key], prefix, options))
                } else {
                    values = values.concat(internals.stringify(obj[key], prefix + "[" + key + "]", options))
                }
            }
            return values
        };
        module.exports = function(obj, options) {
            options = options || {};
            var delimiter = typeof options.delimiter === "undefined" ? internals.delimiter : options.delimiter;
            options.indices = typeof options.indices === "boolean" ? options.indices : internals.indices;
            var keys = [];
            if (typeof obj !== "object" || obj === null) {
                return ""
            }
            var objKeys = Object.keys(obj);
            for (var i = 0, il = objKeys.length; i < il; ++i) {
                var key = objKeys[i];
                keys = keys.concat(internals.stringify(obj[key], key, options))
            }
            return keys.join(delimiter)
        }
    }, {
        "./utils": 480
    }],
    480: [function(require, module, exports) {
        var internals = {};
        exports.arrayToObject = function(source) {
            var obj = {};
            for (var i = 0, il = source.length; i < il; ++i) {
                if (typeof source[i] !== "undefined") {
                    obj[i] = source[i]
                }
            }
            return obj
        };
        exports.merge = function(target, source) {
            if (!source) {
                return target
            }
            if (typeof source !== "object") {
                if (Array.isArray(target)) {
                    target.push(source)
                } else {
                    target[source] = true
                }
                return target
            }
            if (typeof target !== "object") {
                target = [target].concat(source);
                return target
            }
            if (Array.isArray(target) && !Array.isArray(source)) {
                target = exports.arrayToObject(target)
            }
            var keys = Object.keys(source);
            for (var k = 0, kl = keys.length; k < kl; ++k) {
                var key = keys[k];
                var value = source[key];
                if (!target[key]) {
                    target[key] = value
                } else {
                    target[key] = exports.merge(target[key], value)
                }
            }
            return target
        };
        exports.decode = function(str) {
            try {
                return decodeURIComponent(str.replace(/\+/g, " "))
            } catch (e) {
                return str
            }
        };
        exports.compact = function(obj, refs) {
            if (typeof obj !== "object" || obj === null) {
                return obj
            }
            refs = refs || [];
            var lookup = refs.indexOf(obj);
            if (lookup !== -1) {
                return refs[lookup]
            }
            refs.push(obj);
            if (Array.isArray(obj)) {
                var compacted = [];
                for (var i = 0, il = obj.length; i < il; ++i) {
                    if (typeof obj[i] !== "undefined") {
                        compacted.push(obj[i])
                    }
                }
                return compacted
            }
            var keys = Object.keys(obj);
            for (i = 0, il = keys.length; i < il; ++i) {
                var key = keys[i];
                obj[key] = exports.compact(obj[key], refs)
            }
            return obj
        };
        exports.isRegExp = function(obj) {
            return Object.prototype.toString.call(obj) === "[object RegExp]"
        };
        exports.isBuffer = function(obj) {
            if (obj === null || typeof obj === "undefined") {
                return false
            }
            return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj))
        }
    }, {}],
    481: [function(require, module, exports) {
        "use strict";
        module.exports = {
            Link: require("./ac-social/Link"),
            Dialog: require("./ac-social/Dialog"),
            Focus: require("./ac-social/Focus"),
            Debug: require("./ac-social/Debug")
        }
    }, {
        "./ac-social/Debug": 482,
        "./ac-social/Dialog": 483,
        "./ac-social/Focus": 484,
        "./ac-social/Link": 485
    }],
    482: [function(require, module, exports) {
        "use strict";
        var NetworkActions = require("./NetworkActions");

        function Debug() {
            this.types = {};
            var i;
            for (i in NetworkActions) {
                if (NetworkActions.hasOwnProperty(i)) {
                    proto[i] = i;
                    this.addType(i, NetworkActions[i].getDialogDebugData.bind(NetworkActions[i]))
                }
            }
        }
        var proto = Debug.prototype;
        proto.create = function(type, data) {
            data = data || {};
            var func = this.types[type];
            if (!func) {
                return
            }
            return func(data)
        };
        proto.addType = function(name, func) {
            this.types[name] = func;
            return this
        };
        proto.removeType = function() {
            this.types[name] = null;
            return this
        };
        module.exports = new Debug
    }, {
        "./NetworkActions": 486
    }],
    483: [function(require, module, exports) {
        "use strict";
        var NetworkActions = require("./NetworkActions");

        function Dialog() {
            this.types = {};
            var i;
            for (i in NetworkActions) {
                if (NetworkActions.hasOwnProperty(i)) {
                    proto[i] = i;
                    this.addType(i, NetworkActions[i].generateDialog.bind(NetworkActions[i]))
                }
            }
        }
        var proto = Dialog.prototype;
        proto.create = function(type, data) {
            data = data || {};
            var func = this.types[type];
            if (!func) {
                return
            }
            return func(data)
        };
        proto.addType = function(name, func) {
            this.types[name] = func;
            return this
        };
        proto.removeType = function() {
            this.types[name] = null;
            return this
        };
        module.exports = new Dialog
    }, {
        "./NetworkActions": 486
    }],
    484: [function(require, module, exports) {
        "use strict";
        module.exports = function(el) {
            if (window.getSelection) {
                var selection = window.getSelection();
                var range = document.createRange();
                range.selectNodeContents(el);
                selection.removeAllRanges();
                selection.addRange(range)
            } else if (el.setSelectionRange) {
                el.setSelectionRange(0, el.value.length)
            } else if (document.body.createTextRange) {
                var range = document.body.createTextRange();
                range.moveToElementText(el);
                range.select()
            }
        }
    }, {}],
    485: [function(require, module, exports) {
        "use strict";
        var NetworkActions = require("./NetworkActions"),
            DefaultNetworkAction = require("./network-actions/DefaultNetworkAction");

        function Link() {
            this.types = {};
            var i;
            for (i in NetworkActions) {
                if (NetworkActions.hasOwnProperty(i)) {
                    proto[i] = i;
                    this.addType(i, NetworkActions[i].generateLink.bind(NetworkActions[i]))
                }
            }
        }
        var proto = Link.prototype;
        proto.create = function(type, data, el) {
            data = data || {};
            var func = this.types[type];
            if (!func) {
                return
            }
            return func(data, el)
        };
        proto.createFromAnchor = function(el) {
            var elNetworkAction = el.getAttribute("data-network-action");
            var i;
            for (i in NetworkActions) {
                if (NetworkActions.hasOwnProperty(i)) {
                    if (elNetworkAction === NetworkActions[i].id) {
                        NetworkActions[i].enhanceLinkEngagement(el);
                        return
                    }
                }
            }
            DefaultNetworkAction.enhanceLinkEngagement(el)
        };
        proto.addType = function(name, func) {
            this.types[name] = func;
            return this
        };
        proto.removeType = function() {
            this.types[name] = null;
            return this
        };
        module.exports = new Link
    }, {
        "./NetworkActions": 486,
        "./network-actions/DefaultNetworkAction": 487
    }],
    486: [function(require, module, exports) {
        "use strict";
        var FacebookShare = require("./network-actions/FacebookShare"),
            PinterestShare = require("./network-actions/PinterestShare"),
            TumblrShare = require("./network-actions/TumblrShare"),
            TwitterFavorite = require("./network-actions/TwitterFavorite"),
            TwitterReply = require("./network-actions/TwitterReply"),
            TwitterRetweet = require("./network-actions/TwitterRetweet"),
            TwitterTweet = require("./network-actions/TwitterTweet"),
            WeiboShare = require("./network-actions/WeiboShare"),
            QQWeiboShare = require("./network-actions/QQWeiboShare"),
            QZoneShare = require("./network-actions/QZoneShare"),
            RenrenShare = require("./network-actions/RenrenShare"),
            EMailShare = require("./network-actions/EMailShare");
        module.exports = {
            FACEBOOK_SHARE: FacebookShare,
            PINTEREST_SHARE: PinterestShare,
            TUMBLR_SHARE: TumblrShare,
            TWITTER_FAVORITE: TwitterFavorite,
            TWITTER_REPLY: TwitterReply,
            TWITTER_RETWEET: TwitterRetweet,
            TWITTER_TWEET: TwitterTweet,
            WEIBO_SHARE: WeiboShare,
            QQWEIBO_SHARE: QQWeiboShare,
            QZONE_SHARE: QZoneShare,
            RENREN_SHARE: RenrenShare,
            EMAIL_SHARE: EMailShare
        }
    }, {
        "./network-actions/EMailShare": 488,
        "./network-actions/FacebookShare": 489,
        "./network-actions/PinterestShare": 491,
        "./network-actions/QQWeiboShare": 492,
        "./network-actions/QZoneShare": 493,
        "./network-actions/RenrenShare": 494,
        "./network-actions/TumblrShare": 495,
        "./network-actions/TwitterFavorite": 496,
        "./network-actions/TwitterReply": 497,
        "./network-actions/TwitterRetweet": 498,
        "./network-actions/TwitterTweet": 499,
        "./network-actions/WeiboShare": 500
    }],
    487: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            return rawData
        };
        module.exports = new NetworkAction(normalizeData, {
            baseLinkPath: ""
        })
    }, {
        "./NetworkAction": 490
    }],
    488: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            var data = {
                url: rawData.url
            };
            if (rawData.title) {
                data.subject = rawData.title
            }
            if (rawData.description) {
                data.body = rawData.description + "\r\n\r\n" + rawData.url
            } else {
                data.body = rawData.url
            }
            return data
        };
        module.exports = new NetworkAction(normalizeData, {
            id: "email-share",
            baseLinkPath: "mailto:",
            preventDialog: true
        })
    }, {
        "./NetworkAction": 490
    }],
    489: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            return {
                u: rawData.url
            }
        };
        module.exports = new NetworkAction(normalizeData, {
            id: "facebook-share",
            baseLinkPath: "https://www.facebook.com/sharer/sharer.php",
            dialogDimensions: {
                width: 555,
                height: 368
            }
        })
    }, {
        "./NetworkAction": 490
    }],
    490: [function(require, module, exports) {
        "use strict";
        var qs = require("qs");
        var proto;
        var NetworkAction = function(normalizeDataFunc, options) {
            options = options || {};
            this.baseLinkPath = options.baseLinkPath;
            if (options.dialogDimensions) {
                this.dialogDimensions = options.dialogDimensions
            }
            if (options.id) {
                this.id = options.id
            }
            if (options.preventDialog) {
                this.preventDialog = options.preventDialog
            }
            this.normalizeData = normalizeDataFunc
        };
        proto = NetworkAction.prototype;
        proto.dataAttributeName = "network-action";
        proto.id = "network-action";
        proto.normalizeData = function(rawData) {
            return rawData
        };
        proto.dialogDimensions = {
            width: 500,
            height: 500
        };
        proto.generateLinkURL = function(rawData) {
            var normalizedData = this.normalizeData(rawData),
                queryString = qs.stringify(normalizedData),
                linkPath = this.baseLinkPath;
            if (queryString.length > 0) {
                linkPath = linkPath + "?" + queryString
            }
            return linkPath
        };
        proto.generateLink = function(rawData, el) {
            var url = this.generateLinkURL(rawData);
            el = el || document.createElement("A");
            el.setAttribute("href", url);
            el.setAttribute("target", "_blank");
            el.setAttribute("data-" + this.dataAttributeName, this.id);
            this.enhanceLinkEngagement(el, url);
            return el
        };
        proto.generateDialog = function(rawData) {
            var linkPath = this.generateLinkURL(rawData);
            this._triggerDialog(linkPath)
        };
        proto.enhanceLinkEngagement = function(el, url) {
            var scope = this || proto;
            url = url || el.getAttribute("href");
            el.addEventListener("click", this._onLinkEngaged.bind(this, url))
        };
        proto.getDialogOptions = function() {
            var i, optionsStr = "status=1",
                options = {
                    width: this.dialogDimensions.width,
                    height: this.dialogDimensions.height
                };
            options.top = (window.screen.availHeight - options.height) / 2;
            options.left = (window.screen.availWidth - options.width) / 2;
            for (i in options) {
                if (options.hasOwnProperty(i)) {
                    optionsStr += ", " + i + "=" + options[i]
                }
            }
            return optionsStr
        };
        proto.getDialogDebugData = function(rawData) {
            return {
                data: this.normalizeData(rawData),
                dialogUrl: this.generateLinkURL(rawData)
            }
        };
        proto._triggerDialog = function(url) {
            if (this.preventDialog) {
                window.location.href = url;
                return
            }
            window.open(url, "_blank", this.getDialogOptions())
        };
        proto._onLinkEngaged = function(url, e) {
            e.preventDefault();
            this._triggerDialog(url)
        };
        module.exports = NetworkAction
    }, {
        qs: 476
    }],
    491: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            var data = {
                url: rawData.url,
                description: rawData.description
            };
            if (rawData.media) {
                data.media = rawData.media
            }
            return data
        };
        module.exports = new NetworkAction(normalizeData, {
            id: "pinterest-share",
            baseLinkPath: "http://www.pinterest.com/pin/create/button",
            dialogDimensions: {
                width: 750,
                height: 450
            }
        })
    }, {
        "./NetworkAction": 490
    }],
    492: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            return {
                url: rawData.url,
                title: rawData.title,
                pic: rawData.media
            }
        };
        module.exports = new NetworkAction(normalizeData, {
            id: "qq-weibo-share",
            baseLinkPath: "http://v.t.qq.com/share/share.php",
            dialogDimensions: {
                width: 658,
                height: 506
            }
        })
    }, {
        "./NetworkAction": 490
    }],
    493: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            return {
                url: rawData.url,
                title: rawData.title,
                pics: rawData.media,
                summary: rawData.description
            }
        };
        module.exports = new NetworkAction(normalizeData, {
            id: "qzone-share",
            baseLinkPath: "http://sns.qzone.qq.com/cgi-bin/qzshare/cgi_qzshare_onekey",
            dialogDimensions: {
                width: 620,
                height: 645
            }
        })
    }, {
        "./NetworkAction": 490
    }],
    494: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            return {
                url: rawData.url,
                title: rawData.title
            }
        };
        module.exports = new NetworkAction(normalizeData, {
            id: "renren-share",
            baseLinkPath: "http://www.connect.renren.com/share/sharer",
            dialogDimensions: {
                width: 500,
                height: 315
            }
        })
    }, {
        "./NetworkAction": 490
    }],
    495: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            var data = {
                clickthru: rawData.url,
                caption: rawData.description
            };
            if (rawData.media) {
                data.source = rawData.media
            }
            return data
        };
        module.exports = new NetworkAction(normalizeData, {
            id: "tumblr-share",
            baseLinkPath: "http://www.tumblr.com/share/photo",
            dialogDimensions: {
                width: 450,
                height: 432
            }
        })
    }, {
        "./NetworkAction": 490
    }],
    496: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            var data = {
                tweet_id: rawData.messageId
            };
            return data
        };
        module.exports = new NetworkAction(normalizeData, {
            id: "twitter-favorite",
            baseLinkPath: "https://twitter.com/intent/favorite",
            dialogDimensions: {
                width: 550,
                height: 420
            }
        })
    }, {
        "./NetworkAction": 490
    }],
    497: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            var data = {
                in_reply_to: rawData.messageId
            };
            if (rawData.hashtags) {
                data.hashtags = rawData.hashtags
            }
            return data
        };
        module.exports = new NetworkAction(normalizeData, {
            id: "twitter-reply",
            baseLinkPath: "https://twitter.com/intent/tweet",
            dialogDimensions: {
                width: 550,
                height: 420
            }
        })
    }, {
        "./NetworkAction": 490
    }],
    498: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            var data = {
                tweet_id: rawData.messageId
            };
            return data
        };
        module.exports = new NetworkAction(normalizeData, {
            id: "twitter-retweet",
            baseLinkPath: "https://twitter.com/intent/retweet",
            dialogDimensions: {
                width: 550,
                height: 420
            }
        })
    }, {
        "./NetworkAction": 490
    }],
    499: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            var data = {
                url: rawData.url,
                text: rawData.description
            };
            if (rawData.hashtags) {
                data.hashtags = rawData.hashtags
            }
            return data
        };
        module.exports = new NetworkAction(normalizeData, {
            id: "twitter-tweet",
            baseLinkPath: "https://twitter.com/intent/tweet",
            dialogDimensions: {
                width: 550,
                height: 420
            }
        })
    }, {
        "./NetworkAction": 490
    }],
    500: [function(require, module, exports) {
        "use strict";
        var NetworkAction = require("./NetworkAction");
        var normalizeData = function(rawData) {
            return {
                url: rawData.url,
                title: rawData.title,
                pic: rawData.media
            }
        };
        module.exports = new NetworkAction(normalizeData, {
            id: "weibo-share",
            baseLinkPath: "http://service.weibo.com/share/share.php",
            dialogDimensions: {
                width: 650,
                height: 426
            }
        })
    }, {
        "./NetworkAction": 490
    }],
    501: [function(require, module, exports) {
        "use strict";
        var DOMEmitterMicro = function(element) {
            this.el = element
        };
        var proto = DOMEmitterMicro.prototype;
        proto.on = function() {
            this.el.addEventListener.apply(this.el, arguments)
        };
        proto.off = function() {
            this.el.removeEventListener.apply(this.el, arguments)
        };
        proto.once = function(type, cb) {
            var onceCallback = function() {
                cb();
                this.off(type, onceCallback)
            }.bind(this);
            this.on(type, onceCallback)
        };
        proto.trigger = function(eventName, data) {
            var evt = new CustomEvent(eventName, data);
            this.el.dispatchEvent(evt)
        };
        module.exports = DOMEmitterMicro
    }, {}],
    502: [function(require, module, exports) {
        "use strict";
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var EventEmitterShim = function() {
            EventEmitterMicro.call(this)
        };
        var superProto = EventEmitterMicro.prototype;
        EventEmitterShim.prototype = Object.create(superProto);
        var proto = EventEmitterShim.prototype;
        proto.constructor = EventEmitterShim;
        proto.once = function(eventName, callback, context) {
            if (context) {
                var cb = function() {
                    callback.apply(context, arguments)
                };
                superProto.once.apply(this, [eventName, cb])
            } else {
                superProto.once.apply(this, arguments)
            }
        };
        proto.on = function(eventType, callback, context) {
            if (arguments.length > 2) {
                if (!this._boundListeners) {
                    this._boundListeners = {}
                }
                if (!this._boundListeners[eventType]) {
                    this._boundListeners[eventType] = []
                }
                var bound = callback.bind(context);
                this._boundListeners[eventType].push([callback, context, bound]);
                return superProto.on.call(this, eventType, bound)
            } else {
                return superProto.on.apply(this, arguments)
            }
        };
        proto.off = function(eventType, callback, context) {
            if (arguments.length > 2) {
                try {
                    var boundListeners = this._boundListeners[eventType];
                    var i = 0;
                    var len = boundListeners.length;
                    for (; i < len; i++) {
                        if (boundListeners[i][0] === callback && boundListeners[i][1] === context) {
                            var bound = boundListeners.splice(i, 1)[0];
                            return superProto.off.call(this, eventType, bound[2])
                        }
                    }
                } catch (e) {}
            } else {
                return superProto.off.apply(this, arguments)
            }
        };
        proto.destroy = function() {
            this._boundListeners = undefined;
            superProto.destroy.call(this)
        };
        module.exports = EventEmitterShim
    }, {
        "@marcom/ac-event-emitter-micro": 422
    }],
    503: [function(require, module, exports) {
        "use strict";
        module.exports = require("./utils/urlOptimizer/OptimizeVideoUrl")
    }, {
        "./utils/urlOptimizer/OptimizeVideoUrl": 557
    }],
    504: [function(require, module, exports) {
        "use strict";
        var EventEmitter = require("../event-emitter-shim/EventEmitterShim");
        var DOMEmitterMicro = require("../dom-emitter/DOMEmitterMicro");
        var createVideo = require("../video/VideoFactory").create;
        var userAgent = require("@marcom/ac-useragent");
        var ac_fullscreen = require("@marcom/ac-fullscreen");
        var createPoster = require("../posterframe/PosterFrameFactory");
        var IS_RETINA = require("@marcom/ac-feature/isRetina")();
        var IS_DESKTOP = require("@marcom/ac-feature/isDesktop")();
        var IS_HANDHELD = require("@marcom/ac-feature/isHandheld")();
        var IS_SAFARI_OSX = userAgent.browser.safari && userAgent.os.osx;
        var IS_SAFARI_IOS = userAgent.browser.safari && userAgent.os.ios;
        var IS_CHROME = userAgent.browser.chrome;
        var USER_HOVER_CLASS = "user-hover";
        var MOBILE_CONTROLS_CLASS = "mobile";
        var INITIAL_PLAY_CLASS = "initial-play";
        var LIVE_MODE_CLASS = "ac-video-live";
        var LONGFORM_CLASS = "longform";
        var DEFAULT_BREAKPOINTS = require("../ui/DefaultBreakpoints");
        var log = require("@marcom/ac-console/log");
        var EventsToForward = require("./event/EventsToForward");
        var ReadyStateChangeEvents = require("./event/ReadyStateChangeEvents");
        var BreakpointDetect = require("../utils/BreakpointDetect");
        var KeyboardControl = require("../ui/KeyboardControl");
        var disableFocus = require("@marcom/ac-accessibility/helpers/hide");
        var enableFocus = require("@marcom/ac-accessibility/helpers/show");
        var Player = function(options) {
            options = options || {};
            this.el = options.el || document.createElement("div");
            this._elementEmitter = new DOMEmitterMicro(this.el);
            this.options = options;
            EventEmitter.call(this);
            this._controlsFactory = options.controlsFactory;
            this._urlOptimizer = options.urlOptimizer;
            try {
                var rootWindow = window.top;
                this._maxWidth = options.maxWidth || Math.min(window.innerWidth, 1280) || Math.min(rootWindow.innerWidth, 1280)
            } catch (e) {
                this._maxWidth = options.maxWidth || Math.min(window.innerWidth, 1280)
            }
            this._lastResize = 0;
            this._lastMouseCoords = {};
            this.el.classList.add("ac-video-player");
            this._isResponsive = options.responsive;
            if (this._isResponsive) {
                this._breakpointDetect = new BreakpointDetect({
                    el: this.el,
                    player: this,
                    breakpoints: DEFAULT_BREAKPOINTS,
                    addClass: true
                })
            }
            this._isLive = options.live;
            if (this._isLive) {
                this._useLiveMode()
            }
            this._videoImpl = createVideo(options, this.el);
            this._supportsInlineVideo = IS_DESKTOP || !(IS_HANDHELD && IS_SAFARI_IOS);
            this._cachedPiPMode = this.isPictureInPicture();
            this._cachedReadyState = this.getReadyState();
            this._cachedVisibleTracksLength = 0;
            this.el.appendChild(this._videoImpl.getMediaElement());
            if (options.poster || typeof options.poster === "undefined") {
                this._initPoster(options.poster)
            }
            this._bindMethods();
            this._addEventListeners();
            if (IS_DESKTOP) {
                this._keyboardControl = new KeyboardControl({
                    player: this,
                    keyboardTarget: options.keyboardTarget
                })
            }
            if (options.controls) {
                this._initUIComponents()
            }
            if (options.parentElement) {
                options.parentElement.appendChild(this.el)
            }
            this.refreshSize = this.refreshSize.bind(this);
            setTimeout(this.refreshSize, 0);
            window.addEventListener("DOMContentLoaded", this.refreshSize)
        };
        Player.LOADEDMETADATA = 1;
        Player.LOADEDDATA = 2;
        Player.CANPLAY = 3;
        Player.CANPLAYTHROUGH = 4;
        var superProto = EventEmitter.prototype;
        Player.prototype = Object.create(superProto);
        var proto = Player.prototype;
        proto.constructor = Player;
        proto._bindMethods = function() {
            this._onStart = this._onStart.bind(this);
            this._onEnded = this._onEnded.bind(this);
            this._onTimeUpdate = this._onTimeUpdate.bind(this);
            this._onCaptionsChanged = this._onCaptionsChanged.bind(this);
            this._onPlay = this._onPlay.bind(this);
            this._onFullscreenChange = this._onFullscreenChange.bind(this);
            this._forwardEvent = this._forwardEvent.bind(this);
            this._onPresentationModeChanged = this._onPresentationModeChanged.bind(this);
            this._forwardFullScreenChangeEvent = this._forwardNamedEvent.bind(this, "fullscreen:change");
            this._forwardEnterFullScreenEvent = this._forwardNamedEvent.bind(this, "enterfullscreen");
            this._forwardExitFullScreenEvent = this._forwardNamedEvent.bind(this, "exitfullscreen");
            this._onDurationChange = this._onDurationChange.bind(this);
            this._forwardReadyStateChange = this._forwardReadyStateChange.bind(this);
            this._onFocusIn = this._onFocusIn.bind(this);
            this._onFocusOut = this._onFocusOut.bind(this);
            this._showControls = this._showControls.bind(this);
            this._hideControls = this._hideControls.bind(this);
            this._onClick = this._onClick.bind(this);
            this._onUserInteraction = this._onUserInteraction.bind(this);
            this._onMouseLeave = this._onMouseLeave.bind(this);
            this._onMouseOut = this._onMouseOut.bind(this);
            this._onPlayPromiseError = this._onPlayPromiseError.bind(this)
        };
        proto._addEventListeners = function() {
            var i = 0;
            var len = EventsToForward.length;
            for (; i < len; i++) {
                this._videoImpl.on(EventsToForward[i], this._forwardEvent)
            }
            i = 0;
            len = ReadyStateChangeEvents.length;
            for (; i < len; i++) {
                this._videoImpl.on(ReadyStateChangeEvents[i], this._forwardReadyStateChange)
            }
            this._videoImpl.on("timeupdate", this._onTimeUpdate);
            this._videoImpl.on("webkitpresentationmodechanged", this._onPresentationModeChanged);
            this._videoImpl.on("durationchange", this._onDurationChange);
            this._videoImpl.on("addtrack", this._forwardEvent);
            this._videoImpl.on("change", this._forwardEvent);
            this._videoImpl.on("change", this._onCaptionsChanged);
            this._videoImpl.on("removetrack", this._forwardEvent);
            if (IS_DESKTOP) {
                ac_fullscreen.on("enterfullscreen", this._forwardEnterFullScreenEvent);
                ac_fullscreen.on("exitfullscreen", this._forwardExitFullScreenEvent);
                ac_fullscreen.on("enterfullscreen", this._forwardFullScreenChangeEvent);
                ac_fullscreen.on("exitfullscreen", this._forwardFullScreenChangeEvent)
            } else if (IS_SAFARI_IOS) {
                this._videoImpl.on("webkitbeginfullscreen", this._forwardEnterFullScreenEvent);
                this._videoImpl.on("webkitendfullscreen", this._forwardExitFullScreenEvent);
                this._videoImpl.on("webkitbeginfullscreen", this._forwardFullScreenChangeEvent);
                this._videoImpl.on("webkitendfullscreen", this._forwardFullScreenChangeEvent)
            }
            this._videoImpl.on("PlayPromiseError", this._onPlayPromiseError);
            this._elementEmitter.on("focusin", this._onFocusIn);
            this._elementEmitter.on("focusout", this._onFocusOut);
            this.on("fullscreen:change", this._onFullscreenChange)
        };
        proto._removeEventListeners = function() {
            var i = 0;
            var len = EventsToForward.length;
            for (; i < len; i++) {
                this._videoImpl.off(EventsToForward[i], this._forwardEvent)
            }
            i = 0;
            len = ReadyStateChangeEvents.length;
            for (; i < len; i++) {
                this._videoImpl.off(ReadyStateChangeEvents[i], this._forwardReadyStateChange)
            }
            this._videoImpl.off("timeupdate", this._onTimeUpdate);
            this._videoImpl.off("webkitpresentationmodechanged", this._onPresentationModeChanged);
            this._videoImpl.off("durationchange", this._onDurationChange);
            if (IS_DESKTOP) {
                ac_fullscreen.off("enterfullscreen", this._forwardEnterFullScreenEvent);
                ac_fullscreen.off("exitfullscreen", this._forwardExitFullScreenEvent);
                ac_fullscreen.off("enterfullscreen", this._forwardFullScreenChangeEvent);
                ac_fullscreen.off("exitfullscreen", this._forwardFullScreenChangeEvent)
            } else if (userAgent.os.ios) {
                this._videoImpl.off("webkitbeginfullscreen", this._forwardEnterFullScreenEvent);
                this._videoImpl.off("webkitendfullscreen", this._forwardExitFullScreenEvent);
                this._videoImpl.off("webkitbeginfullscreen", this._forwardFullScreenChangeEvent);
                this._videoImpl.off("webkitendfullscreen", this._forwardFullScreenChangeEvent)
            }
            this._elementEmitter.off("focusin", this._onFocusIn);
            this._elementEmitter.off("focusout", this._onFocusOut);
            this._elementEmitter.off("mouseenter", this._onUserInteraction);
            if (this.controls) {
                this.controls.el.removeEventListener("mousemove", this._onUserInteraction, true);
                this.controls.el.removeEventListener("click", this._onUserInteraction, true)
            }
            if (this._blockade) {
                this._blockade.off("mouseenter", this._onUserInteraction);
                this._blockade.off("mousemove", this._onUserInteraction);
                this._blockade.off("click", this._onUserInteraction);
                this._elementEmitter.off("click", this._onClick);
                if ("onmouseleave" in this.el) {
                    this._blockade.off("mouseleave", this._onMouseLeave)
                } else {
                    this._blockade.off("mouseout", this._onMouseOut)
                }
                clearTimeout(this._userInteractionTimeout)
            }
            if (this._keyboardControl) {
                this._keyboardControl.off("keyboardinteraction", this._onUserInteraction)
            }
            this.off("fullscreen:change", this._onFullscreenChange);
            this._videoImpl.off("PlayPromiseError", this._onPlayPromiseError);
            clearTimeout(this._userInteractionTimeout)
        };
        proto._forwardReadyStateChange = function() {
            var readyState = this.getReadyState();
            if (readyState > this._cachedReadyState || readyState === 0) {
                this._cachedReadyState = readyState;
                this.trigger("readystatechange", {
                    readyState: readyState
                })
            }
        };
        proto._forwardEvent = function(evt) {
            log(evt.type + " time:" + this.getCurrentTime());
            this.trigger(evt.type)
        };
        proto._forwardNamedEvent = function(name) {
            log(name + " time:" + this.getCurrentTime());
            this.trigger(name)
        };
        proto._onPlayPromiseError = function() {
            log("play() Promise rejected, probably because the browser is blocking autoplay");
            this.el.classList.add(INITIAL_PLAY_CLASS);
            this._showStartState();
            this.once("play", this._onPlay)
        };
        proto._onCaptionsChanged = function(evt) {
            var visibleTracksLength = this.getVisibleTextTracks().length;
            if (visibleTracksLength > 0 && this._cachedVisibleTracksLength === 0) {
                this.trigger("texttrackshow")
            } else if (visibleTracksLength === 0 && this._cachedVisibleTracksLength > 0) {
                this.trigger("texttrackhide")
            }
            this._cachedVisibleTracksLength = visibleTracksLength
        };
        proto._onTimeUpdate = function() {
            this.trigger("timeupdate", {
                currentTime: this.getCurrentTime()
            })
        };
        proto.load = function(sourceUrls, textTrackUrls, startTime, metadata) {
            this.refreshSize();
            if (!Array.isArray(sourceUrls)) {
                sourceUrls = [sourceUrls]
            }
            if (textTrackUrls && !Array.isArray(textTrackUrls)) {
                textTrackUrls = [{
                    src: textTrackUrls
                }]
            }
            this._cachedReadyState = 0;
            if (!metadata) {
                metadata = this.options
            }
            if (this._urlOptimizer) {
                if (!textTrackUrls) {
                    textTrackUrls = sourceUrls.map(this._urlOptimizer.getCaptionsSource).filter(function(val) {
                        return !!val
                    })
                }
                var visibleTracks = this.getVisibleTextTracks();
                if (visibleTracks && visibleTracks.length && textTrackUrls && textTrackUrls.length) {
                    textTrackUrls[0].mode = "showing"
                }
                var calculatedMaxWidth = metadata.maxWidth || this._calcMaxWidth();
                sourceUrls = sourceUrls.map(function(url) {
                    return this._urlOptimizer.getVideoSource(url, calculatedMaxWidth, null, {
                        maxWidth: this._maxWidth
                    })
                }.bind(this))
            }
            var thumbnails = metadata && metadata.thumbnails || this._urlOptimizer && this._urlOptimizer.getThumbnailImageSource(sourceUrls[0]);
            this.once("play", this._onPlay);
            if (this._poster) {
                this._poster.show()
            }
            if (this.options.autoplay && IS_DESKTOP) {
                this.once("loadstart", function() {
                    this.play()
                }.bind(this))
            }
            if (this.controls && this.controls.sharingModule) {
                if (metadata.sharing) {
                    this.controls.sharingModule.setData(metadata.sharing)
                } else {
                    this.controls.sharingModule.setData(null)
                }
            }
            if (metadata.live !== undefined) {
                this._isLive = metadata.live;
                this._useLiveMode()
            }
            this._videoImpl.load(sourceUrls, textTrackUrls, startTime);
            if (this.controls && this.controls.overlays) {
                this.controls.overlays.setData(thumbnails)
            } else if (this.controls) {
                this.once("controlsready", function() {
                    this.controls.overlays && this.controls.overlays.setData(thumbnails)
                }.bind(this))
            }
        };
        proto._calcMaxWidth = function() {
            if (this.el.parentElement) {
                return this.el.parentElement.clientWidth
            } else {
                return this._maxWidth
            }
        };
        proto._isActiveArea = function(el) {
            while (el !== this.el) {
                if (el.hasAttribute("data-acv-active-area")) {
                    return true
                }
                el = el.parentNode
            }
            return false
        };
        proto._onPresentationModeChanged = function(evt) {
            this._forwardEvent(evt);
            var isPiP = this.isPictureInPicture();
            if (this._cachedPiPMode !== isPiP) {
                this._cachedPiPMode = isPiP;
                log("pictureinpicture:change to " + isPiP);
                this.trigger("pictureinpicture:change")
            }
        };
        proto._onDurationChange = function(evt) {
            if (this.getDuration() > 3600) {
                this.el.classList.add(LONGFORM_CLASS)
            }
        };
        proto.appendTo = function(el) {
            el.appendChild(this.el);
            this.refreshSize()
        };
        proto.getTextTracks = function() {
            return Array.prototype.slice.call(this._videoImpl.getTextTracks())
        };
        proto.getVisibleTextTracks = function() {
            var tracks = Array.prototype.slice.call(this._videoImpl.getTextTracks());
            if (tracks && tracks.length) {
                tracks = tracks.filter(function(t) {
                    return t.mode === "showing"
                })
            }
            return tracks
        };
        proto.getFullScreenElement = function() {
            if (!IS_DESKTOP) {
                return this.getMediaElement()
            } else {
                return this.el
            }
        };
        proto.getFullScreenEnabled = function() {
            return ac_fullscreen.fullscreenEnabled(this.getFullScreenElement())
        };
        proto.isFullscreen = function() {
            if (IS_DESKTOP) {
                return ac_fullscreen.fullscreenElement() === this.getFullScreenElement()
            } else {
                return this._videoImpl.isFullscreen()
            }
        };
        proto.requestFullscreen = function() {
            if (!this.isFullscreen()) {
                if (this.controls) {
                    this.controls.el.display = "none"
                }
                this._hideControls();
                this.trigger("fullscreen:willenter", {
                    type: "enter"
                });
                this._lastResize = Date.now();
                if (IS_CHROME) {
                    setTimeout(function() {
                        this._lastResize = Date.now();
                        ac_fullscreen.requestFullscreen(this.getFullScreenElement())
                    }.bind(this), 300)
                } else {
                    ac_fullscreen.requestFullscreen(this.getFullScreenElement())
                }
            }
        };
        proto.exitFullscreen = function() {
            if (this.isFullscreen()) {
                if (this.controls) {
                    this.controls.el.display = "none"
                }
                this._hideControls();
                this.trigger("fullscreen:willexit", {
                    type: "exit"
                });
                if (IS_CHROME) {
                    setTimeout(function() {
                        ac_fullscreen.exitFullscreen(this.getFullScreenElement())
                    }.bind(this), 300)
                } else {
                    ac_fullscreen.exitFullscreen(this.getFullScreenElement())
                }
            }
        };
        proto._onFullscreenChange = function() {
            this._lastResize = Date.now();
            if (this.controls) {
                this.controls.el.display = ""
            }
            this._hideControls();
            this._preventUserInteraction = true;
            setTimeout(function() {
                this._preventUserInteraction = false
            }.bind(this), 750)
        };
        proto.toggleFullscreen = function() {
            if (this.isFullscreen()) {
                this.exitFullscreen()
            } else {
                this.requestFullscreen()
            }
        };
        proto._initUIComponents = function() {
            if (this._controlsFactory) {
                this._instantiateDefaultCustomUIControls();
                if (!IS_DESKTOP) {
                    this.controls.el.classList.add(MOBILE_CONTROLS_CLASS);
                    this.setControls(true)
                } else {
                    this.el.appendChild(this._blockade.el)
                }
            } else {
                this.setControls(true)
            }
        };
        proto._onFocusIn = function() {
            clearTimeout(this._focusOutTimer);
            this._focusOutTimer = null;
            this._hasFocus = true;
            if (IS_DESKTOP) {
                this._onUserInteraction()
            }
        };
        proto._onFocusOut = function(evt) {
            this._focusOutTimer = setTimeout(function() {
                if (this._hasFocus && !this.el.contains(document.activeElement)) {
                    this._hasFocus = false;
                    this._hideControls()
                }
            }.bind(this), 100)
        };
        proto._showControls = function() {
            this.el.classList.remove(INITIAL_PLAY_CLASS);
            this.el.classList.add(USER_HOVER_CLASS)
        };
        proto._hideControls = function() {
            this.el.classList.remove(USER_HOVER_CLASS)
        };
        proto._onControlsReady = function() {
            if (!this.options.autoplay || !IS_DESKTOP) {
                this._showStartState()
            }
        };
        proto._showStartState = function() {
            if (this.controls) {
                this.controls.el.classList.add("start-state")
            }
            if (!IS_DESKTOP) {
                disableFocus(this.getMediaElement())
            }
        };
        proto._hideStartState = function() {
            if (this.controls) {
                this.controls.el.classList.remove("start-state")
            }
            if (!IS_DESKTOP) {
                enableFocus(this.getMediaElement())
            }
        };
        proto._showEndState = function() {
            if (this.controls) {
                if (this.controls.mainControlsElement) {
                    if (this.controls.mainControlsElement.contains(document.activeElement)) {
                        this.controls.playButtonElement.focus()
                    }
                }
                this.controls.el.classList.add("end-state")
            }
            disableFocus(this.getMediaElement())
        };
        proto._hideEndState = function() {
            this.controls.el.classList.remove("end-state");
            if (!IS_DESKTOP) {
                enableFocus(this.getMediaElement())
            }
        };
        proto._instantiateDefaultCustomUIControls = function() {
            this.controls = this._controlsFactory.create({
                player: this,
                basePath: this.options.localizationBasePath,
                template: this.options.template,
                readyCallback: function() {
                    if (!this.options.autoplay || !IS_DESKTOP) {
                        this._showStartState()
                    }
                    this.trigger("controlsready")
                }.bind(this)
            });
            if (this.controls.el.parentNode !== this.el) {
                this.el.appendChild(this.controls.el)
            }
            this._videoImpl.setControls(false);
            this._blockade = new DOMEmitterMicro(document.createElement("div"));
            this._blockade.el.classList.add("ac-video-blockade");
            if (IS_DESKTOP) {
                this.controls.el.addEventListener("mousemove", this._onUserInteraction, true);
                this.controls.el.addEventListener("click", this._onUserInteraction, true);
                this._elementEmitter.on("click", this._onClick);
                if ("onmouseleave" in this.el) {
                    this.controls.el.addEventListener("mouseleave", this._onMouseLeave)
                } else {
                    this.controls.el.addEventListener("mouseout", this._onMouseOut, true)
                }
                if (this._keyboardControl) {
                    this._keyboardControl.on("keyboardinteraction", this._onUserInteraction)
                }
            }
            return this.controls
        };
        proto._onClick = function() {
            this._hasFocus = false
        };
        proto._onMouseLeave = function(evt) {
            window.clearTimeout(this._userInteractionTimeout);
            this._hideControls();
            this._lastMouseCoords = {}
        };
        proto._onMouseOut = function(evt) {
            if (!this.controls.el.contains(evt.target) && evt.target !== this.controls.el) {
                this._onMouseLeave()
            }
        };
        proto._onUserInteraction = function(evt) {
            this.controls.el.classList.remove("hide-cursor");
            if (!this.getCurrentSrc() || this._preventUserInteraction || evt && this._lastMouseCoords.x === evt.screenX && this._lastMouseCoords.y === evt.screenY) {
                return
            }
            if (evt && evt.pageX) {
                this._lastMouseCoords = {
                    x: evt.screenX,
                    y: evt.screenY
                }
            }
            this._showControls();
            window.clearTimeout(this._userInteractionTimeout);
            if (evt && evt.target) {
                if (this._isActiveArea(evt.target)) {
                    return
                }
            }
            this._userInteractionTimeout = window.setTimeout(function() {
                this.controls.el.classList.add("hide-cursor");
                this._hideControls()
            }.bind(this), this.options.controlsTimeoutDuration)
        };
        proto._onPlay = function() {
            if (!IS_SAFARI_OSX) {
                this.once("timeupdate", this._onStart)
            } else {
                this.once("timeupdate", this._onStart, function() {
                    return this.getCurrentTime() > 0
                }.bind(this))
            }
        };
        proto._onStart = function() {
            this.el.classList.add(INITIAL_PLAY_CLASS);
            if (this._poster) {
                this._poster.hide()
            }
            if (this.controls) {
                this._hideStartState();
                this._hideEndState()
            }
            this.once("ended", this._onEnded)
        };
        proto._onEnded = function() {
            if (this.isFullscreen()) {
                this.exitFullscreen()
            }
            if (this.controls) {
                this._hideStartState();
                this._showEndState()
            }
            this.once("timeupdate", this._onStart);
            if (this._poster) {
                this._poster.show()
            }
        };
        proto._initPoster = function(src) {
            this._poster = createPoster({
                player: this,
                video: this._videoImpl,
                useNativePoster: this.options.controls === false,
                is2x: IS_RETINA,
                src: src
            });
            if (this._poster.el) {
                this.el.appendChild(this._poster.el)
            }
            if (!this.options.autoplay) {
                this._poster.show()
            }
        };
        proto._useLiveMode = function() {
            if (this._isLive) {
                this.el.classList.add(LIVE_MODE_CLASS)
            } else {
                this.el.classList.remove(LIVE_MODE_CLASS)
            }
        };
        proto.once = function(eventType, callback, clause) {
            if (arguments.length < 3 || typeof clause === "object") {
                superProto.once.apply(this, arguments)
            } else {
                var args = arguments;
                var clauses = Array.prototype.slice.call(arguments, 2);
                var cb = function() {
                    if (clauses.every(function(fn) {
                            return !!fn()
                        })) {
                        args[1].apply(this, args);
                        this.off(args[0], cb)
                    }
                }.bind(this);
                this.on(args[0], cb)
            }
        };
        proto.getMediaElement = function() {
            return this._videoImpl.getMediaElement()
        };
        proto.play = function() {
            log("play called");
            this._videoImpl.play()
        };
        proto.pause = function() {
            this._videoImpl.pause()
        };
        proto.seek = function(seekPosition) {
            this.setCurrentTime.apply(this, arguments)
        };
        proto.addTextTrack = function(trackObject) {
            this._videoImpl.addTextTrack(trackObject)
        };
        proto.getReadyState = function() {
            return this._videoImpl.getMediaElement().readyState
        };
        proto.getPreload = function() {
            return this._videoImpl.getPreload()
        };
        proto.setPoster = function(url) {
            this._poster.setSrc(url)
        };
        proto.getVolume = function() {
            return this._videoImpl.getVolume()
        };
        proto.getMuted = function() {
            return this._videoImpl.getMuted()
        };
        proto.getCurrentTime = function() {
            return this._videoImpl.getCurrentTime()
        };
        proto.getDuration = function() {
            return this._videoImpl.getDuration()
        };
        proto.getPaused = function() {
            return this._videoImpl.getPaused()
        };
        proto.getEnded = function() {
            return this._videoImpl.getEnded()
        };
        proto.setCurrentTime = function(time) {
            return this._videoImpl.setCurrentTime(time)
        };
        proto.setVolume = function(volume) {
            this.trigger("uservolumechange");
            return this._videoImpl.setVolume(volume)
        };
        proto.setMuted = function(muted) {
            this.trigger("uservolumechange");
            this._videoImpl.setMuted(muted)
        };
        proto.setSrc = function(url) {
            this._videoImpl.setSrc(url)
        };
        proto.getCurrentSrc = function() {
            return this._videoImpl.getCurrentSrc()
        };
        proto.setControls = function(enable) {
            return this._videoImpl.setControls(enable)
        };
        proto.getMediaHeight = function() {
            return this._videoImpl.getMediaElement().videoHeight
        };
        proto.getMediaWidth = function() {
            return this._videoImpl.getMediaElement().videoWidth
        };
        proto.supportsPictureInPicture = function() {
            return this._videoImpl.supportsPictureInPicture()
        };
        proto.isPictureInPicture = function() {
            return this._videoImpl.isPictureInPicture()
        };
        proto.setPictureInPicture = function(enable) {
            return this._videoImpl.setPictureInPicture(enable)
        };
        proto.supportsAirPlay = function() {
            return this._videoImpl.supportsAirPlay()
        };
        proto.refreshSize = function() {
            if (this._breakpointDetect) {
                this._breakpointDetect.refresh()
            } else {
                this._currentBreakpoint && this.el.classList.remove(this._currentBreakpoint.name);
                this._currentBreakpoint = BreakpointDetect.getBreakpointFromElement(this.el, DEFAULT_BREAKPOINTS);
                this.el.classList.add(this._currentBreakpoint.name)
            }
        };
        proto.destroy = function() {
            this._removeEventListeners();
            this._videoImpl.destroy();
            if (this.controls) {
                this.controls.destroy();
                this.controls = null
            }
            this._videoImpl = undefined;
            this.el.innerHTML = "";
            if (this._breakpointDetect) {
                this._breakpointDetect.destroy()
            }
            EventEmitter.prototype.destroy.call(this)
        };
        module.exports = Player
    }, {
        "../dom-emitter/DOMEmitterMicro": 501,
        "../event-emitter-shim/EventEmitterShim": 502,
        "../posterframe/PosterFrameFactory": 510,
        "../ui/DefaultBreakpoints": 519,
        "../ui/KeyboardControl": 521,
        "../utils/BreakpointDetect": 550,
        "../video/VideoFactory": 559,
        "./event/EventsToForward": 505,
        "./event/ReadyStateChangeEvents": 506,
        "@marcom/ac-accessibility/helpers/hide": 408,
        "@marcom/ac-accessibility/helpers/show": 411,
        "@marcom/ac-console/log": 421,
        "@marcom/ac-feature/isDesktop": 161,
        "@marcom/ac-feature/isHandheld": 162,
        "@marcom/ac-feature/isRetina": 163,
        "@marcom/ac-fullscreen": 432,
        "@marcom/ac-useragent": 403
    }],
    505: [function(require, module, exports) {
        "use strict";
        module.exports = ["loadstart", "progress", "suspend", "abort", "error", "emptied", "stalled", "play", "pause", "loadedmetadata", "loadeddata", "waiting", "playing", "canplay", "canplaythrough", "seeking", "seeked", "ended", "ratechange", "durationchange", "volumechange", "addtrack", "change", "removetrack"]
    }, {}],
    506: [function(require, module, exports) {
        "use strict";
        module.exports = ["loadstart", "suspend", "abort", "error", "emptied", "stalled", "loadedmetadata", "loadeddata", "waiting", "canplay", "canplaythrough"]
    }, {}],
    507: [function(require, module, exports) {
        "use strict";
        var Player = require("../Player");
        var IS_DESKTOP = require("@marcom/ac-feature/isDesktop")();
        module.exports = function createPlayer(options) {
            if (!options) {
                options = {}
            } else if (arguments.length > 1) {
                options = Object.assign.apply(null, Array.prototype.slice.apply(arguments))
            }
            if (!options.components) {
                options.components = require("../../ui/DefaultComponents")
            }
            if (typeof options.controls === "undefined") {
                options.controls = true
            }
            if (!options.controlsImplementation) {
                options.controlsImplementation = require("../../ui/ControlBar")
            }
            if (!options.controlsFactory) {
                options.controlsFactory = require("../../ui/ControlsFactory")({
                    controlsImplementation: options.controlsImplementation,
                    components: options.components,
                    template: options.controlsTemplate
                })
            }
            if (typeof options.urlOptimizer !== "undefined" && options.urlOptimizer === true || options.urlOptimizer === "true") {
                options.urlOptimizer = require("../../optimizeVideoUrl")
            }
            if (!options.sources && !options.src) {
                options.sources = []
            } else {
                options.sources = options.sources ? options.sources : options.src ? [options.src] : []
            }
            options.autoplay = options.autoplay !== undefined ? options.autoplay : IS_DESKTOP;
            if (!options.controlsTimeoutDuration) {
                options.controlsTimeoutDuration = 3e3
            }
            var player = new Player(options);
            var metadata = {};
            if (options.sharing) {
                metadata.sharing = Object.assign({}, options.sharing)
            }
            if (options.thumbnails) {
                metadata.thumbnails = Object.assign({}, options.thumbnails)
            }
            if (options.sources && options.sources.length) {
                player.load(options.sources, options.textTracks, options.startTime, metadata)
            }
            return player
        }
    }, {
        "../../optimizeVideoUrl": 503,
        "../../ui/ControlBar": 517,
        "../../ui/ControlsFactory": 518,
        "../../ui/DefaultComponents": 520,
        "../Player": 504,
        "@marcom/ac-feature/isDesktop": 161
    }],
    508: [function(require, module, exports) {
        "use strict";
        var createPlayer = require("./createPlayer");
        module.exports = function createSharablePlayer(options) {
            if (arguments.length > 1) {
                options = Object.assign.apply(null, Array.prototype.slice.apply(arguments))
            }
            if (options.localizationBasePath) {
                options.sharing.basePath = options.localizationBasePath
            }
            return createPlayer(options)
        }
    }, {
        "./createPlayer": 507
    }],
    509: [function(require, module, exports) {
        "use strict";
        var POSTER_CLASS = "ac-video-poster";
        var POSTER_HIDDEN_CLASS = "ac-video-poster-hide";
        var PosterFrame = function(options) {
            this._initialize(options)
        };
        var proto = PosterFrame.prototype;
        proto._initialize = function(options) {
            var source = options.src;
            this.el = options.el || document.createElement("div");
            this._imgElement = document.createElement("img");
            this._imgElement.src = source;
            this._imgElement.alt = "";
            this.el.appendChild(this._imgElement);
            this.el.classList.add(POSTER_CLASS)
        };
        proto.hide = function() {
            this.el.classList.add(POSTER_HIDDEN_CLASS)
        };
        proto.show = function() {
            this.el.classList.remove(POSTER_HIDDEN_CLASS)
        };
        proto.setSrc = function(src) {
            this._imgElement.src = src
        };
        module.exports = PosterFrame
    }, {}],
    510: [function(require, module, exports) {
        "use strict";
        var PosterFrame = require("./PosterFrame");
        var DEFAULT_SRC = {
            "1x": "/ac/ac-video-posterframe/1.0/images/ac-video-poster_848x480.jpg",
            "2x": "/ac/ac-video-posterframe/1.0/images/ac-video-poster_848x480_2x.jpg"
        };
        module.exports = function createPosterFrame(options) {
            options.src = options.src || (options.is2x ? DEFAULT_SRC["2x"] : DEFAULT_SRC["1x"]);
            if (!options.useNativePoster) {
                return new PosterFrame(options)
            } else {
                options.video.setPoster(options.src);
                var showing = false;
                var cachedUrl;
                return {
                    show: function() {
                        showing = true;
                        if (cachedUrl) {
                            options.video.setPoster(cachedUrl);
                            cachedUrl = null
                        }
                    },
                    hide: function() {
                        showing = false
                    },
                    setSrc: function(src) {
                        if (!showing) {
                            cachedUrl = src
                        } else {
                            options.video.setPoster(src)
                        }
                    }
                }
            }
        }
    }, {
        "./PosterFrame": 509
    }],
    511: [function(require, module, exports) {
        "use strict";
        var http = require("@marcom/ac-ajax-xhr");
        var throttle = require("@marcom/ac-function/throttle");
        var parseVTT = require("./parseVTT");
        var TextTracksBehavior = function(view, options) {
            this._view = view;
            this._video = options.video;
            this._refreshTracks = this._refreshTracks.bind(this);
            this._throttledRefreshCurrentCaption = throttle(this._refreshCurrentCaption.bind(this), 300);
            this._addTrackListeners()
        };
        var proto = TextTracksBehavior.prototype;
        proto._addTrackListeners = function() {
            this._video.on("addtrack", this._refreshTracks);
            this._video.on("removetrack", this._refreshTracks);
            this._video.on("change", this._refreshTracks)
        };
        proto._addVideoListeners = function(track) {
            if (!track.cues) {
                this._view.setText("");
                try {
                    return http.get(track.src, {
                        complete: function(response) {
                            track.cues = parseVTT(response.responseText);
                            this._addVideoListeners(track);
                            this._refreshCurrentCaption()
                        }.bind(this),
                        error: function(error) {}.bind(this)
                    })
                } catch (e) {}
            }
            this._video.on("loadstart", this._refreshTracks);
            this._video.on("timeupdate", this._throttledRefreshCurrentCaption)
        };
        proto._removeVideoListeners = function() {
            this._video.off("loadstart", this._refreshTracks);
            this._video.off("timeupdate", this._throttledRefreshCurrentCaption)
        };
        proto._refreshTracks = function() {
            var tracks = this._video.getTextTracks();
            if (tracks && tracks.length) {
                tracks = tracks.filter(function(t) {
                    return t.mode === "showing"
                })
            }
            if (tracks.length) {
                this._activeTrack = tracks[0];
                this._addVideoListeners(this._activeTrack)
            } else {
                this._activeTrack = null;
                this._removeVideoListeners()
            }
            this._refreshCurrentCaption()
        };
        proto._getCurrentCaptionText = function(time) {
            var cues = this._activeTrack ? this._activeTrack.cues : null;
            if (!cues) {
                return ""
            } else if (this._currentCaption && this._currentCaption.startTime >= time && this._currentCaption <= time) {
                return this._currentCaption.text
            }
            var i = 0;
            var len = cues.length;
            var closest;
            while (i < len) {
                if (cues[i].startTime <= time && cues[i].endTime >= time) {
                    closest = cues[i]
                } else if (cues[i].startTime >= time) {
                    break
                }
                i++
            }
            this._currentCaption = closest;
            return closest ? closest.text : ""
        };
        proto._refreshCurrentCaption = function() {
            this._view.setText(this._getCurrentCaptionText(this._video.getCurrentTime()))
        };
        proto.destroy = function() {
            this._removeVideoListeners()
        };
        module.exports = TextTracksBehavior
    }, {
        "./parseVTT": 516,
        "@marcom/ac-ajax-xhr": 414,
        "@marcom/ac-function/throttle": 439
    }],
    512: [function(require, module, exports) {
        "use strict";
        var createComponents = require("../ui/factory/createComponents");
        var TextTracksBehavior = require("./TextTracksBehavior");
        var Label = require("../ui/elements/Label");
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var TEMPLATE = '<div class="ac-video-player-text-track"></div>';
        var VISIBLE_CLASS = "is-visible";
        var CONTAINER_CLASS = "ac-video-player-text-track-container";
        var COMPONENTS_DEFINITION = {
            textTracksPolyfill: {
                className: "ac-video-player-text-track",
                view: {
                    classDef: Label,
                    options: {}
                },
                behavior: {
                    classDef: TextTracksBehavior
                }
            }
        };
        var TextTracksDOM = function(options) {
            EventEmitterMicro.call(this);
            this.container = options.container;
            this._video = options.video;
            this._initialize(options)
        };
        var proto = TextTracksDOM.prototype = Object.create(EventEmitterMicro.prototype);
        proto._initialize = function(options) {
            this._onTrackChange = this._onTrackChange.bind(this);
            this.el = document.createElement("div");
            this.el.innerHTML = options.template || TEMPLATE;
            this.el.classList.add(CONTAINER_CLASS);
            this._tracks = options.tracks || [];
            this._textTrackComponent = createComponents(this.el, COMPONENTS_DEFINITION, {
                video: this._video
            })
        };
        proto._onTrackChange = function() {
            this.trigger("change");
            if (!this.el.parentElement) {
                this._video.el.parentElement.appendChild(this.el);
                this.el.firstElementChild.classList.add(VISIBLE_CLASS)
            }
        };
        proto.addTrack = function(textTrack) {
            if (!this._tracks) {
                this._tracks = []
            }
            var mode = textTrack.mode || "hidden";
            var onChange = this._onTrackChange;
            Object.defineProperty(textTrack, "mode", {
                get: function() {
                    return mode
                },
                set: function(newValue) {
                    mode = newValue;
                    onChange()
                },
                enumerable: true,
                configurable: true
            });
            this._tracks.push(textTrack);
            this.trigger("addtrack")
        };
        proto.clearTracks = function() {
            this._tracks = [];
            this.trigger("removetrack");
            this.trigger("change")
        };
        proto.getTextTracks = function() {
            return this._tracks
        };
        proto.trigger = function(eventName, data) {
            return EventEmitterMicro.prototype.trigger.call(this, eventName, Object.assign({
                type: eventName
            }, data || {}))
        };
        proto.destroy = function() {
            this._textTrackComponent.destroy();
            EventEmitterMicro.prototype.destroy.call(this)
        };
        module.exports = TextTracksDOM
    }, {
        "../ui/elements/Label": 536,
        "../ui/factory/createComponents": 541,
        "./TextTracksBehavior": 511,
        "@marcom/ac-event-emitter-micro": 422
    }],
    513: [function(require, module, exports) {
        "use strict";
        var userAgent = require("@marcom/ac-useragent");
        var setTextTrackMode;
        if (userAgent.browser.safari) {
            setTextTrackMode = function(track, mode) {
                track.track.mode = mode
            }
        } else {
            setTextTrackMode = function(track, mode) {
                track.mode = mode
            }
        }
        var addTextTrackTag = function(textTrack) {
            var index;
            if (textTrack instanceof HTMLElement) {
                return this._videoElement.appendChild(textTrack)
            }
            var track = document.createElement("track");
            track.src = textTrack.src;
            track.kind = "captions";
            track.srclang = textTrack.srclang;
            if (track.srclang === "en") {
                track.label = "English"
            }
            if (userAgent.browser.firefox) {
                index = this._videoElement.textTracks.length;
                setTimeout(function() {
                    this._videoElement.appendChild(track);
                    setTextTrackMode(this._videoElement.textTracks[index], textTrack.mode || "hidden")
                }.bind(this), 0)
            } else if (userAgent.os.android) {
                index = this._videoElement.textTracks.length;
                this._videoElement.appendChild(track);
                setTextTrackMode(this._videoElement.textTracks[index], textTrack.mode || "hidden")
            } else {
                this._videoElement.appendChild(track);
                setTextTrackMode(track, textTrack.mode || "hidden")
            }
        };
        var getTracks = function() {
            return this._videoElement.textTracks
        };
        var getEmitter = function() {
            if (!this._textTracksEmitter) {
                var DOMEmitter = require("../dom-emitter/DOMEmitterMicro");
                this._textTracksEmitter = new DOMEmitter(this.getTextTracks())
            }
            return this._textTracksEmitter
        };
        var createTextTrackTags = function(textTracks) {
            var i = 0;
            var len = textTracks ? textTracks.length : 0;
            for (; i < len; i++) {
                var track = textTracks[i];
                addTextTrackTag.call(this, track)
            }
        };
        var destroy = function() {};
        module.exports = {
            create: createTextTrackTags,
            add: addTextTrackTag,
            get: getTracks,
            getEmitter: getEmitter,
            destroy: destroy
        }
    }, {
        "../dom-emitter/DOMEmitterMicro": 501,
        "@marcom/ac-useragent": 403
    }],
    514: [function(require, module, exports) {
        "use strict";
        var TextTracksDOM = require("./TextTracksDOM");
        var createTextTrackPolyfill = function(textTracks) {
            if (!textTracks) {
                return
            }
            if (!this._textTracksPolyfill) {
                this._textTracksPolyfill = new TextTracksDOM({
                    video: this,
                    tracks: textTracks,
                    container: this._parentElement
                })
            } else {
                this._textTracksPolyfill.clearTracks();
                var i = 0;
                var len = textTracks.length;
                for (; i < len; i++) {
                    this._textTracksPolyfill.addTrack(textTracks[i])
                }
            }
        };
        var addTextTrackTag = function(textTrack) {
            return this._textTracksPolyfill.addTrack(textTrack)
        };
        var getTracks = function() {
            if (!this._textTracksPolyfill) {
                this._createTextTrackTags([])
            }
            return this._textTracksPolyfill.getTextTracks()
        };
        var getEmitter = function() {
            if (!this._textTracksPolyfill) {
                this._createTextTrackTags([])
            }
            return this._textTracksPolyfill
        };
        var destroy = function() {
            this._textTracksPolyfill.destroy();
            this._textTracksPolyfill = null
        };
        module.exports = {
            create: createTextTrackPolyfill,
            add: addTextTrackTag,
            get: getTracks,
            getEmitter: getEmitter,
            destroy: destroy
        }
    }, {
        "./TextTracksDOM": 512
    }],
    515: [function(require, module, exports) {
        "use strict";
        var ac_userAgent = require("@marcom/ac-useragent");
        var SUPPORTS_NATIVE_CAPTIONS = !ac_userAgent.browser.ie && !ac_userAgent.browser.edge;
        module.exports = function createTextTracks(options) {
            options = options || {};
            var useNative = typeof options.useNativeCaptions === "undefined" ? SUPPORTS_NATIVE_CAPTIONS : options.useNativeCaptions;
            return useNative ? require("./TextTracksNative") : require("./TextTracksPolyfill")
        }
    }, {
        "./TextTracksNative": 513,
        "./TextTracksPolyfill": 514,
        "@marcom/ac-useragent": 403
    }],
    516: [function(require, module, exports) {
        "use strict";
        var Time = require("../utils/Time");
        module.exports = function parseVTT(captionsData) {
            var fileContents = captionsData.split(/\n/);
            var timeIdentifyer = /([\d]{2}:)?[\d]{2}:[\d]{2}.[\d]{3}( \-\-> ){1}([\d]{2}:)?[\d]{2}:[\d]{2}.[\d]{3}/;
            var returnData = [];
            var timeMarkers;
            var text;
            var i = 0;
            var len = fileContents.length;
            for (i; i < len; i++) {
                text = "";
                if (timeIdentifyer.test(fileContents[i])) {
                    timeMarkers = fileContents[i].split(" --\x3e ");
                    timeMarkers[0] = timeMarkers[0].split(":").length < 3 ? "00:" + timeMarkers[0] : timeMarkers[0];
                    timeMarkers[1] = timeMarkers[1].split(":").length < 3 ? "00:" + timeMarkers[1] : timeMarkers[1];
                    while (++i && i < len && !timeIdentifyer.test(fileContents[i])) {
                        if (fileContents[i] !== "") {
                            text += fileContents[i] + "<br />"
                        }
                    }
                    text = text.substr(0, text.length - 6);
                    if (i < len) {
                        i--
                    }
                    returnData.push({
                        startTime: Time.stringToNumber(timeMarkers[0].split(" ")[0]),
                        endTime: Time.stringToNumber(timeMarkers[1].split(" ")[0]),
                        text: text
                    })
                }
            }
            return returnData
        }
    }, {
        "../utils/Time": 551
    }],
    517: [function(require, module, exports) {
        "use strict";
        var supplant = require("@marcom/ac-string/supplant");
        var Time = require("../utils/Time");
        var Localization = require("./localization/Localization");
        var createComponents = require("./factory/createComponents");
        var DEFAULT_CLASS_NAME = "ac-video-controls";
        var DEFAULT_SKIN = "control-bar-skin-default";
        var IS_DESKTOP = require("@marcom/ac-feature/isDesktop")();
        var OverlayContainer = require("./overlays/OverlayContainer");
        var merge = require("../utils/merge");
        var ControlBar = function(options) {
            this._initialize(options)
        };
        var proto = ControlBar.prototype;
        proto._initialize = function(options) {
            this.el = options.element || document.createElement("div");
            this._basePath = options.basePath;
            this.el.style.display = "none";
            this._template = options.template || '<div class="controls-container" >\n\n\t<div class="{elementClassPrefix}-social-tray hidden"></div>\n\n\t<div class="center-button-container {elementClassPrefix}-play-pause-button-container">\n\t\t<div class="button-wrapper">\n\t\t\t<button type="button" class="ac-video-icon centered-button {elementClassPrefix}-play-pause-button {elementClassPrefix}-button no-autoplay" value="{playpause}" aria-label="{playpause}" role="button" tabindex="0" data-acv-active-area></button>\n\t\t</div>\n\t</div>\n\n\t<div class="main-controls-container" >\n\t\t<div class="ac-video-overlay-container" ></div>\n\t\t<div class="main-controls">\n\t\t\t<div class="button-wrapper">\n\t\t\t\t<div class="main-controls-item controls-volume">\n\t\t\t\t\t<button type="button" class="ac-video-icon {elementClassPrefix}-toggle-mute-volume-button {elementClassPrefix}-button" value="{togglemutevolume}" aria-label="{togglemutevolume}" role="button" tabindex="0" data-acv-active-area></button>\n\t\t\t\t\t<div class="{elementClassPrefix}-volume-level-indicator" tabindex="0" aria-valuemin="0" aria-valuemax="100" min="0" max="100" aria-label="{adjustvolume}" role="slider" aria-orientation="vertical" step="0.05" data-acv-active-area></div>\n\t\t\t\t</div>\n\t\t\t</div>\n\n\t\t\t<div class="button-wrapper">\n\t\t\t\t<button type="button" class="ac-video-icon main-controls-item {elementClassPrefix}-text-tracks-toggle-button {elementClassPrefix}-button no-text-tracks" value="{captionscontrol}" aria-label="{captionscontrol}" role="button" tabindex="0" data-acv-active-area></button>\n\t\t\t</div>\n\n\t\t\t<div class="main-controls-item controls-progress">\n\t\t\t\t<div class="controls-progress-time controls-progress-time-1">\n\t\t\t\t\t<div class="{elementClassPrefix}-elapsed-time-indicator" role="text" tabindex="-1">\n\t\t\t\t\t\t<span class="label">{elapsed}</span>\n\t\t\t\t\t\t<span class="{elementClassPrefix}-elapsed-time">00:00</span>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t<div class="controls-progress-bar">\n\t\t\t\t\t<div class="{elementClassPrefix}-buffered-indicator"></div>\n\t\t\t\t\t<div class="{elementClassPrefix}-progress-indicator ac-slider-inactive" aria-label="progress-indicator" role="slider" precision="float" min="0" max="{max}" step="0.0005" value="0" tabindex="0" aria-valuemax="{max}" aria-valuemin="{min}" aria-valuenow="{value}" data-acv-active-area></div>\n\t\t\t\t</div>\n\t\t\t\t<div class="controls-progress-time controls-progress-time-2">\n\t\t\t\t\t<div class="{elementClassPrefix}-remaining-time-indicator" role="text" tabindex="-1">\n\t\t\t\t\t\t<span class="label">{remaining}</span>\n\t\t\t\t\t\t<span class="{elementClassPrefix}-remaining-time">-00:00</span>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t\n\t\t\t<div class="main-controls-item live-stream">\n\t\t\t\t<span class="live-stream-text">{livestream}</span>\n\t\t\t</div>\n\n\t\t\t<div class="button-wrapper">\n\t\t\t\t<button type="button" class="ac-video-icon main-controls-item {elementClassPrefix}-airplay-button {elementClassPrefix}-button airplay-unsupported" value="{airplay}" aria-label="{airplay}" role="button" tabindex="0" data-acv-active-area></button>\n\t\t\t</div>\n\n\t\t\t<div class="button-wrapper">\n\t\t\t\t<button type="button" class="ac-video-icon main-controls-item {elementClassPrefix}-picture-in-picture-button {elementClassPrefix}-button picture-in-picture-unsupported" value="{pictureinpicture}" aria-label="{pictureinpicture}" role="button" tabindex="0" data-acv-active-area></button>\n\t\t\t</div>\n\n\t\t\t<div class="button-wrapper">\n\t\t\t\t<button type="button" class="ac-video-icon main-controls-item {elementClassPrefix}-full-screen-button {elementClassPrefix}-button fullscreen-unsupported" value="{fullscreen}" aria-label="{fullscreen}" role="button" tabindex="0" data-acv-active-area></button>\n\t\t\t</div>\n\t\t</div>\n\t</div>\n</div>\n';
            this._templateData = options.templateData || Object.assign({
                elementClassPrefix: "controls"
            });
            this._destroyed = false;
            this._localize().then(function() {
                if (!this._destroyed) {
                    this._initUIComponents(options);
                    this.el.style.display = ""
                }
                if (typeof options.readyCallback === "function") {
                    options.readyCallback()
                }
            }.bind(this))
        };
        proto._localize = function() {
            return new Promise(function(resolve) {
                Localization.getTranslation({
                    callback: function(response) {
                        resolve(response)
                    }.bind(this),
                    basePath: this._basePath
                })
            }.bind(this)).then(function(response) {
                this._templateData = Object.assign(this._templateData, response)
            }.bind(this))
        };
        proto._renderTemplateMarkup = function() {
            var supplantedTemplate = supplant(this._template, this._templateData);
            this.el.innerHTML = supplantedTemplate
        };
        proto._initDesktopControls = function(rootElement, components) {
            this._componentCollection = createComponents(rootElement, merge(components, {
                elementClassPrefix: this._templateData.elementClassPrefix,
                elapsedTimeIndicator: {
                    behavior: {
                        observe: {
                            source: this._player,
                            events: ["timeupdate", "seeking", "seeked", "durationchange"],
                            update: function(view) {
                                view.setText(Time.formatTime(this._player.getCurrentTime(), this._player.getDuration()))
                            }.bind(this)
                        }
                    }
                },
                remainingTimeIndicator: {
                    behavior: {
                        observe: {
                            source: this._player,
                            events: ["timeupdate", "seeking", "seeked", "durationchange"],
                            update: function(view) {
                                view.setText(Time.formatTime(this._player.getCurrentTime() - this._player.getDuration(), this._player.getDuration()))
                            }.bind(this)
                        }
                    }
                },
                volumeLevel: {
                    view: {
                        options: {
                            value: this._player.getMuted() ? 0 : this._player.getVolume() * 100
                        }
                    }
                },
                playPauseContainer: {
                    view: {
                        options: {
                            labels: {
                                playing: this._templateData.pause,
                                paused: this._templateData.play,
                                ended: this._templateData.replay
                            }
                        }
                    }
                },
                fullScreen: {
                    view: {
                        options: {
                            labels: {
                                initial: this._templateData.fullscreen,
                                on: this._templateData.exitfullscreen,
                                off: this._templateData.fullscreen
                            }
                        }
                    }
                },
                pictureInPictureToggle: {
                    view: {
                        options: {
                            labels: {
                                initial: this._templateData.pictureinpicture,
                                on: this._templateData.exitpictureinpicture,
                                off: this._templateData.pictureinpicture
                            }
                        }
                    }
                }
            }), {
                player: this._player,
                localization: this._templateData
            })
        };
        proto._initUIComponents = function(options) {
            this._player = options.player;
            var rootElement = this.el;
            var components = options.components;
            rootElement.classList.add(options.className || DEFAULT_CLASS_NAME);
            this._renderTemplateMarkup();
            var mainControlsContainer = rootElement.querySelector(".main-controls-container");
            if (!IS_DESKTOP) {
                mainControlsContainer.parentElement.removeChild(mainControlsContainer)
            } else {
                mainControlsContainer.classList.add(DEFAULT_SKIN);
                this.mainControlsElement = mainControlsContainer
            }
            this._initDesktopControls(rootElement, components);
            this.sharingModule = this._componentCollection.components["socialShare"][0].behavior.sharingModule;
            if (this._componentCollection.components["progressBar"].length) {
                this.scrubberView = this._componentCollection.components["progressBar"][0].view
            }
            this.playButtonElement = this.el.querySelector(".controls-play-pause-button");
            if (IS_DESKTOP) {
                this.overlays = new OverlayContainer({
                    el: this.el.querySelector(".ac-video-overlay-container"),
                    player: this._player
                })
            }
        };
        proto._setVolume = function(level) {
            if (level) {
                this._player.setMuted(false)
            }
            this._player.setVolume(level)
        };
        proto._thirySecondsBack = function() {
            var currentTime = this._player.getCurrentTime();
            var newTime = currentTime - 30;
            this._player.setCurrentTime(newTime < 0 ? 0 : newTime)
        };
        proto.destroy = function() {
            if (this._componentCollection) {
                this._componentCollection.destroy();
                this._componentCollection = null
            }
            this._destroyed = true;
            this._player = null;
            this._templateData = null
        };
        module.exports = ControlBar
    }, {
        "../utils/Time": 551,
        "../utils/merge": 552,
        "./factory/createComponents": 541,
        "./localization/Localization": 544,
        "./overlays/OverlayContainer": 546,
        "@marcom/ac-feature/isDesktop": 161,
        "@marcom/ac-string/supplant": 402
    }],
    518: [function(require, module, exports) {
        "use strict";
        var DEFAULTS = {
            components: require("./DefaultComponents"),
            controlsImplementation: require("./ControlBar")
        };
        var ControlsFactory = function(options) {
            options = options || {};
            var combinedOptions = Object.assign({}, DEFAULTS, options);
            return {
                create: function(controlsOptions) {
                    var opts = Object.assign({}, combinedOptions, controlsOptions);
                    opts.components = options.components || DEFAULTS.components;
                    return new opts.controlsImplementation(opts)
                }
            }
        };
        module.exports = ControlsFactory
    }, {
        "./ControlBar": 517,
        "./DefaultComponents": 520
    }],
    519: [function(require, module, exports) {
        "use strict";
        module.exports = [{
            name: "small",
            minWidth: 0,
            maxWidth: 479
        }, {
            name: "medium",
            minWidth: 480,
            maxWidth: 779
        }, {
            name: "large",
            minWidth: 780,
            maxWidth: Infinity
        }]
    }, {}],
    520: [function(require, module, exports) {
        "use strict";
        var Button = require("./elements/Button");
        var StatefulButton = require("./elements/StatefulButton");
        var Label = require("./elements/Label");
        var Slider = require("./elements/Slider");
        var Container = require("./elements/Container");
        var MuteButtonBehavior = require("./behaviors/MuteButtonBehavior");
        var PlayPauseButtonBehavior = require("./behaviors/PlayPauseButtonBehavior");
        var PictureInPictureButtonBehavior = require("./behaviors/PictureInPictureButtonBehavior");
        var CaptionsButtonBehavior = require("./behaviors/CaptionsButtonBehavior");
        var FullScreenButtonBehavior = require("./behaviors/FullScreenButtonBehavior");
        var ProgressBarSliderBehavior = require("./behaviors/ProgressBarSliderBehavior");
        var VolumeSliderBehavior = require("./behaviors/VolumeSliderBehavior");
        var SharingButtonBehavior = require("./behaviors/SharingButtonBehavior");
        var SocialContainerBehavior = require("./behaviors/SocialContainerBehavior");
        var AirPlayButtonBehavior = require("./behaviors/AirPlayButtonBehavior");
        var CursorPointer = require("./elements/mixins/CursorPointer");
        module.exports = {
            back30Seconds: {
                className: "back-30-seconds-button",
                view: {
                    classDef: Button
                }
            },
            fullScreen: {
                className: "full-screen-button",
                view: {
                    classDef: StatefulButton,
                    options: {
                        states: {
                            initial: "fullscreen-unsupported",
                            on: "is-fullscreen",
                            off: ""
                        },
                        labels: {
                            initial: "fullscreen",
                            on: "exitfullscreen",
                            off: "fullscreen"
                        }
                    }
                },
                behavior: {
                    classDef: FullScreenButtonBehavior
                }
            },
            toggleMuteVolume: {
                className: "toggle-mute-volume-button",
                view: {
                    classDef: StatefulButton,
                    options: {
                        states: {
                            initial: [],
                            on: ["is-muted"],
                            off: []
                        }
                    }
                },
                behavior: {
                    classDef: MuteButtonBehavior
                }
            },
            playPauseContainer: {
                className: "play-pause-button-container",
                view: {
                    classDef: StatefulButton,
                    options: {
                        states: {
                            playing: ["is-playing"],
                            paused: [],
                            ended: ["is-ended"]
                        }
                    }
                },
                behavior: {
                    classDef: PlayPauseButtonBehavior
                }
            },
            pictureInPictureToggle: {
                className: "picture-in-picture-button",
                view: {
                    classDef: StatefulButton,
                    options: {
                        states: {
                            initial: ["picture-in-picture-unsupported"],
                            on: ["is-picture-in-picture"],
                            off: []
                        },
                        labels: {
                            initial: "pictureinpicture",
                            on: "exitpictureinpicture",
                            off: "pictureinpicture"
                        }
                    }
                },
                behavior: {
                    classDef: PictureInPictureButtonBehavior
                }
            },
            captionsToggle: {
                className: "text-tracks-toggle-button",
                view: {
                    classDef: StatefulButton,
                    options: {
                        states: {
                            initial: ["no-text-tracks"],
                            on: ["text-tracks-visible"],
                            off: []
                        }
                    }
                },
                behavior: {
                    classDef: CaptionsButtonBehavior
                }
            },
            airplayToggle: {
                className: "airplay-button",
                view: {
                    classDef: StatefulButton,
                    options: {
                        states: {
                            initial: ["airplay-unsupported"],
                            on: ["airplay-active"],
                            off: []
                        }
                    }
                },
                behavior: {
                    classDef: AirPlayButtonBehavior
                }
            },
            elapsedTimeIndicator: {
                className: "elapsed-time",
                view: {
                    classDef: Label
                }
            },
            remainingTimeIndicator: {
                className: "remaining-time",
                view: {
                    classDef: Label
                }
            },
            progressBar: {
                className: "progress-indicator",
                view: {
                    classDef: Slider,
                    options: {
                        template: '<div class="ac-slider-runnable-track">\n\t<div class="ac-slider-hover-track">\n\t\t<div class="ac-slider-hover-notch"></div>\n\t</div>\n\t<div class="ac-slider-thumb">\n\t\t<div class="ac-slider-thumb-background-wrapper">\n\t\t\t<div class="ac-slider-thumb-background"></div>\n\t\t</div>\n\t</div>\n\t<div class="ac-slider-inner-track">\n\t\t<div class="ac-slider-scrubbed"></div>\n\t</div>\n</div>',
                        min: 0,
                        max: 1,
                        mixins: [CursorPointer],
                        orientation: "horizontal"
                    }
                },
                behavior: {
                    classDef: ProgressBarSliderBehavior
                }
            },
            volumeLevel: {
                className: "volume-level-indicator",
                view: {
                    classDef: Slider,
                    options: {
                        template: '<div class="ac-slider-runnable-track">\n\t<div class="ac-slider-background"></div>\n\t<div class="ac-slider-thumb-wrapper">\n\t\t<div class="ac-slider-thumb">\n\t\t\t<div class="ac-slider-thumb-background-wrapper">\n\t\t\t\t<div class="ac-slider-thumb-background"></div>\n\t\t\t</div>\n\t\t</div>\n\t</div>\n\t<div class="ac-slider-inner-track">\n\t\t<div class="ac-slider-scrubbed"></div>\n\t</div>\n</div>',
                        min: 0,
                        max: 100,
                        mixins: [CursorPointer],
                        orientation: "vertical"
                    }
                },
                behavior: {
                    classDef: VolumeSliderBehavior
                }
            },
            sharing: {
                className: "sharing-button",
                view: {
                    classDef: StatefulButton,
                    options: {
                        states: {
                            initial: ["sharing-unsupported"],
                            on: ["is-sharing"],
                            off: []
                        }
                    }
                },
                behavior: {
                    classDef: SharingButtonBehavior
                }
            },
            socialShare: {
                className: "social-tray",
                view: {
                    classDef: Container,
                    options: {}
                },
                behavior: {
                    classDef: SocialContainerBehavior
                }
            }
        }
    }, {
        "./behaviors/AirPlayButtonBehavior": 522,
        "./behaviors/CaptionsButtonBehavior": 525,
        "./behaviors/FullScreenButtonBehavior": 526,
        "./behaviors/MuteButtonBehavior": 527,
        "./behaviors/PictureInPictureButtonBehavior": 528,
        "./behaviors/PlayPauseButtonBehavior": 529,
        "./behaviors/ProgressBarSliderBehavior": 530,
        "./behaviors/SharingButtonBehavior": 531,
        "./behaviors/SocialContainerBehavior": 532,
        "./behaviors/VolumeSliderBehavior": 533,
        "./elements/Button": 534,
        "./elements/Container": 535,
        "./elements/Label": 536,
        "./elements/Slider": 537,
        "./elements/StatefulButton": 538,
        "./elements/mixins/CursorPointer": 539
    }],
    521: [function(require, module, exports) {
        "use strict";
        var Keyboard = require("@marcom/ac-keyboard/Keyboard");
        var EventEmitter = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var SPACE = 32;
        var LEFT = 37;
        var UP = 38;
        var RIGHT = 39;
        var DOWN = 40;
        var KeyboardControl = function(options) {
            EventEmitter.call(this);
            this._player = options.player;
            this._target = options.keyboardTarget || this._player.el;
            this._keyboard = new Keyboard(this._target);
            this._addEventListeners()
        };
        var superProto = EventEmitter.prototype;
        var proto = KeyboardControl.prototype = Object.create(superProto);
        proto._addEventListeners = function() {
            this._onLeftArrow = this._onLeftArrow.bind(this);
            this._onRightArrow = this._onRightArrow.bind(this);
            this._onUpArrow = this._onUpArrow.bind(this);
            this._onDownArrow = this._onDownArrow.bind(this);
            this._onSpaceBarUp = this._onSpaceBarUp.bind(this);
            this._onSpaceBarDown = this._onSpaceBarDown.bind(this);
            this._onKeyboardInteraction = this._onKeyboardInteraction.bind(this);
            this._onDurationChange = this._onDurationChange.bind(this);
            this._boundKeyboardInteraction = {};
            [SPACE, LEFT, RIGHT, UP, DOWN].forEach(function(evtName) {
                this._boundKeyboardInteraction[evtName] = this._onKeyboardInteraction.bind(this, evtName);
                this._keyboard.onDown(evtName, this._boundKeyboardInteraction[evtName])
            }.bind(this));
            this._keyboard.onDown(SPACE, this._onSpaceBarDown);
            this._keyboard.onDown(LEFT, this._onLeftArrow);
            this._keyboard.onDown(RIGHT, this._onRightArrow);
            this._keyboard.onDown(UP, this._onUpArrow);
            this._keyboard.onDown(DOWN, this._onDownArrow);
            this._player.on("durationchange", this._onDurationChange)
        };
        proto._onKeyboardInteraction = function() {
            this.trigger("keyboardinteraction")
        };
        proto._onDurationChange = function() {
            var duration = this._player.getDuration();
            if (duration >= 60) {
                this._interval = 10
            } else if (duration >= 20) {
                this._interval = 5
            } else {
                this._interval = 1
            }
        };
        proto._onLeftArrow = function(evt) {
            evt.originalEvent.preventDefault();
            evt.originalEvent.stopPropagation();
            var currentTime = this._player.getCurrentTime();
            if (!isNaN(currentTime)) {
                this._player.seek(Math.max(currentTime - this._interval, 0))
            }
        };
        proto._onRightArrow = function(evt) {
            evt.originalEvent.preventDefault();
            evt.originalEvent.stopPropagation();
            var currentTime = this._player.getCurrentTime();
            if (!isNaN(currentTime)) {
                this._player.seek(Math.min(currentTime + this._interval, this._player.getDuration()))
            }
        };
        proto._onUpArrow = function(evt) {
            evt.originalEvent.preventDefault();
            evt.originalEvent.stopPropagation();
            var volume = this._player.getMuted() ? 0 : this._player.getVolume();
            var newValue = Math.min(1, volume + .1);
            this._player.setVolume(newValue);
            this._player.setMuted(false)
        };
        proto._onDownArrow = function(evt) {
            evt.originalEvent.preventDefault();
            evt.originalEvent.stopPropagation();
            var volume = this._player.getMuted() ? 0 : this._player.getVolume();
            var newValue = Math.max(0, volume - .1);
            this._player.setVolume(newValue);
            this._player.setMuted(Math.round(newValue * 10) === 0)
        };
        proto._onSpaceBarDown = function(evt) {
            if (evt.target.tagName === "BUTTON") {
                return
            }
            this._keyboard.offDown(SPACE, this._onSpaceBarDown);
            this._keyboard.onUp(SPACE, this._onSpaceBarUp)
        };
        proto._onSpaceBarUp = function() {
            this._keyboard.offUp(SPACE, this._onSpaceBarUp);
            if (this._player.getPaused()) {
                this._player.play()
            } else {
                this._player.pause()
            }
            this._keyboard.onDown(SPACE, this._onSpaceBarDown)
        };
        proto.destroy = function() {
            [SPACE, LEFT, RIGHT, UP, DOWN].forEach(function(evtName) {
                this._keyboard.offDown(evtName, this._boundKeyboardInteraction[evtName])
            }.bind(this));
            this._boundKeyboardInteraction = null;
            this._keyboard.offDown(SPACE, this._onSpaceBarDown);
            this._keyboard.offUp(SPACE, this._onSpaceBarUp);
            this._keyboard.offDown(LEFT, this._onLeftArrow);
            this._keyboard.offDown(RIGHT, this._onRightArrow);
            this._keyboard.offDown(UP, this._onUpArrow);
            this._keyboard.offDown(DOWN, this._onDownArrow);
            this._player.off("durationchange", this._onDurationChange);
            this._keyboard.destroy();
            superProto.destroy.call(this)
        };
        module.exports = KeyboardControl
    }, {
        "@marcom/ac-event-emitter-micro": 422,
        "@marcom/ac-keyboard/Keyboard": 442
    }],
    522: [function(require, module, exports) {
        "use strict";
        var ButtonBehavior = require("./ButtonBehavior");
        var AirPlayButtonBehavior = function(view, options) {
            ButtonBehavior.apply(this, arguments);
            if (this._player.supportsAirPlay()) {
                this._airplayStateChange = this._airplayStateChange.bind(this);
                this._player.getMediaElement().addEventListener("webkitplaybacktargetavailabilitychanged", this._airplayStateChange);
                this._updateState = this._updateState.bind(this);
                this._player.getMediaElement().addEventListener("webkitcurrentplaybacktargetiswirelesschanged", this._updateState)
            }
        };
        var superProto = ButtonBehavior.prototype;
        var proto = AirPlayButtonBehavior.prototype = Object.create(superProto);
        proto._airplayStateChange = function(evt) {
            if (evt.availability === "available") {
                this._airplayAvailable = true
            } else {
                this._airplayAvailable = false
            }
            this._updateState()
        };
        proto._updateState = function() {
            if (this._player.getMediaElement().webkitCurrentPlaybackTargetIsWireless) {
                this._view.setState("on")
            } else if (this._airplayAvailable) {
                this._view.setState("off")
            } else {
                this._view.setState("initial")
            }
        };
        proto._onClick = function() {
            this._player.getMediaElement().webkitShowPlaybackTargetPicker()
        };
        proto.destroy = function() {
            this._player.getMediaElement().removeEventListener("webkitplaybacktargetavailabilitychanged", this._airplayStateChange);
            this._player.getMediaElement().removeEventListener("webkitcurrentplaybacktargetiswirelesschanged", this._updateState)
        };
        module.exports = AirPlayButtonBehavior
    }, {
        "./ButtonBehavior": 524
    }],
    523: [function(require, module, exports) {
        "use strict";
        var BaseBehavior = function(view, options) {
            this._player = options.player;
            this._view = view;
            if (this._addViewListeners) {
                this._addViewListeners()
            }
            if (this._addPlayerListeners) {
                this._addPlayerListeners()
            }
        };
        module.exports = BaseBehavior
    }, {}],
    524: [function(require, module, exports) {
        "use strict";
        var Base = require("./BaseBehavior");
        var ButtonBehavior = function(view, options) {
            this._onClick = this._onClick.bind(this);
            Base.apply(this, arguments)
        };
        var proto = ButtonBehavior.prototype = Object.create(Base.prototype);
        proto._addViewListeners = function() {
            this._view.on("click", this._onClick)
        };
        proto._clickHandler = function(evt) {
            evt.preventDefault();
            this._onClick(evt)
        };
        proto._onClick = function(evt) {};
        proto.destroy = function() {
            this._view.off("click", this._onClick)
        };
        module.exports = ButtonBehavior
    }, {
        "./BaseBehavior": 523
    }],
    525: [function(require, module, exports) {
        "use strict";
        var ButtonBehavior = require("./ButtonBehavior");
        var CaptionsButtonBehavior = function(view, options) {
            ButtonBehavior.apply(this, arguments);
            this._updateState()
        };
        var superProto = ButtonBehavior.prototype;
        var proto = CaptionsButtonBehavior.prototype = Object.create(superProto);
        proto._updateState = function() {
            var visibleTracks = this._player.getVisibleTextTracks();
            var tracks = this._player.getTextTracks();
            if (visibleTracks.length) {
                this._view.setState("on")
            } else if (tracks.length) {
                this._view.setState("off")
            } else {
                this._view.setState("initial")
            }
        };
        proto._addPlayerListeners = function() {
            this._updateState = this._updateState.bind(this);
            this._player.on("addtrack", this._updateState);
            this._player.on("change", this._updateState);
            this._player.on("removetrack", this._updateState)
        };
        proto._onClick = function() {
            var visibleTracks = this._player.getVisibleTextTracks();
            var tracks = this._player.getTextTracks();
            if (visibleTracks.length) {
                tracks[0].mode = "hidden"
            } else {
                tracks[0].mode = "showing"
            }
        };
        proto.destroy = function() {
            this._player.off("addtrack", this._updateState);
            this._player.off("change", this._updateState);
            this._player.off("removetrack", this._updateState);
            superProto.destroy.call(this)
        };
        module.exports = CaptionsButtonBehavior
    }, {
        "./ButtonBehavior": 524
    }],
    526: [function(require, module, exports) {
        "use strict";
        var ButtonBehavior = require("./ButtonBehavior");
        var FullScreenButtonBehavior = function(view, options) {
            ButtonBehavior.apply(this, arguments);
            if (this._player.getFullScreenEnabled()) {
                this._updateState()
            }
        };
        var superProto = ButtonBehavior.prototype;
        var proto = FullScreenButtonBehavior.prototype = Object.create(superProto);
        proto._addPlayerListeners = function() {
            this._updateState = this._updateState.bind(this);
            this._player.on("fullscreen:change", this._updateState)
        };
        proto._updateState = function() {
            this._view.setState(this._player.isFullscreen() ? "on" : "off")
        };
        proto._onClick = function() {
            this._player.toggleFullscreen(!this._player.isFullscreen())
        };
        proto.destroy = function() {
            this._player.off("fullscreen:change", this._updateState);
            superProto.destroy.call(this)
        };
        module.exports = FullScreenButtonBehavior
    }, {
        "./ButtonBehavior": 524
    }],
    527: [function(require, module, exports) {
        "use strict";
        var ButtonBehavior = require("./ButtonBehavior");
        var MuteButtonBehavior = function(view, options) {
            ButtonBehavior.apply(this, arguments);
            this._updateState()
        };
        var superProto = ButtonBehavior.prototype;
        var proto = MuteButtonBehavior.prototype = Object.create(superProto);
        proto._updateState = function() {
            this._view.setState(this._player.getMuted() ? "on" : "off")
        };
        proto._addPlayerListeners = function() {
            this._updateState = this._updateState.bind(this);
            this._player.on("volumechange", this._updateState)
        };
        proto._onClick = function() {
            if (this._player.getMuted()) {
                this._player.setMuted(false);
                if (this._player.getVolume() === 0) {
                    this._player.setVolume(.1)
                }
            } else {
                this._player.setMuted(true)
            }
        };
        proto.destroy = function() {
            this._player.off("volumechange", this._updateState);
            superProto.destroy.call(this)
        };
        module.exports = MuteButtonBehavior
    }, {
        "./ButtonBehavior": 524
    }],
    528: [function(require, module, exports) {
        "use strict";
        var ButtonBehavior = require("./ButtonBehavior");
        var PictureInPictureButtonBehavior = function(view, options) {
            ButtonBehavior.apply(this, arguments);
            this._initialize()
        };
        var superProto = ButtonBehavior.prototype;
        var proto = PictureInPictureButtonBehavior.prototype = Object.create(superProto);
        proto._initialize = function() {
            this._updateButtonState = this._updateButtonState.bind(this);
            if (this._player.supportsPictureInPicture()) {
                this._updateButtonState();
                this._player.on("webkitpresentationmodechanged", this._updateButtonState)
            }
        };
        proto._onClick = function() {
            this._player.setPictureInPicture(!this._player.isPictureInPicture())
        };
        proto._updateButtonState = function() {
            this._view.setState(this._player.isPictureInPicture() ? "on" : "off")
        };
        proto.destroy = function() {
            this._player.off("webkitpresentationmodechanged", this._updateButtonState);
            superProto.destroy.call(this)
        };
        module.exports = PictureInPictureButtonBehavior
    }, {
        "./ButtonBehavior": 524
    }],
    529: [function(require, module, exports) {
        "use strict";
        var ButtonBehavior = require("./ButtonBehavior");
        var PlayPauseButtonBehavior = function(view, options) {
            ButtonBehavior.apply(this, arguments);
            this._setPlayingState()
        };
        var superProto = ButtonBehavior.prototype;
        var proto = PlayPauseButtonBehavior.prototype = Object.create(superProto);
        proto._addPlayerListeners = function() {
            this._setPlayingState = this._setPlayingState.bind(this);
            this._player.on("play", this._setPlayingState);
            this._player.on("pause", this._setPlayingState);
            this._player.on("ended", this._setPlayingState)
        };
        proto._onClick = function() {
            this._togglePlay()
        };
        proto._setPlayingState = function() {
            this._view.setState(this._player.getEnded() ? "ended" : this._player.getPaused() ? "paused" : "playing")
        };
        proto._togglePlay = function() {
            if (this._player.getPaused() || this._player.getEnded()) {
                this._player.play()
            } else {
                this._player.pause()
            }
        };
        proto.destroy = function() {
            this._player.off("play", this._setPlayingState);
            this._player.off("pause", this._setPlayingState);
            superProto.destroy.call(this)
        };
        module.exports = PlayPauseButtonBehavior
    }, {
        "./ButtonBehavior": 524
    }],
    530: [function(require, module, exports) {
        "use strict";
        var Base = require("./BaseBehavior");
        var supplant = require("@marcom/ac-string/supplant");
        var IS_PLAYING = "is-playing";
        var draw = require("@marcom/ac-raf-emitter/draw");
        var cancelDraw = require("@marcom/ac-raf-emitter/cancelDraw");
        var ProgressBarSliderBehavior = function(view, options) {
            Base.apply(this, arguments);
            this._visible = false;
            this._ariaTextTemplate = options.localization.currenttimetext;
            this._onDurationChange()
        };
        var proto = ProgressBarSliderBehavior.prototype = Object.create(Base.prototype);
        proto._addViewListeners = function() {
            this._onSliderGrab = this._onSliderGrab.bind(this);
            this._onSliderChange = this._onSliderChange.bind(this);
            this._onSliderRelease = this._onSliderRelease.bind(this);
            this._view.on("grab", this._onSliderGrab)
        };
        proto._addPlayerListeners = function() {
            this._onTimeUpdate = this._onTimeUpdate.bind(this);
            this._onPlay = this._onPlay.bind(this);
            this._onPause = this._onPause.bind(this);
            this._onEnded = this._onEnded.bind(this);
            this._onDurationChange = this._onDurationChange.bind(this);
            this._onRAF = this._onRAF.bind(this);
            this._player.on("durationchange", this._onDurationChange);
            this._player.on("loadstart", this._onEnded);
            this._player.on("ended", this._onEnded);
            this._player.on("timeupdate", this._onTimeUpdate);
            this._player.on("play", this._onPlay);
            this._player.on("pause", this._onPause);
            this._player.on("ended", this._onEnded)
        };
        proto._setIsPlaying = function(enabled) {
            if (enabled) {
                this._view.setState(IS_PLAYING)
            } else {
                this._view.clearState(IS_PLAYING)
            }
        };
        proto._onPlay = function() {
            this._setIsPlaying(true);
            cancelDraw(this._timeUpdateInterval);
            draw(this._onRAF)
        };
        proto._onRAF = function() {
            this._onTimeUpdate();
            this._timeUpdateInterval = draw(this._onRAF)
        };
        proto._onPause = function() {
            this._setIsPlaying(false);
            cancelDraw(this._timeUpdateInterval);
            this._onTimeUpdate()
        };
        proto._onEnded = function() {
            this._onPause();
            this._updateSliderPosition(0)
        };
        proto._onSliderGrab = function() {
            this._player.off("timeupdate", this._onTimeUpdate);
            cancelDraw(this._timeUpdateInterval);
            this._view.off("grab", this._onSliderGrab);
            this._view.on("change", this._onSliderChange);
            this._view.on("release", this._onSliderRelease);
            this._onPause()
        };
        proto._onSliderRelease = function() {
            this._view.off("change", this._onSliderChange);
            this._view.off("release", this._onSliderRelease);
            this._view.on("grab", this._onSliderGrab);
            this._player.on("timeupdate", this._onTimeUpdate);
            if (!this._player.getPaused()) {
                this._onPlay()
            }
        };
        proto._getTimeAsPercent = function() {
            return this._player.getCurrentTime() / this._cachedDuration
        };
        proto._onDurationChange = function() {
            this._cachedDuration = this._player.getDuration();
            this._updateSliderPosition(this._getTimeAsPercent());
            if (!this._player.getPaused()) {
                this._onPlay()
            }
        };
        proto._onSliderChange = function() {
            var time = this._view.getValue();
            this._setPlayerCurrentTime(time * this._cachedDuration);
            this._setAriaValueText(time * this._cachedDuration);
            this._updateScrubbedValue()
        };
        proto._onTimeUpdate = function() {
            if (this._player.getPaused()) {
                this._updateSliderPosition(this._getTimeAsPercent())
            } else {
                this._updateSliderPosition(this._getTimeAsPercent())
            }
        };
        proto._updateSliderPosition = function(position) {
            this._view.setValue(position);
            this._setAriaValueText(position * this._cachedDuration);
            this._updateScrubbedValue();
            if (!this._visible && !isNaN(this._cachedDuration)) {
                this._view.show();
                this._visible = true
            }
        };
        proto._setAriaValueText = function(position) {
            var minutes = Math.floor(position / 60);
            var seconds = Math.ceil(position % 60);
            this._view.setAriaValueText(supplant(this._ariaTextTemplate, {
                minutes: minutes,
                seconds: seconds
            }))
        };
        proto._updateScrubbedValue = function() {
            this._view.setScrubbedValue()
        };
        proto._setPlayerCurrentTime = function(value) {
            this._player.setCurrentTime(value)
        };
        proto._removeEventListeners = function() {
            this._player.off("durationchange", this._onDurationChange);
            this._player.off("loadstart", this._onEnded);
            this._player.off("ended", this._onEnded);
            this._player.off("timeupdate", this._onTimeUpdate);
            this._view.off("change", this._onSliderChange);
            this._view.off("release", this._onSliderRelease);
            this._view.off("grab", this._onSliderGrab);
            this._player.off("play", this._onPlay);
            this._player.off("pause", this._onPause);
            this._player.off("ended", this._onPause)
        };
        proto.destroy = function() {
            this._removeEventListeners();
            cancelDraw(this._timeUpdateInterval)
        };
        module.exports = ProgressBarSliderBehavior
    }, {
        "./BaseBehavior": 523,
        "@marcom/ac-raf-emitter/cancelDraw": 460,
        "@marcom/ac-raf-emitter/draw": 461,
        "@marcom/ac-string/supplant": 402
    }],
    531: [function(require, module, exports) {
        "use strict";
        var ButtonBehavior = require("./ButtonBehavior");
        var SharingButtonBehavior = function(view, options) {
            ButtonBehavior.apply(this, arguments);
            if (this._player.states) {
                this._updateState()
            }
        };
        var superProto = ButtonBehavior.prototype;
        var proto = SharingButtonBehavior.prototype = Object.create(superProto);
        proto._addPlayerListeners = function() {
            this._updateState = this._updateState.bind(this);
            this._player.states && this._player.states.on("statechange", this._updateState)
        };
        proto._updateState = function() {
            this._stateChanging = false;
            this._view.setState(this._player.states.getCurrentState() === "sharing" ? "on" : "off")
        };
        proto._onClick = function() {
            if (this._stateChanging) {
                return
            }
            if (this._player.states.getCurrentState() === "sharing") {
                this._view.setState("off");
                this._player.states.setState("none")
            } else {
                this._view.setState("on");
                this._player.states.setState("sharing")
            }
            this._stateChanging = true
        };
        proto.destroy = function() {
            this._player.states && this._player.states.off("statechange", this._updateState);
            superProto.destroy.call(this)
        };
        module.exports = SharingButtonBehavior
    }, {
        "./ButtonBehavior": 524
    }],
    532: [function(require, module, exports) {
        "use strict";
        var BaseBehavior = require("./BaseBehavior");
        var SharingModule = require("../sharing/SharingModule");
        var SocialContainerBehavior = function(view, options) {
            BaseBehavior.apply(this, arguments);
            this._updateState()
        };
        var superProto = BaseBehavior.prototype;
        var proto = SocialContainerBehavior.prototype = Object.create(superProto);
        proto._updateState = function() {
            this.sharingModule = new SharingModule(Object.assign({}, {
                player: this._player,
                parentView: this._view
            }));
            this.sharingModule.setData(this._player.options.sharing);
            this._view.el.innerHTML = "";
            this._view.el.appendChild(this.sharingModule.el)
        };
        module.exports = SocialContainerBehavior
    }, {
        "../sharing/SharingModule": 549,
        "./BaseBehavior": 523
    }],
    533: [function(require, module, exports) {
        "use strict";
        var Base = require("./BaseBehavior");
        var VolumeSliderBehavior = function(view, options) {
            Base.apply(this, arguments);
            this._hideVolume();
            this._updateSliderVolumeValue()
        };
        var proto = VolumeSliderBehavior.prototype = Object.create(Base.prototype);
        proto._addViewListeners = function() {
            this._showVolume = this._showVolume.bind(this);
            this._hideVolume = this._hideVolume.bind(this);
            this._onSliderGrab = this._onSliderGrab.bind(this);
            this._onSliderChange = this._onSliderChange.bind(this);
            this._onSliderRelease = this._onSliderRelease.bind(this);
            this._onFocusChange = this._onFocusChange.bind(this);
            this._view.on("grab", this._onSliderGrab);
            this._view.on("focuschange", this._onFocusChange)
        };
        proto._addPlayerListeners = function() {
            this._updateSliderVolumeValue = this._updateSliderVolumeValue.bind(this);
            this._onUserVolumeChange = this._onUserVolumeChange.bind(this);
            this._player.once("durationchange", this._updateSliderVolumeValue);
            this._player.on("volumechange", this._updateSliderVolumeValue);
            this._player.on("uservolumechange", this._onUserVolumeChange)
        };
        proto._onSliderGrab = function() {
            this._cachedVolume = this._player.getVolume();
            this._player.off("volumechange", this._updateSliderVolumeValue);
            this._view.off("grab", this._onSliderGrab);
            this._view.on("change", this._onSliderChange);
            this._view.on("release", this._onSliderRelease)
        };
        proto._onSliderRelease = function() {
            this._setPlayerVolume(this._view.getValue());
            this._view.off("change", this._onSliderChange);
            this._view.off("release", this._onSliderRelease);
            this._view.on("grab", this._onSliderGrab);
            this._player.on("volumechange", this._updateSliderVolumeValue)
        };
        proto._onSliderChange = function() {
            var val = this._view.getValue();
            this._setPlayerVolume(val);
            this._view.setScrubbedValue()
        };
        proto._setPlayerVolume = function(value) {
            if (value) {
                this._player.setMuted(false);
                this._player.setVolume(value / 100)
            } else {
                this._player.setMuted(true);
                this._player.setVolume(this._cachedVolume)
            }
        };
        proto._showVolume = function() {
            this._view.show()
        };
        proto._hideVolume = function() {
            this._view.hide()
        };
        proto._onUserVolumeChange = function() {
            this._showVolume();
            clearTimeout(this._hideVolumeTimer);
            if (!this._view.isFocused()) {
                this._hideVolumeTimer = setTimeout(this._hideVolume, 1e3)
            }
        };
        proto._onFocusChange = function() {
            if (!this._view.isFocused()) {
                this._hideVolume()
            } else {
                this._showVolume()
            }
        };
        proto._updateSliderVolumeValue = function() {
            if (this._player.getMuted()) {
                this._view.setValue(0);
                this._view.setScrubbedValue()
            } else {
                var vol = this._player.getVolume();
                this._view.setValue(vol * 100);
                this._view.setScrubbedValue()
            }
        };
        proto._removeEventListeners = function() {
            this._player.off("durationchange", this._updateSliderVolumeValue);
            this._player.off("volumechange", this._updateSliderVolumeValue);
            this._player.off("uservolumechange", this._onUserVolumeChange);
            this._view.off("change", this._onSliderChange);
            this._view.off("release", this._onSliderRelease);
            this._view.off("grab", this._onSliderGrab)
        };
        proto.destroy = function() {
            this._removeEventListeners()
        };
        module.exports = VolumeSliderBehavior
    }, {
        "./BaseBehavior": 523
    }],
    534: [function(require, module, exports) {
        "use strict";
        var DOMEmitterMicro = require("../../dom-emitter/DOMEmitterMicro");
        var Button = function(element) {
            this.el = element
        };
        Button.prototype = Object.create(DOMEmitterMicro.prototype);
        module.exports = Button
    }, {
        "../../dom-emitter/DOMEmitterMicro": 501
    }],
    535: [function(require, module, exports) {
        "use strict";
        var Container = function(element) {
            this.el = element
        };
        var proto = Container.prototype;
        proto.show = function() {
            this.el.classList.remove("hidden")
        };
        proto.hide = function() {
            this.el.classList.add("hidden")
        };
        module.exports = Container
    }, {}],
    536: [function(require, module, exports) {
        "use strict";
        var Label = function(element) {
            this.el = element
        };
        var proto = Label.prototype;
        proto.setText = function(value) {
            this.el.innerHTML = value
        };
        module.exports = Label
    }, {}],
    537: [function(require, module, exports) {
        "use strict";
        var acSlider = require("@marcom/ac-slider").Slider;
        var INACTIVE_CLASS = "ac-slider-inactive";
        var Slider = function(element, options) {
            this.el = element;
            this._min = options.min || 0;
            this._max = options.max || 1;
            if (options.mixins) {
                var mixins = options.mixins.slice(0);
                while (mixins.length) {
                    Object.assign(this, mixins.pop())
                }
            }
            this._slider = new acSlider(this.el, {
                template: options.template,
                min: this._min,
                max: this._max,
                step: isNaN(+this.el.getAttribute("step")) ? this.el.getAttribute("step") : +this.el.getAttribute("step"),
                value: options.value !== undefined ? options.value : +this.el.getAttribute("value"),
                orientation: options.orientation,
                renderedPosition: true,
                keyboardContext: this.el
            });
            this._onFocusChange = this._onFocusChange.bind(this);
            this._setHoveringValue = this._setHoveringValue.bind(this);
            this._onMouseOver = this._onMouseOver.bind(this);
            this._onMouseLeave = this._onMouseLeave.bind(this);
            this._slider.el.addEventListener("blur", this._onFocusChange);
            this._slider.el.addEventListener("focus", this._onFocusChange);
            this._slider.el.addEventListener("mouseout", this._onFocusChange);
            this.forceCursorPointer = this.forceCursorPointer.bind(this);
            this.disableForcedCursorPointer = this.disableForcedCursorPointer.bind(this);
            this._slider.on("grab", this.forceCursorPointer);
            this._slider.on("release", this.disableForcedCursorPointer);
            this._scrubbedEl = this.el.querySelector(".ac-slider-scrubbed");
            this._notchEl = this.el.querySelector(".ac-slider-hover-notch");
            if (this._notchEl) {
                this._slider.el.addEventListener("mouseover", this._onMouseOver);
                this._slider.el.addEventListener("mouseleave", this._onMouseLeave);
                this._slider.el.addEventListener("mousemove", this._setHoveringValue)
            }
            if (options.value) {
                requestAnimationFrame(function() {
                    if (this._slider) {
                        this.setValue(options.value)
                    }
                }.bind(this))
            }
        };
        var proto = Slider.prototype;
        proto.on = function() {
            return this._slider.on.apply(this._slider, arguments)
        };
        proto.off = function() {
            return this._slider.off.apply(this._slider, arguments)
        };
        proto.trigger = function() {
            return this._slider.trigger.apply(this._slider, arguments)
        };
        proto.setValue = function(value) {
            return this._slider.setValue.call(this._slider, value)
        };
        proto.setAriaValueText = function(value) {
            this._slider.el.setAttribute("aria-valuetext", value)
        };
        proto.setMin = function(min) {
            this._min = min;
            this._slider.setMin(min)
        };
        proto.setMax = function(max) {
            this._max = max;
            this._slider.setMax(max)
        };
        proto._onMouseOver = function() {
            this._slider.el.classList.add("hover")
        };
        proto._onMouseLeave = function() {
            this._slider.el.classList.remove("hover")
        };
        proto._onFocusChange = function() {
            setTimeout(function() {
                this.trigger("focuschange")
            }.bind(this), 0)
        };
        proto.isFocused = function() {
            return this._slider.el === document.activeElement && this._hasFocusOutline()
        };
        proto._hasFocusOutline = function() {
            return getComputedStyle(this._slider.el).getPropertyValue("outline-style") !== "none"
        };
        proto.getValue = function() {
            return this._slider.getValue.apply(this._slider, arguments)
        };
        proto.getMax = function() {
            return this._max
        };
        proto.setScrubbedValue = function() {
            if (this._slider.getOrientation() === "horizontal") {
                this._scrubbedEl.style.left = this._slider.thumbElement.style.left
            } else {
                this._scrubbedEl.style.bottom = this._slider.thumbElement.style.bottom
            }
        };
        proto._setHoveringValue = function(evt) {
            var value = this.getClientXValue(evt, this._notchEl);
            this._notchEl.style.left = value / this.getMax() * 100 + "%";
            this._setNotchColor(value)
        };
        proto._setNotchColor = function(value) {
            if (value > this.getValue()) {
                this._notchEl.style.backgroundColor = "#fff"
            } else {
                this._notchEl.style.backgroundColor = "#333"
            }
        };
        proto.show = function() {
            this.el.classList.remove(INACTIVE_CLASS)
        };
        proto.hide = function() {
            this.el.classList.add(INACTIVE_CLASS)
        };
        proto.setState = function(state) {
            this.el.classList.add(state)
        };
        proto.clearState = function(state) {
            this.el.classList.remove(state)
        };
        proto.getClientXValue = function(evt, offsetEl) {
            return this._slider.getClientXValue(evt, offsetEl)
        };
        proto.destroy = function() {
            this._slider.el.removeEventListener("mousemove", this._setHoveringValue);
            this._slider.el.removeEventListener("mouseleave", this._onMouseOver);
            this._slider.el.removeEventListener("mouseout", this._onMouseLeave);
            this._slider.el.removeEventListener("blur", this._onFocusChange);
            this._slider.el.removeEventListener("focus", this._onFocusChange);
            this._slider.el.removeEventListener("mouseout", this._onFocusChange);
            this._slider.off("grab", this.forceCursorPointer);
            this._slider.off("release", this.disableForcedCursorPointer);
            this._slider.destroy();
            this._slider = null
        };
        module.exports = Slider
    }, {
        "@marcom/ac-slider": 475
    }],
    538: [function(require, module, exports) {
        "use strict";
        var Button = require("./Button");
        var StatefulButton = function(element, options) {
            Button.apply(this, arguments);
            this._states = options.states || {};
            this._labels = options.labels;
            this._focusTarget = this.el.querySelector("button") || this.el;
            if (this._states && this._states.initial) {
                this.setState("initial")
            }
        };
        var proto = StatefulButton.prototype = Object.create(Button.prototype);
        proto.setState = function(state) {
            if (this._currentState && this._currentState !== state && this._states[this._currentState].length) {
                this.el.classList.remove(this._states[this._currentState])
            }
            this._currentState = state;
            if (this._labels && this._labels[this._currentState]) {
                this._focusTarget.value = this._labels[this._currentState];
                this._focusTarget.setAttribute("aria-label", this._labels[this._currentState])
            }
            if (this._currentState === "on") {
                this._focusTarget.setAttribute("aria-pressed", true)
            } else {
                this._focusTarget.setAttribute("aria-pressed", false)
            }
            if (this._states[state].length) {
                this.el.classList.add(this._states[state])
            }
        };
        module.exports = StatefulButton
    }, {
        "./Button": 534
    }],
    539: [function(require, module, exports) {
        "use strict";
        var FORCE_CURSOR_POINTER_CLASS = "cursor-pointer";
        module.exports = {
            disableForcedCursorPointer: function() {
                document.body.classList.remove(FORCE_CURSOR_POINTER_CLASS);
                this.onSelectStartResumeDefault()
            },
            forceCursorPointer: function() {
                document.body.classList.add(FORCE_CURSOR_POINTER_CLASS);
                this.onSelectStartPreventDefault()
            },
            onSelectStartResumeDefault: function() {
                document.removeEventListener("selectstart", this.preventDefault)
            },
            onSelectStartPreventDefault: function() {
                document.addEventListener("selectstart", this.preventDefault)
            },
            preventDefault: function(e) {
                e.preventDefault()
            }
        }
    }, {}],
    540: [function(require, module, exports) {
        "use strict";
        var createBehaviorFromClass = function(view, behaviorDefinitionObject, behaviorDecorations) {
            return new behaviorDefinitionObject.classDef(view, Object.assign(behaviorDefinitionObject.options || {}, behaviorDecorations || {}))
        };
        var createListener = function(context, eventName, view) {
            return function(event) {
                context[eventName](event, view)
            }
        };
        var createBehaviorDynamically = function(view, behaviorDefinitionObject) {
            var handlers = behaviorDefinitionObject.handlers || {};
            var boundListeners = {};
            for (var evt in handlers) {
                if (handlers.hasOwnProperty(evt)) {
                    view.on(evt, boundListeners[evt] = createListener(handlers, evt, view))
                }
            }
            var observe = behaviorDefinitionObject.observe;
            var destroyObserver;
            if (observe) {
                var update = observe.update;
                var source = observe.source;
                var on = source.on.bind(source) || source.addEventListener;
                var off = source.off.bind(source) || source.removeEventListener;
                var events = observe.events;
                var i = 0;
                var len = events.length;
                var updateCallback = function() {
                    update.call(observe, view)
                };
                for (; i < len; i++) {
                    evt = events[i];
                    on(evt, updateCallback)
                }
                destroyObserver = function() {
                    for (i = 0; i < len; i++) {
                        evt = events[i];
                        off(evt, updateCallback)
                    }
                }
            }
            var destroy = function() {
                for (var evt in boundListeners) {
                    if (boundListeners.hasOwnProperty(evt)) {
                        view.off(evt, boundListeners[evt])
                    }
                }
                if (destroyObserver) {
                    destroyObserver()
                }
            };
            return {
                destroy: destroy
            }
        };
        module.exports = function createBehavior(view, behaviorDefinitionObject, behaviorDecorations) {
            if (behaviorDefinitionObject.classDef) {
                return createBehaviorFromClass(view, behaviorDefinitionObject, behaviorDecorations)
            } else {
                return createBehaviorDynamically(view, behaviorDefinitionObject, behaviorDecorations)
            }
        }
    }, {}],
    541: [function(require, module, exports) {
        "use strict";
        var createView = require("./createView");
        var createBehavior = require("./createBehavior");
        var destroyComponent = function(view, behavior) {
            if (typeof behavior.destroy === "function") {
                behavior.destroy()
            }
            if (typeof view.destroy === "function") {
                view.destroy()
            }
        };
        var destroyArray = function(array) {
            while (array.length) {
                array.shift().destroy()
            }
        };
        var destroyMap = function(map) {
            for (var prop in map) {
                if (map.hasOwnProperty(prop)) {
                    destroyArray(map[prop]);
                    delete map[prop]
                }
            }
        };
        var createComponent = function(element, componentDefinitionObject, behaviorDecorations) {
            var view = createView(element, componentDefinitionObject.view);
            var behavior = createBehavior(view, componentDefinitionObject.behavior, behaviorDecorations);
            return {
                view: view,
                behavior: behavior,
                destroy: destroyComponent.bind(null, view, behavior)
            }
        };
        module.exports = function createComponents(contextElement, componentDefinitionObject, behaviorDecorations) {
            var components = {};
            for (var componentName in componentDefinitionObject) {
                if (componentDefinitionObject.hasOwnProperty(componentName) && typeof componentDefinitionObject[componentName] === "object") {
                    var definition = componentDefinitionObject[componentName];
                    var targetSelector = componentDefinitionObject.elementClassPrefix ? "." + componentDefinitionObject.elementClassPrefix + "-" + definition.className : "." + definition.className;
                    var targetElements = contextElement.querySelectorAll(targetSelector);
                    components[componentName] = [];
                    var i = 0;
                    var len = targetElements.length;
                    for (; i < len; i++) {
                        components[componentName].push(createComponent(targetElements[i], definition, behaviorDecorations))
                    }
                }
            }
            return {
                components: components,
                destroy: destroyMap.bind(null, components)
            }
        }
    }, {
        "./createBehavior": 540,
        "./createView": 542
    }],
    542: [function(require, module, exports) {
        "use strict";
        module.exports = function createView(element, viewDefinitionObject) {
            return new viewDefinitionObject.classDef(element, viewDefinitionObject.options)
        }
    }, {}],
    543: [function(require, module, exports) {
        "use strict";
        module.exports = {
            backthirtyseconds: "Back 30 Seconds",
            playpause: "Play/Pause",
            play: "Play",
            pause: "Pause",
            togglemutevolume: "Toggle Mute Volume",
            mutevolume: "Mute Volume",
            minvolume: "Minimum Volume",
            adjustvolume: "Adjust Volume",
            fastreverse: "Fast Reverse",
            fastforward: "Fast Forward",
            fullvolume: "Full Volume",
            fullscreen: "Full Screen",
            exitfullscreen: "Exit Full Screen",
            airplay: "AirPlay",
            captionscontrol: "Closed Captions",
            captionsturnedon: "Closed Captions On",
            captionsturnedoff: "Closed Captions Off",
            subtitlescontrol: "Subtitles",
            subtitlesturnedon: "Subtitles On",
            subtitlesturnedoff: "Subtitles Off",
            sizescontrol: "Video Size",
            downloadcontrol: "Download Video",
            share: "Share",
            small: "Small",
            medium: "Medium",
            large: "Large",
            hd: "HD",
            ipod: "iPod/iPhone",
            mb: "MB",
            gb: "GB",
            tb: "TB",
            downloadquicktimetitle: "Get QuickTime.",
            downloadquicktimetext: "Download QuickTime to view this video. QuickTime is free for Mac + PC.",
            downloadquicktimebutton: "Download",
            downloadquicktimeurl: "https://www.apple.com/quicktime/download/",
            elapsed: "elapsed",
            remaining: "remaining",
            currenttimetext: "{minutes} minutes and {seconds} seconds",
            pictureinpicture: "Picture-in-Picture",
            exitpictureinpicture: "Exit Picture-in-Picture",
            closesharing: "Close Sharing",
            facebookshare: "Share to Facebook",
            twittershare: "Share to Twitter",
            copylink: "Copy Link",
            copyembed: "Copy Embed Code",
            copyarea: "Copy Link Text Area",
            selectlink: "Select Link Text",
            selectembed: "Select Embed Code",
            close: "Close",
            dismisscopy: "Dismiss Copy",
            replay: "Replay",
            livestream: "Live Streaming",
            newwindow: "Opens in New Window"
        }
    }, {}],
    544: [function(require, module, exports) {
        "use strict";
        var TRANSLATIONS = require("./Translations");
        var DEFAULT_LABEL_STRINGS = require("./DefaultLabelStrings");
        var HTML = window.document.documentElement;
        var TOP_HTML;
        try {
            TOP_HTML = window.top.document.documentElement
        } catch (e) {
            TOP_HTML = HTML
        }
        var xhr = require("@marcom/ac-ajax-xhr");
        var m = "m";
        var BASE_PATH = "/global/ac_" + m + "edia_player/scripts/ac_" + m + "edia_languages/";
        var DEFAULT_LANGUAGE = "en-US";
        var localizationCache = {};
        var getLanguage = function(langCode) {
            var attr;
            try {
                attr = langCode || TOP_HTML.getAttribute("lang")
            } catch (err) {
                attr = HTML.getAttribute("lang")
            }
            var lang;
            if (!attr) {
                lang = DEFAULT_LANGUAGE
            } else {
                switch (attr.toLowerCase()) {
                    case "es-418":
                        lang = "es-LA";
                        break;
                    case "pt":
                        lang = "pt-BR";
                        break;
                    default:
                        lang = attr;
                        break
                }
            }
            return lang
        };
        var translationReady = function(lang) {
            lang = getLanguage(lang);
            return localizationCache[lang] !== undefined
        };
        var getTranslation = function(options) {
            options = options || {};
            var lang = getLanguage(options.lang);
            if (translationReady(lang)) {
                if (options.callback) {
                    options.callback(localizationCache[lang]);
                    return
                } else {
                    return localizationCache[lang]
                }
            } else if (!options.callback) {
                throw new Error("To use Localization.getTranslation you must either pass a callback or ensure the translation is ready via Localization.translationReady")
            }
            var path = options.basePath || BASE_PATH;
            var fullPath = TRANSLATIONS[lang] ? path + TRANSLATIONS[lang] : path + TRANSLATIONS[DEFAULT_LANGUAGE];
            var translation = DEFAULT_LABEL_STRINGS;
            xhr.get(fullPath, {
                success: function(response) {
                    translation = Object.assign(translation, JSON.parse(response));
                    localizationCache[lang] = translation;
                    options.callback(translation)
                },
                error: function() {
                    localizationCache[lang] = translation;
                    options.callback(translation)
                }
            })
        };
        module.exports = {
            getLanguage: getLanguage,
            getTranslation: getTranslation,
            translationReady: translationReady
        }
    }, {
        "./DefaultLabelStrings": 543,
        "./Translations": 545,
        "@marcom/ac-ajax-xhr": 414
    }],
    545: [function(require, module, exports) {
        "use strict";
        module.exports = {
            "bg-BG": "bg-BG.json",
            "cs-CZ": "cs-CZ.json",
            "el-GR": "el-GR.json",
            "de-AT": "de-AT.json",
            "de-CH": "de-CH.json",
            "de-DE": "de-DE.json",
            "de-LI": "de-LI.json",
            "da-DK": "da-DK.json",
            en: "en.json",
            "en-US": "en-US.json",
            "en-AP": "en-AP.json",
            "en-CA": "en-CA.json",
            "en-GB": "en-GB.json",
            "en-HK": "en-HK.json",
            "en-IE": "en-IE.json",
            "en-IN": "en-IN.json",
            "en-KR": "en-KR.json",
            "en-AU": "en-AU.json",
            "en-NZ": "en-NZ.json",
            "en-SG": "en-SG.json",
            "en-ZA": "en-ZA.json",
            es: "es.json",
            "es-LA": "es-LA.json",
            "es-MX": "es-MX.json",
            "es-ES": "es-ES.json",
            "et-EE": "et-EE.json",
            "fi-FI": "fi-FI.json",
            fr: "fr.json",
            "fr-BE": "fr-BE.json",
            "fr-CA": "fr-CA.json",
            "fr-CH": "fr-CH.json",
            "fr-FR": "fr-FR.json",
            "hr-HR": "hr-HR.json",
            "hu-HU": "hu-HU.json",
            "it-IT": "it-IT.json",
            ja: "ja.json",
            "ja-JP": "ja-JP.json",
            "ko-KR": "ko-KR.json",
            "lt-LT": "lt-LT.json",
            "lv-LV": "lv-LV.json",
            "nl-BE": "nl-BE.json",
            "nl-NL": "nl-NL.json",
            "no-NO": "no-NO.json",
            "pl-PL": "pl-PL.json",
            pt: "pt.json",
            "pt-BR": "pt-BR.json",
            "pt-PT": "pt-PT.json",
            "ro-RO": "ro-RO.json",
            "ru-RU": "ru-RU.json",
            "sk-SK": "sk-SK.json",
            "sv-SE": "sv-SE.json",
            "tr-TR": "tr-TR.json",
            zh: "zh.json",
            "zh-CN": "zh-CN.json",
            "zh-HK": "zh-HK.json",
            "zh-TW": "zh-TW.json"
        }
    }, {}],
    546: [function(require, module, exports) {
        "use strict";
        var PopUp = require("./PopUp");
        var OverlayContainer = function(options) {
            this.el = options.el;
            this._player = options.player;
            this._popUp = new PopUp(options);
            this.el.appendChild(this._popUp.el)
        };
        var proto = OverlayContainer.prototype;
        proto.setData = function(data) {
            this._popUp.setData(data)
        };
        proto.show = function() {
            this.el.classList.remove("hidden")
        };
        proto.hide = function() {
            this.el.classList.add("hidden")
        };
        proto.destroy = function() {};
        module.exports = OverlayContainer
    }, {
        "./PopUp": 547
    }],
    547: [function(require, module, exports) {
        "use strict";
        var TEMPLATE = '<div class="ac-video-trickplay hidden" aria-hidden="true">\n    <div class="ac-video-trickplay-image">\n    </div>\n    <div class="ac-video-trickplay-time"></div>\n</div>\n';
        var Time = require("../../utils/Time");
        var ThumbnailHandler = require("./ThumbnailHandler");
        var debounce = require("@marcom/ac-function/throttle");
        var RUNNABLE_TRACK_PADDING = 5;
        var PopUp = function(options) {
            this._player = options.player;
            this.el = document.createElement("div");
            this.el.style.opacity = "0";
            this.el.innerHTML = TEMPLATE;
            this._thumbnailHandler = new ThumbnailHandler({
                el: this.el.querySelector(".ac-video-trickplay-image"),
                player: this._player,
                numberOfImages: options.numberOfImages
            });
            this._timeLabel = this.el.querySelector(".ac-video-trickplay-time");
            this._bindMethods();
            this._addEventListeners()
        };
        var proto = PopUp.prototype;
        proto._initPointerTracking = function() {
            this._scrubberView = this._player.controls.scrubberView;
            if (!this._scrubberView) {
                return
            }
            this._runnableTrack = this._scrubberView.el.querySelector(".ac-slider-runnable-track");
            this._calcOffsets();
            this._scrubberView.el.addEventListener("mouseover", this._show);
            this._scrubberView.el.addEventListener("mouseout", this._hide);
            this._scrubberView.el.addEventListener("mousedown", this._startScrubbing);
            this._scrubberView.el.addEventListener("mouseup", this._endScrubbing);
            this._scrubberView.el.addEventListener("mousemove", this._onTrackerUpdate);
            this._scrubberView.el.addEventListener("mousemove", this._setThumbnail);
            this._player.on("resize", this._calcOffsets);
            window.addEventListener("resize", this._calcOffsets)
        };
        proto._bindMethods = function() {
            this._show = this._show.bind(this);
            this._hide = this._hide.bind(this);
            this._onDurationChange = this._onDurationChange.bind(this);
            this._onLoadedMetaData = this._onLoadedMetaData.bind(this);
            this._startScrubbing = this._startScrubbing.bind(this);
            this._endScrubbing = this._endScrubbing.bind(this);
            this._initPointerTracking = this._initPointerTracking.bind(this);
            this._onTrackerUpdate = this._onTrackerUpdate.bind(this);
            this._setThumbnail = this._setThumbnail.bind(this);
            this._calcOffsets = this._calcOffsets.bind(this);
            this._debouncedCalcOffsets = debounce(this._calcOffsets, 30)
        };
        proto._startScrubbing = function(evt) {
            this._thumbnailHandler.el.classList.add("hidden");
            this._scrubberView.el.removeEventListener("mousemove", this._setThumbnail);
            this._scrubberView.el.removeEventListener("mouseout", this._hide);
            document.addEventListener("mouseup", this._endScrubbing);
            document.addEventListener("mousemove", this._onTrackerUpdate)
        };
        proto._endScrubbing = function(evt) {
            if (evt.target === this._scrubberView.el) {
                this._hide()
            }
            this._scrubberView.el.addEventListener("mousemove", this._setThumbnail);
            this._scrubberView.el.addEventListener("mouseout", this._hide);
            document.removeEventListener("mouseup", this._endScrubbing);
            document.removeEventListener("mousemove", this._onTrackerUpdate);
            this._setThumbnail(evt);
            this._thumbnailHandler.el.classList.remove("hidden")
        };
        proto._calcOffsets = function() {
            this._onLoadedMetaData();
            var playerRect = this._player.el.getBoundingClientRect();
            this._offsetLeft = playerRect.left;
            var rect = this._runnableTrack.getBoundingClientRect();
            this._leftBoundary = rect.left - this._offsetLeft + RUNNABLE_TRACK_PADDING;
            this._rightBoundary = this._leftBoundary + rect.width - RUNNABLE_TRACK_PADDING - 2;
            this._imgWidth = this.el.firstElementChild.getBoundingClientRect().width
        };
        proto._onLoadedMetaData = function() {
            var w = this._player.getMediaElement().videoWidth;
            var h = this._player.getMediaElement().videoHeight;
            this.el.classList.remove("square-video");
            this.el.classList.remove("vertical-video");
            if (w < h) {
                this.el.classList.add("vertical-video");
                this._thumbnailHandler.setVertical(true)
            } else if (w === h) {
                this.el.classList.add("square-video");
                this._thumbnailHandler.setVertical(false)
            } else {
                this._thumbnailHandler.setVertical(false)
            }
        };
        proto._addEventListeners = function() {
            this._player.on("durationchange", this._onDurationChange);
            this._player.once("controlsready", this._initPointerTracking);
            this._player.on("loadedmetadata", this._calcOffsets)
        };
        proto._removeEventListeners = function() {
            this._player.off("durationchange", this._onDurationChange);
            this._player.off("controlsready", this._initPointerTracking);
            this._player.off("timeupdate", this._calcOffsets);
            this._player.off("resize", this._debouncedCalcOffsets);
            window.removeEventListener("resize", this._debouncedCalcOffsets);
            this._scrubberView.el.removeEventListener("mouseover", this._show);
            this._scrubberView.el.removeEventListener("mouseout", this._hide);
            this._scrubberView.el.removeEventListener("mousemove", this._onTrackerUpdate);
            this._scrubberView.el.removeEventListener("mousemove", this._setThumbnail)
        };
        proto._onTrackerUpdate = function(evt) {
            this._calcOffsets();
            var position = Math.min(Math.max(evt.clientX - this._offsetLeft, this._leftBoundary), this._rightBoundary);
            this.el.firstElementChild.style.left = position - this._imgWidth / 2 + "px";
            var scrubberPosition = this._scrubberView.getClientXValue(evt);
            if (this._player.getReadyState() <= 2) {
                this._cachedTrackerUpdate = evt
            } else {
                this._cachedTrackerUpdate = null
            }
            this._setTime(Math.max(scrubberPosition, 0))
        };
        proto._onDurationChange = function(evt) {
            this._cachedDuration = this._player.getDuration();
            if (this._cachedTrackerUpdate) {
                this._onTrackerUpdate(this._cachedTrackerUpdate);
                this._setThumbnail()
            }
            this.el.style.opacity = "1"
        };
        proto._setThumbnail = function(evt) {
            this._thumbnailHandler.setTime(this._time, this._cachedDuration)
        };
        proto._setTime = function(position) {
            var percent = position / this._scrubberView.getMax();
            this._time = Math.min(percent * this._cachedDuration, this._cachedDuration);
            var formattedTime = Time.formatTime(Math.round(this._time), this._cachedDuration);
            this._timeLabel.innerHTML = formattedTime
        };
        proto.setData = function(data) {
            this.el.style.opacity = "0";
            if (this._canPlayThroughHander) {
                this._player.off("canplaythrough", this._canPlayThroughHander);
                this._player.off("playing", this._canPlayThroughHander);
                this._canPlayThroughHander = null
            }
            if (data && this._player.getReadyState() > 2) {
                this.el.style.opacity = "1";
                this._thumbnailHandler.setData(data);
                if (this._cachedTrackerUpdate) {
                    this._onTrackerUpdate(this._cachedTrackerUpdate);
                    this._setThumbnail()
                }
            } else {
                this._thumbnailHandler.setData(null);
                if (data) {
                    this._canPlayThroughHander = this.setData.bind(this, data);
                    this._player.on("canplaythrough", this._canPlayThroughHander);
                    this._player.on("playing", this._canPlayThroughHander)
                } else {
                    this.el.style.opacity = "1"
                }
            }
            this._onLoadedMetaData()
        };
        proto._show = function(evt) {
            this._onTrackerUpdate(evt);
            this.el.firstElementChild.classList.remove("hidden")
        };
        proto._hide = function() {
            this.el.firstElementChild.classList.add("hidden")
        };
        proto.destroy = function() {
            if (this._canPlayThroughHander) {
                this._player.off("canplaythrough", this._canPlayThroughHander);
                this._player.off("playing", this._canPlayThroughHander)
            }
            this._tracker.destroy()
        };
        module.exports = PopUp
    }, {
        "../../utils/Time": 551,
        "./ThumbnailHandler": 548,
        "@marcom/ac-function/throttle": 439
    }],
    548: [function(require, module, exports) {
        "use strict";
        var DEFAULT_NUMBER_OF_IMAGES = 120;
        var DEFAULT_WIDTH = 144;
        var DEFAULT_HEIGHT = 81;
        var ThumbnailHandler = function(options) {
            this.el = options.el;
            this._player = options.player;
            this._imgWidth = options.imgWidth || DEFAULT_WIDTH;
            this.el.style.backgroundSize = this._numberOfImages * 100 + "% 100%"
        };
        var proto = ThumbnailHandler.prototype;
        proto.setVertical = function(vertical) {
            this._imgWidth = vertical ? DEFAULT_HEIGHT : DEFAULT_WIDTH
        };
        proto.getWidth = function() {
            return this._imgWidth
        };
        proto.setData = function(data) {
            if (!data) {
                this._imgUrl = null;
                this.el.style.backgroundImage = "";
                return
            } else if (data.url === this._imgUrl) {
                return
            }
            if (this._imageLoadPromise) {
                this._imageLoadPromise.cancel()
            }
            this._imgUrl = data.url;
            this._numberOfImages = parseInt(data.numberOfImages || DEFAULT_NUMBER_OF_IMAGES);
            this.el.style.backgroundSize = this._numberOfImages * 100 + "% 100%";
            this.el.style.backgroundImage = "";
            this.el.classList.add("hidden");
            this._imageLoadPromise = this._loadImage(this._imgUrl).then(function() {
                this.el.style.backgroundImage = 'url("' + this._imgUrl + '")';
                this._imageLoadPromise = null;
                this.el.classList.remove("hidden")
            }.bind(this))
        };
        proto._loadImage = function(url) {
            return new Promise(function(resolve, reject) {
                var img = new Image;
                img.onload = function() {
                    resolve()
                };
                img.onerror = function() {
                    reject()
                };
                img.src = url
            })
        };
        proto.setTime = function(time, max) {
            var percent = time / max;
            var sequenceNumber = Math.min(Math.round(percent * this._numberOfImages), this._numberOfImages - 1);
            var percentageOffset = sequenceNumber / (this._numberOfImages - 1) * 100;
            this.el.style.backgroundPositionX = percentageOffset + "%"
        };
        proto.destroy = function() {
            if (this._imageLoadPromise) {
                this._imageLoadPromise.cancel()
            }
        };
        module.exports = ThumbnailHandler
    }, {}],
    549: [function(require, module, exports) {
        (function(Buffer) {
            "use strict";
            var TEMPLATE = Buffer("PGRpdiBjbGFzcz0ic2hhcmluZy1zdGF0ZSI+CiAgICA8ZGl2IGNsYXNzPSJjb250YWluZXIiIGRhdGEtYWN2LWFjdGl2ZS1hcmVhPgogICAgICAgIDxkaXYgY2xhc3M9InNoYXJpbmctY29udGFpbmVyIj4KICAgICAgICAgICAgPGRpdiBjbGFzcz0ic2hhcmluZy1idXR0b24tY29udGFpbmVyIj4KICAgICAgICAgICAgICAgIDxidXR0b24gY2xhc3M9ImZhY2Vib29rLXNoYXJlIGFjLXZpZGVvLWljb24gaWNvbi1zaGFyZV9mYiIgYXJpYS1sYWJlbD0ie2ZhY2Vib29rc2hhcmV9LCB7bmV3d2luZG93fSI+PC9idXR0b24+CiAgICAgICAgICAgICAgICA8YnV0dG9uIGNsYXNzPSJ0d2l0dGVyLXNoYXJlIGFjLXZpZGVvLWljb24gaWNvbi1zaGFyZV90d2l0dGVyIiBhcmlhLWxhYmVsPSJ7dHdpdHRlcnNoYXJlfSwge25ld3dpbmRvd30iPjwvYnV0dG9uPgogICAgICAgICAgICAgICAgPGJ1dHRvbiBjbGFzcz0iY29weS1saW5rIGFjLXZpZGVvLWljb24gaWNvbi1zaGFyZV9saW5rIiBhcmlhLWxhYmVsPSJ7Y29weWxpbmt9Ij48L2J1dHRvbj4KICAgICAgICAgICAgICAgIDxidXR0b24gY2xhc3M9ImNvcHktZW1iZWQtY29kZSBhYy12aWRlby1pY29uIGljb24tc2hhcmVfZW1iZWQiIGFyaWEtbGFiZWw9Intjb3B5ZW1iZWR9Ij48L2J1dHRvbj4KICAgICAgICAgICAgPC9kaXY+CiAgICAgICAgPC9kaXY+CiAgICAgICAgPGRpdiBjbGFzcz0idGV4dGFyZWEtY29udGFpbmVyIj4KICAgICAgICAgICAgPHNwYW4+CiAgICAgICAgICAgICAgICA8aW5wdXQgY2xhc3M9ImNvcHktYXJlYSBmb3JtLXRleHRib3ggZm9ybS10ZXh0Ym94LXRleHQgZGlzYWJsZWQiIHR5cGU9InRleHQiIGlkPSJjb3B5LWxpbmsiIGFyaWEtbGFiZWw9Intjb3B5bGlua30iPjwvaW5wdXQ+CiAgICAgICAgICAgICAgICA8YnV0dG9uIGNsYXNzPSJ0ZXh0aW5wdXQtY2xvc2UtYnV0dG9uIGFjLXZpZGVvLWljb24gaWNvbi1zaGFyZV9jbG9zZSIgYXJpYS1sYWJlbD0ie2Rpc21pc3Njb3B5fSI+PC9idXR0b24+CiAgICAgICAgICAgIDwvc3Bhbj4KICAgICAgICA8L2Rpdj4KICAgIDwvZGl2Pgo8L2Rpdj4K", "base64").toString();
            var EMBED_CODE_TEMPLATE = Buffer("PGlmcmFtZSBzcmM9IntlbWJlZENvZGVQYXRofXt2aWRlb2lkfXtleHRlbnNpb259IiB3aWR0aD0ie3dpZHRofSIgaGVpZ2h0PSJ7aGVpZ2h0fSIgdGl0bGU9Int0aXRsZX0iIGFsbG93ZnVsbHNjcmVlbj48L2lmcmFtZT4K", "base64").toString();
            var DEFAULT_EMBED_PATH = "https://www.apple.com/embed/";
            var DEFAULT_TITLE = "Video Player";
            var log = require("@marcom/ac-console/log");
            var select = require("@marcom/ac-clipboard/select");
            var Dialog = require("@marcom/ac-social").Dialog;
            var supplant = require("@marcom/ac-string/supplant");
            var Localization = require("../localization/Localization");
            var TabManager = require("@marcom/ac-accessibility/helpers/TabManager");
            var createAnalyticsObserver;
            try {
                createAnalyticsObserver = require("@marcom/ac-analytics-share/factory/create")
            } catch (err) {
                log("ac-analytics-share failed to load, are you sure you've included it?")
            }
            var userAgent = require("@marcom/ac-useragent");
            var os = userAgent.os;
            var IS_MOBILE = os.ios || os.android;
            var BREAKPOINT = 735;
            var SharingModule = function(options) {
                if (!this.el) {
                    this._initializeElement(options.el, options.template)
                }
                this._player = options.player;
                this._parentView = options.parentView;
                this._clickedShareButton = null;
                this._container = this.el.querySelector(".container");
                this._sharingButtonContainer = this.el.querySelector(".sharing-button-container");
                this._facebookButton = this.el.querySelector(".facebook-share");
                this._twitterButton = this.el.querySelector(".twitter-share");
                this._copyLinkButton = this.el.querySelector(".copy-link");
                this._copyEmbedCodeButton = this.el.querySelector(".copy-embed-code");
                this._copyTextArea = this.el.querySelector(".copy-area");
                this._copyCloseButton = this.el.querySelector(".textinput-close-button");
                this._closeButton = this.el.querySelector(".close-button");
                if (options.analytics === false) {
                    createAnalyticsObserver = null
                }
                if (IS_MOBILE) {
                    this.el.firstChild.classList.add("mobile");
                    this._player.on("loadstart", function() {
                        if (this._getClientWidth() > BREAKPOINT) {
                            this.el.firstChild.classList.add("mobile-large")
                        }
                    }.bind(this))
                }
                this._bindMethods();
                this._addEventListeners();
                this._syncSocialShareHidden()
            };
            var proto = SharingModule.prototype;
            proto._initializeElement = function(el, template) {
                if (!el) {
                    this.el = document.createElement("div");
                    this._templateData = Localization.getTranslation();
                    this.el.innerHTML = supplant((template || TEMPLATE).toString(), this._templateData)
                } else {
                    this.el = el
                }
            };
            proto.setData = function(data) {
                if (!data) {
                    this._parentView.hide();
                    return
                } else {
                    this._parentView.show()
                }
                if (data.allowEmbed) {
                    this.el.firstChild.classList.add("embed-enabled")
                }
                this._sharingUrl = data.originatorUrl || window.location.href;
                this._videoid = data.videoid;
                this._hideExtension = data.hideExtension;
                this._embedPath = data.embedpath || DEFAULT_EMBED_PATH;
                this._hideFacebook = data.hideFacebookShare || false;
                this._hideTwitter = data.hideTwitterShare || false;
                this._title = data.title || DEFAULT_TITLE;
                this._syncSocialShareHidden();
                this._container.classList.remove("textarea-active");
                if (createAnalyticsObserver && data.analytics !== false && data.videoid) {
                    try {
                        this._initAnalyticsAttributes(data);
                        if (!this._analyticsObserver) {
                            this._analyticsObserver = createAnalyticsObserver({
                                context: this.el
                            })
                        }
                    } catch (error) {
                        log("ac-analytics-share failed to load, are you sure you've included it?")
                    }
                }
            };
            proto._bindMethods = function() {
                this._doFacebookShare = this._doSocialShare.bind(this, Dialog.FACEBOOK_SHARE);
                this._doTwitterShare = this._doSocialShare.bind(this, Dialog.TWITTER_TWEET);
                this._copyUrl = this._copyUrl.bind(this);
                this._copyEmbedCode = this._copyEmbedCode.bind(this);
                this._closeCopyArea = this._showTextArea.bind(this, false);
                this._closeState = this._closeState.bind(this)
            };
            proto._addEventListeners = function() {
                this._facebookButton && this._facebookButton.addEventListener("click", this._doFacebookShare);
                this._twitterButton && this._twitterButton.addEventListener("click", this._doTwitterShare);
                this._copyLinkButton && this._copyLinkButton.addEventListener("click", this._copyUrl);
                this._copyEmbedCodeButton && this._copyEmbedCodeButton.addEventListener("click", this._copyEmbedCode);
                this._copyCloseButton && this._copyCloseButton.addEventListener("click", this._closeCopyArea);
                this._closeButton && this._closeButton.addEventListener("click", this._closeState)
            };
            proto._removeEventListeners = function() {
                this._facebookButton && this._facebookButton.removeEventListener("click", this._doFacebookShare);
                this._twitterButton && this._twitterButton.removeEventListener("click", this._doTwitterShare);
                this._copyLinkButton && this._copyLinkButton.removeEventListener("click", this._copyUrl);
                this._copyEmbedCodeButton && this._copyEmbedCodeButton.removeEventListener("click", this._copyEmbedCode);
                this._copyCloseButton && this._copyCloseButton.removeEventListener("click", this._closeCopyArea);
                this._closeButton && this._closeButton.removeEventListener("click", this._closeState)
            };
            proto._syncSocialShareHidden = function() {
                if (this._facebookButton) {
                    if (this._hideFacebook) {
                        this._facebookButton.classList.add("hide-button")
                    } else {
                        this._facebookButton.classList.remove("hide-button")
                    }
                }
                if (this._twitterButton) {
                    if (this._hideTwitter) {
                        this._twitterButton.classList.add("hide-button")
                    } else {
                        this._twitterButton.classList.remove("hide-button")
                    }
                }
            };
            proto._doSocialShare = function(network) {
                this._clickedShareButton = null;
                this._copyLinkButton.classList.remove("active");
                this._copyEmbedCodeButton.classList.remove("active");
                this._showTextArea(false);
                Dialog.create(network, {
                    url: this._sharingUrl,
                    title: this._title
                })
            };
            proto._showTextArea = function(show) {
                if (show) {
                    this._container.classList.add("textarea-active");
                    select(this._copyTextArea);
                    if (!IS_MOBILE) {
                        this._copyTextArea.setAttribute("readonly", "")
                    }
                } else {
                    this._container.classList.remove("textarea-active");
                    this._copyLinkButton.classList.remove("active");
                    this._copyEmbedCodeButton.classList.remove("active");
                    this._copyTextArea.removeAttribute("readonly");
                    if (this._clickedShareButton) {
                        this._clickedShareButton.focus()
                    }
                    this._copyLinkButton.setAttribute("aria-label", this._templateData.copylink);
                    this._copyEmbedCodeButton.setAttribute("aria-label", this._templateData.copyembed)
                }
            };
            proto._copyUrl = function() {
                this._clearTextArea();
                this._copyTextArea.value = this._sharingUrl;
                this._copyLinkButton.classList.add("active");
                this._copyLinkButton.setAttribute("aria-label", this._templateData.selectlink);
                this._showTextArea(true);
                this._clickedShareButton = this._copyLinkButton;
                this._copyTextArea.setAttribute("aria-label", this._templateData.copylink);
                select(this._copyTextArea)
            };
            proto._clearTextArea = function() {
                window.getSelection().removeAllRanges();
                this._copyLinkButton.classList.remove("active");
                this._copyEmbedCodeButton.classList.remove("active");
                this._copyTextArea.removeAttribute("readonly")
            };
            proto._copyEmbedCode = function() {
                this._clearTextArea();
                this._copyTextArea.value = supplant(EMBED_CODE_TEMPLATE, {
                    videoid: this._videoid,
                    embedCodePath: this._embedPath,
                    width: this._player.getMediaWidth(),
                    height: this._player.getMediaHeight(),
                    title: this._title,
                    extension: this._hideExtension ? "" : ".html"
                });
                this._copyEmbedCodeButton.classList.add("active");
                this._copyEmbedCodeButton.setAttribute("aria-label", this._templateData.selectembed);
                this._showTextArea(true);
                this._clickedShareButton = this._copyEmbedCodeButton;
                this._copyTextArea.setAttribute("aria-label", this._templateData.copyembed);
                select(this._copyTextArea)
            };
            proto._focusFirstButton = function() {
                if (!this._firstButton) {
                    this._firstButton = TabManager.getTabbableElements(this._sharingButtonContainer)[0]
                }
                this._firstButton.focus()
            };
            proto.show = function() {
                return new Promise(function(resolve, reject) {
                    requestAnimationFrame(function() {
                        var cb = function() {
                            this.el.removeEventListener("transitionend", cb);
                            if (focus) {
                                this._focusFirstButton()
                            }
                            resolve()
                        }.bind(this);
                        this.el.addEventListener("transitionend", cb);
                        setTimeout(function() {
                            this._container.classList.add("showing")
                        }.bind(this))
                    }.bind(this))
                }.bind(this))
            };
            proto.hide = function() {
                this._clickedShareButton = null;
                this._showTextArea(false);
                return new Promise(function(resolve, reject) {
                    var cb = function() {
                        this.el.removeEventListener("transitionend", cb);
                        resolve()
                    }.bind(this);
                    this.el.addEventListener("transitionend", cb);
                    setTimeout(function() {
                        this._container.classList.remove("showing")
                    }.bind(this))
                }.bind(this))
            };
            proto._getClientHeight = function() {
                return this.el.clientHeight
            };
            proto._getClientWidth = function() {
                return this.el.clientWidth
            };
            proto.destroy = function() {
                this._removeEventListeners()
            };
            proto._closeState = function() {
                this._showTextArea(false);
                if (this._player.getCurrentTime() === 0 || this._player.getEnded()) {
                    this._player.states.setState("initial")
                } else {
                    this._player.states.setState("none")
                }
            };
            proto._getAnalyticsSource = function() {
                return "drawer"
            };
            proto._initAnalyticsAttributes = function(data) {
                var buttons = [];
                this._facebookButton && buttons.push({
                    button: this._facebookButton,
                    title: "facebook",
                    events: "event85"
                });
                this._twitterButton && buttons.push({
                    button: this._twitterButton,
                    title: "twitter",
                    events: "event84"
                });
                this._copyLinkButton && buttons.push({
                    button: this._copyLinkButton,
                    title: "copy-link",
                    events: "event89"
                });
                this._copyEmbedCodeButton && buttons.push({
                    button: this._copyEmbedCodeButton,
                    title: "copy-embed-code",
                    events: "event101"
                });
                var fileType = ((data.url && data.url.indexOf(".m3u8")) !== -1 ? "m3u8" : "mp4") + " via html5";
                var evar70 = this._getAnalyticsSource();
                var name = data.videoid;
                var analyticsTrackMeta = document.head.querySelectorAll('meta[property="analytics-track"]');
                analyticsTrackMeta = analyticsTrackMeta ? analyticsTrackMeta[0].getAttribute("content") : "";
                buttons.forEach(function(btn) {
                    btn.button.setAttribute("data-analytics-click", "");
                    btn.button.setAttribute("data-analytics-share", JSON.stringify({
                        title: name,
                        events: btn.events,
                        prop2: analyticsTrackMeta + " - " + name + " - " + btn.title,
                        prop18: fileType,
                        eVar49: document.referrer,
                        eVar54: document.location.href,
                        eVar55: analyticsTrackMeta + " - " + name,
                        eVar70: evar70
                    }))
                }.bind(this))
            };
            module.exports = SharingModule
        }).call(this, require("buffer").Buffer)
    }, {
        "../localization/Localization": 544,
        "@marcom/ac-accessibility/helpers/TabManager": 407,
        "@marcom/ac-analytics-share/factory/create": 18,
        "@marcom/ac-clipboard/select": 419,
        "@marcom/ac-console/log": 421,
        "@marcom/ac-social": 481,
        "@marcom/ac-string/supplant": 402,
        "@marcom/ac-useragent": 403,
        buffer: 280
    }],
    550: [function(require, module, exports) {
        "use strict";
        var EventEmitterMicro = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var BreakpointDetect = function(options) {
            EventEmitterMicro.call(this);
            this.el = options.el || document.body;
            this.breakpoints = options.breakpoints.sort(function(a, b) {
                return a.minWidth - b.minWidth
            });
            this._breakPointsLength = this.breakpoints.length;
            this._addClasses = options.addClass;
            this._addEventListeners();
            this._onResize()
        };
        var superProto = EventEmitterMicro.prototype;
        var proto = BreakpointDetect.prototype = Object.create(superProto);
        proto.constructor = BreakpointDetect;
        proto._addEventListeners = function() {
            var self = this;
            this._boundOnResize = function() {
                self._onResize.apply(self, arguments)
            };
            window.addEventListener("resize", this._boundOnResize);
            window.addEventListener("orientationchange", this._boundOnResize);
            window.addEventListener("DOMContentLoaded", this._boundOnResize)
        };
        proto._removeEventListeners = function() {
            window.removeEventListener("resize", this._boundOnResize);
            window.removeEventListener("orientationchange", this._boundOnResize);
            window.addEventListener("DOMContentLoaded", this._boundOnResize)
        };
        proto._onResize = function() {
            var clientWidth = this.el.clientWidth;
            var currentBP = this._currentBreakpoint;
            if (currentBP && BreakpointDetect.widthInBreakpoint(clientWidth, currentBP)) {
                return
            }
            var newBreakpoint = BreakpointDetect.getBreakpointFromWidth(clientWidth, this.breakpoints, currentBP, this._breakPointsLength);
            if (this._addClasses) {
                this._currentBreakpoint && this.el.classList.remove(currentBP.name);
                this.el.classList.add(newBreakpoint.name)
            }
            this._currentBreakpoint = newBreakpoint;
            this.trigger("breakpointchange", newBreakpoint)
        };
        proto.getCurrentBreakpoint = function() {
            return this._currentBreakpoint
        };
        proto.refresh = function() {
            this._onResize()
        };
        proto.destroy = function() {
            this._removeEventListeners();
            superProto.destroy.call(this)
        };
        BreakpointDetect.getBreakpointFromElement = function(el, breakpoints) {
            return BreakpointDetect.getBreakpointFromWidth(el.clientWidth, breakpoints)
        };
        BreakpointDetect.getBreakpointFromWidth = function(clientWidth, breakpoints, excludeBP, cachedLength) {
            var i = 0;
            var len = cachedLength || breakpoints.length;
            for (; i < len; i++) {
                var bp = breakpoints[i];
                if (bp === excludeBP) {
                    continue
                }
                if (clientWidth >= bp.minWidth && clientWidth <= bp.maxWidth) {
                    return bp
                }
            }
        };
        BreakpointDetect.widthInBreakpoint = function(clientWidth, breakpoint) {
            return clientWidth >= breakpoint.minWidth && clientWidth <= breakpoint.maxWidth
        };
        module.exports = BreakpointDetect
    }, {
        "@marcom/ac-event-emitter-micro": 422
    }],
    551: [function(require, module, exports) {
        "use strict";
        var supplant = require("@marcom/ac-string/supplant");
        var Time = {
            addLeadingZero: function(number, size) {
                size = size || 2;
                if (number < 10 || size > 2) {
                    number = String(number);
                    while (number.length < size) {
                        number = "0" + number
                    }
                }
                return number
            },
            formatTime: function(time, totalTime, leadingZero) {
                if (isNaN(time)) {
                    return "00:00"
                }
                time = this.splitTime(Math.floor(time), totalTime, function(number) {
                    return this.addLeadingZero(number, leadingZero)
                }.bind(this));
                var template;
                if (totalTime >= 3600) {
                    template = "{PN}{hours}:{minutes}:{seconds}"
                } else {
                    template = "{PN}{minutes}:{seconds}"
                }
                var currentTime = supplant(template, {
                    PN: time.negativeModifier,
                    hours: time.hours,
                    minutes: time.minutes,
                    seconds: time.seconds
                });
                return currentTime
            },
            splitTime: function(seconds, totalTime, formatingFunction) {
                formatingFunction = formatingFunction || function(number) {
                    return number
                };
                var time = {
                    negativeModifier: "",
                    hours: 0,
                    minutes: 0,
                    seconds: 0
                };
                if (isNaN(seconds)) {
                    return time
                }
                time.negativeModifier = seconds < 0 ? "-" : "";
                seconds = Math.abs(seconds);
                time.hours = totalTime >= 3600 ? Math.floor(seconds / 3600) : 0;
                time.minutes = time.hours ? Math.floor(seconds / 60 % 60) : Math.floor(seconds / 60);
                time.seconds = seconds % 60;
                for (var property in time) {
                    if (typeof time[property] !== "number") {
                        continue
                    }
                    if (property !== "hours") {
                        time[property] = formatingFunction(time[property])
                    }
                }
                return time
            },
            stringToNumber: function(timeString) {
                var time = 0;
                var split = timeString.split(":");
                while (split.length) {
                    if (split.length === 3) {
                        time += parseFloat(split.shift()) * 3600
                    } else if (split.length === 2) {
                        time += parseFloat(split.shift()) * 60
                    } else {
                        time += parseFloat(split.shift())
                    }
                }
                return time
            }
        };
        module.exports = Time
    }, {
        "@marcom/ac-string/supplant": 402
    }],
    552: [function(require, module, exports) {
        "use strict";
        var clone = require("@marcom/ac-object/clone");
        var merge = function() {
            var args = Array.prototype.slice.call(arguments);
            if (args.length < 2) {
                return clone(args[0])
            }
            var dest = clone(args.shift(), true);
            var source = args.shift();
            for (var prop in source) {
                if (source.hasOwnProperty(prop)) {
                    if (!dest.hasOwnProperty(prop) || typeof dest[prop] !== "object") {
                        dest[prop] = source[prop]
                    } else if (typeof dest[prop] === "object" && typeof source[prop] === "object") {
                        dest[prop] = merge(dest[prop], source[prop])
                    }
                }
            }
            if (args.length) {
                return merge.apply(null, [dest].concat(args))
            } else {
                return dest
            }
        };
        module.exports = merge
    }, {
        "@marcom/ac-object/clone": 445
    }],
    553: [function(require, module, exports) {
        "use strict";
        module.exports = [{
            width: 384,
            height: 160,
            type: "baseline-high",
            suffix: "h"
        }, {
            width: 384,
            height: 160,
            type: "small",
            suffix: "h"
        }, {
            width: 384,
            height: 160,
            type: "baseline-low",
            suffix: "l"
        }, {
            width: 384,
            height: 160,
            type: "baseline-medium",
            suffix: "m"
        }, {
            width: 480,
            height: 200,
            type: "medium",
            suffix: "h"
        }, {
            width: 768,
            height: 320,
            type: "large",
            suffix: ""
        }, {
            width: 960,
            height: 400,
            type: "large",
            suffix: ""
        }, {
            width: 1536,
            height: 640,
            type: "large",
            suffix: "h"
        }, {
            width: 1536,
            height: 640,
            type: "large",
            suffix: "l"
        }, {
            width: 1920,
            height: 800,
            type: "large",
            suffix: "l"
        }, {
            width: 1920,
            height: 800,
            type: "large",
            suffix: "h"
        }]
    }, {}],
    554: [function(require, module, exports) {
        "use strict";
        module.exports = [{
            width: 416,
            height: 234,
            type: "baseline-high",
            suffix: "h"
        }, {
            width: 416,
            height: 234,
            type: "small",
            suffix: "h"
        }, {
            width: 416,
            height: 234,
            type: "baseline-low",
            suffix: "l"
        }, {
            width: 416,
            height: 234,
            type: "baseline-medium",
            suffix: "m"
        }, {
            width: 640,
            height: 360,
            type: "medium",
            suffix: "h"
        }, {
            width: 848,
            height: 480,
            type: "large",
            suffix: ""
        }, {
            width: 960,
            height: 540,
            type: "large",
            suffix: ""
        }, {
            width: 1280,
            height: 720,
            type: "large",
            suffix: "h"
        }, {
            width: 1280,
            height: 720,
            type: "large",
            suffix: "l"
        }, {
            width: 1920,
            height: 1080,
            type: "large",
            suffix: "l"
        }, {
            width: 1920,
            height: 1080,
            type: "large",
            suffix: "h"
        }]
    }, {}],
    555: [function(require, module, exports) {
        "use strict";
        module.exports = [{
            width: 528,
            height: 244,
            type: "baseline-high",
            suffix: "h"
        }, {
            width: 528,
            height: 244,
            type: "small",
            suffix: "h"
        }, {
            width: 528,
            height: 244,
            type: "baseline-low",
            suffix: "l"
        }, {
            width: 528,
            height: 244,
            type: "baseline-medium",
            suffix: "m"
        }, {
            width: 812,
            height: 375,
            type: "medium",
            suffix: "h"
        }, {
            width: 1082,
            height: 500,
            type: "large",
            suffix: ""
        }, {
            width: 1218,
            height: 563,
            type: "large",
            suffix: ""
        }, {
            width: 1624,
            height: 750,
            type: "large",
            suffix: "h"
        }, {
            width: 1624,
            height: 750,
            type: "large",
            suffix: "l"
        }, {
            width: 2436,
            height: 1126,
            type: "large",
            suffix: "l"
        }, {
            width: 2436,
            height: 1126,
            type: "large",
            suffix: "h"
        }]
    }, {}],
    556: [function(require, module, exports) {
        "use strict";
        module.exports = [{
            width: 360,
            height: 360,
            type: "baseline-high",
            suffix: "h"
        }, {
            width: 360,
            height: 360,
            type: "small",
            suffix: "h"
        }, {
            width: 360,
            height: 360,
            type: "baseline-low",
            suffix: "l"
        }, {
            width: 480,
            height: 480,
            type: "medium",
            suffix: ""
        }, {
            width: 540,
            height: 540,
            type: "medium",
            suffix: ""
        }, {
            width: 720,
            height: 720,
            type: "large",
            suffix: "h"
        }, {
            width: 720,
            height: 720,
            type: "large",
            suffix: "l"
        }, {
            width: 1080,
            height: 1080,
            type: "large",
            suffix: "l"
        }, {
            width: 1080,
            height: 1080,
            type: "large",
            suffix: "h"
        }]
    }, {}],
    557: [function(require, module, exports) {
        "use strict";
        var supplant = require("@marcom/ac-string/supplant");
        var LEGACY_REF_PATTERN = /_r[0-9].+\.mov$/;
        var REF_PATTERN = /_[0-9]+x[0-9].+\.mp4$/;
        var URL_SIZE = /_([0-9]+)x([0-9]+)/;
        var HAS_THUMBNAILS_PATTERN = /-tpl-.*-/;
        var HAS_CC_PATTERN = /-cc-[a-z].*-/;
        var IS_12X5_PATTERN = /-tft-.*-/;
        var m = "m";
        var VAT_SOURCE_TEMPLATE = "_{width}x{height}{suffix}." + m + "p4";
        var VAT_SOURCE_TEMPLATE_VERTICAL = "_{height}x{width}{suffix}." + m + "p4";
        var j = "j";
        var THUMBNAILS_SUFFIX = "_thumbnails." + j + "pg";
        var _1X1_ASSET_SIZES = require("./1X1AssetSizes");
        var _16X9_ASSET_SIZES = require("./16X9AssetSizes");
        var _12X5_ASSET_SIZES = require("./12X5AssetSizes");
        var _19X9_ASSET_SIZES = require("./19X9AssetSizes");
        var containsMatch = function(array, urlSize) {
            return array.find(function(size) {
                return size.width === urlSize.width && (size.height = urlSize.height) || size.width === urlSize.height && (size.height = urlSize.width)
            })
        };
        var getVideoSource = function(originalUrl, width, type, options) {
            var sizes;
            var defaultMaxWidth;
            URL_SIZE.test(originalUrl);
            var urlSize = {};
            var isVertical;
            urlSize.width = parseInt(RegExp.$1, 10);
            urlSize.height = parseInt(RegExp.$2, 10);
            if (originalUrl.match(IS_12X5_PATTERN)) {
                sizes = _12X5_ASSET_SIZES;
                defaultMaxWidth = 1536
            } else if (urlSize.width === urlSize.height) {
                sizes = _1X1_ASSET_SIZES;
                defaultMaxWidth = 1080
            } else if (originalUrl.match(LEGACY_REF_PATTERN) || containsMatch(_16X9_ASSET_SIZES, urlSize)) {
                sizes = _16X9_ASSET_SIZES;
                defaultMaxWidth = 1280
            } else if (containsMatch(_19X9_ASSET_SIZES, urlSize)) {
                sizes = _19X9_ASSET_SIZES;
                defaultMaxWidth = 1624
            } else {
                return originalUrl
            }
            if (urlSize.width < urlSize.height) {
                isVertical = true
            }
            var minimumWidth = sizes[0].width;
            var maxWidth = options && options.maxWidth ? Math.max(options.maxWidth, minimumWidth) : defaultMaxWidth;
            if (!originalUrl) {
                throw "Must provide an url to optimize"
            }
            if (width === undefined || isNaN(width)) {
                throw "Must provide a width"
            }
            if (width === 0) {
                width = urlSize.width
            }
            if (type) {
                sizes = sizes.filter(function(size) {
                    return size.type === type
                })
            }
            if (maxWidth < 1920) {
                sizes = sizes.filter(function(size) {
                    return size.width <= maxWidth
                })
            }
            var sourceData;
            if (!isVertical) {
                sourceData = sizes.reduce(function(prev, curr) {
                    return Math.abs(curr.width - width) < Math.abs(prev.width - width) ? curr : prev
                })
            } else {
                sourceData = sizes.reduce(function(prev, curr) {
                    return Math.abs(curr.height - width) < Math.abs(prev.height - width) ? curr : prev
                })
            }
            var vatTemplate = VAT_SOURCE_TEMPLATE;
            if (isVertical) {
                vatTemplate = VAT_SOURCE_TEMPLATE_VERTICAL
            }
            if (originalUrl.match(REF_PATTERN)) {
                return originalUrl.replace(REF_PATTERN, supplant(vatTemplate, sourceData))
            } else if (originalUrl.match(LEGACY_REF_PATTERN)) {
                return originalUrl.replace(LEGACY_REF_PATTERN, supplant(vatTemplate, sourceData))
            } else {
                return originalUrl
            }
        };
        var getCaptionsSource = function(url) {
            if (!url.match(HAS_CC_PATTERN)) {
                return null
            }
            if (url.match(REF_PATTERN)) {
                return {
                    src: url.replace(REF_PATTERN, "_cc.vtt"),
                    srclang: "en"
                }
            } else if (url.match(LEGACY_REF_PATTERN)) {
                return {
                    src: url.replace(LEGACY_REF_PATTERN, "_cc.vtt"),
                    srclang: "en"
                }
            } else {
                return null
            }
        };
        var getThumbnailImageSource = function(url) {
            if (!url.match(HAS_THUMBNAILS_PATTERN)) {
                return null
            } else {
                return {
                    url: url.replace(REF_PATTERN, THUMBNAILS_SUFFIX)
                }
            }
        };
        module.exports = {
            getVideoSource: getVideoSource,
            getCaptionsSource: getCaptionsSource,
            getThumbnailImageSource: getThumbnailImageSource
        }
    }, {
        "./12X5AssetSizes": 553,
        "./16X9AssetSizes": 554,
        "./19X9AssetSizes": 555,
        "./1X1AssetSizes": 556,
        "@marcom/ac-string/supplant": 402
    }],
    558: [function(require, module, exports) {
        "use strict";
        var DOMEmitter = require("../dom-emitter/DOMEmitterMicro");
        var createTextTracks = require("../texttracks/createTextTracks");
        var log = require("@marcom/ac-console/log");
        var doc = window.document;
        var Video = function(options) {
            this._videoElement = options && options.mediaElement ? options.mediaElement : doc.createElement("video");
            this.options = options || {};
            this._textTracks = createTextTracks(options);
            this._initElement();
            DOMEmitter.apply(this, [this._videoElement]);
            this._forwardCaptionEvent = this._forwardCaptionEvent.bind(this);
            this._textTracksEmitter = this.getTextTracksEventEmitter();
            this._textTracksEmitter.on("addtrack", this._forwardCaptionEvent);
            this._textTracksEmitter.on("change", this._forwardCaptionEvent);
            this._textTracksEmitter.on("removetrack", this._forwardCaptionEvent)
        };
        var proto = Video.prototype = Object.create(DOMEmitter.prototype);
        proto._initElement = function() {
            this._videoElement.classList.add("ac-video-media-controller");
            if (this.options.crossorigin !== null) {
                this._videoElement.setAttribute("crossorigin", this.options.crossorigin ? this.options.crossorigin : "anonymous")
            }
            this._videoElement.setAttribute("preload", this.options.preload || "auto");
            this._videoElement.setAttribute("x-webkit-airplay", "")
        };
        proto._forwardCaptionEvent = function(evt) {
            this.trigger(evt.type)
        };
        proto.load = function(sourceUrls, textTracks, startTime) {
            if (startTime) {
                sourceUrls = sourceUrls.map(function(url) {
                    return url + "#t=" + startTime
                })
            }
            this._createSourceTags(sourceUrls);
            this._createTextTrackTags(textTracks);
            this._videoElement.load()
        };
        proto._createSourceTags = function(sourceUrls) {
            this._videoElement.removeAttribute("src");
            this._videoElement.innerHTML = "";
            var i = 0;
            var len = sourceUrls.length;
            if (len) {
                this._videoElement.setAttribute("src", sourceUrls[0])
            }
            for (; i < len; i++) {
                var source = doc.createElement("source");
                source.src = sourceUrls[i];
                this._videoElement.appendChild(source)
            }
        };
        proto.play = function() {
            try {
                var promise = this._videoElement.play();
                if (promise && typeof promise["catch"] === "function") {
                    promise["catch"](function(err) {
                        if (this._playPromise === promise) {
                            this.trigger("PlayPromiseError")
                        }
                    }.bind(this))
                }
                this._playPromise = promise
            } catch (err) {
                log(err)
            }
        };
        proto.pause = function() {
            this._playPromise = null;
            this._videoElement.pause()
        };
        proto.addTextTrack = function(trackObject) {
            this._addTextTrackTag(trackObject)
        };
        proto.removeTextTrack = function(trackObject) {
            this._removeTextTrackTag(trackObject)
        };
        proto.getMediaElement = function() {
            return this._videoElement
        };
        proto._createTextTrackTags = function() {
            return this._textTracks.create.apply(this, arguments)
        };
        proto._addTextTrackTag = function() {
            return this._textTracks.add.apply(this, arguments)
        };
        proto._removeTextTrackTag = function() {
            return this._textTracks.remove.apply(this, arguments)
        };
        proto.getTextTracks = function() {
            return this._textTracks.get.apply(this, arguments)
        };
        proto.getTextTracksEventEmitter = function() {
            return this._textTracks.getEmitter.apply(this, arguments)
        };
        proto.getReadyState = function() {
            return this._videoElement.readyState
        };
        proto.getPreload = function() {
            return this._videoElement.preload
        };
        proto.setPreload = function(value) {
            return this._videoElement.preload = value
        };
        proto.setPoster = function(url) {
            this._videoElement.poster = url
        };
        proto.getVolume = function() {
            return this._videoElement.volume
        };
        proto.getMuted = function() {
            return this._videoElement.muted
        };
        proto.getPaused = function() {
            return this._videoElement.paused
        };
        proto.getCurrentTime = function() {
            return this._videoElement.currentTime
        };
        proto.getDuration = function() {
            return this._videoElement.duration
        };
        proto.setCurrentTime = function(time) {
            return this._videoElement.currentTime = time
        };
        proto.setVolume = function(volume) {
            return this._videoElement.volume = volume
        };
        proto.setMuted = function(muted) {
            this._videoElement.muted = muted
        };
        proto.getEnded = function() {
            return this._videoElement.ended
        };
        proto.setSrc = function(url) {
            if (!this._videoElement.childNodes.length || url !== this._getSrcNode().url) {
                this._createSourceTags([url])
            }
        };
        proto.getCurrentSrc = function() {
            return this._getSrcNode()
        };
        proto._getSrcNode = function() {
            return this._videoElement.childNodes[0]
        };
        proto.setControls = function(enable) {
            if (!enable) {
                this._videoElement.removeAttribute("controls");
                this._videoElement.setAttribute("aria-hidden", "true")
            } else {
                this._videoElement.setAttribute("controls", "");
                this._videoElement.removeAttribute("aria-hidden")
            }
        };
        proto.isFullscreen = function() {
            return this._videoElement.webkitDisplayingFullscreen
        };
        proto.supportsPictureInPicture = function() {
            return typeof this._videoElement.webkitSetPresentationMode === "function"
        };
        proto.isPictureInPicture = function() {
            return this._videoElement.webkitPresentationMode === "picture-in-picture"
        };
        proto.setPictureInPicture = function(enable) {
            if (!this.supportsPictureInPicture()) {
                return
            }
            this._videoElement.webkitSetPresentationMode(enable ? "picture-in-picture" : "inline")
        };
        proto.supportsAirPlay = function() {
            return !!window.WebKitPlaybackTargetAvailabilityEvent
        };
        proto.destroy = function() {
            this._textTracks.destroy();
            this._textTracksEmitter.off("addtrack", this._forwardCaptionEvent);
            this._textTracksEmitter.off("change", this._forwardCaptionEvent);
            this._textTracksEmitter.off("removetrack", this._forwardCaptionEvent);
            this._textTracks = null;
            this._textTracksEmitter = null;
            this._videoElement = null
        };
        module.exports = Video
    }, {
        "../dom-emitter/DOMEmitterMicro": 501,
        "../texttracks/createTextTracks": 515,
        "@marcom/ac-console/log": 421
    }],
    559: [function(require, module, exports) {
        "use strict";
        var HTML5Video = require("./HTML5Video");
        var VideoFactory = function() {};
        var proto = VideoFactory.prototype;
        proto.create = function(options, parentElement) {
            return new HTML5Video(Object.assign({}, options, {
                parentElement: parentElement
            }))
        };
        module.exports = Object.create(VideoFactory.prototype)
    }, {
        "./HTML5Video": 558
    }],
    560: [function(require, module, exports) {
        arguments[4][11][0].apply(exports, arguments)
    }, {
        dup: 11
    }],
    561: [function(require, module, exports) {
        arguments[4][13][0].apply(exports, arguments)
    }, {
        "./ac-event-emitter-micro/EventEmitterMicro": 562,
        dup: 13
    }],
    562: [function(require, module, exports) {
        arguments[4][14][0].apply(exports, arguments)
    }, {
        dup: 14
    }],
    563: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Function/prototype.bind");
        require("@marcom/ac-polyfills/Object/keys");
        require("@marcom/ac-polyfills/Object/create");
        var EventEmitter = require("@marcom/ac-event-emitter-micro").EventEmitterMicro;
        var ac_addEventListener = require("@marcom/ac-dom-events/utils/addEventListener");
        var mediaQueriesAvailable = require("@marcom/ac-feature/mediaQueriesAvailable");
        var DEFAULT_ID = "viewport-emitter";
        var PSEUDO_SELECTOR = "::before";
        var RETINA_QUERY = "only screen and (-webkit-min-device-pixel-ratio: 1.5), screen and (min-resolution: 1.5dppx), screen and (min-resolution: 144dpi)";

        function ViewportEmitter(id) {
            EventEmitter.call(this);
            this._initializeElement(id);
            if (mediaQueriesAvailable()) {
                this._updateViewport = this._updateViewport.bind(this);
                ac_addEventListener(window, "resize", this._updateViewport);
                ac_addEventListener(window, "orientationchange", this._updateViewport);
                this._retinaQuery = window.matchMedia(RETINA_QUERY);
                this._updateRetina();
                if (this._retinaQuery.addListener) {
                    this._updateRetina = this._updateRetina.bind(this);
                    this._retinaQuery.addListener(this._updateRetina)
                }
            }
            this._updateViewport()
        }
        var proto = ViewportEmitter.prototype = Object.create(EventEmitter.prototype);
        proto.viewport = false;
        proto.retina = false;
        proto._initializeElement = function(id) {
            var el;
            id = id || DEFAULT_ID;
            el = document.getElementById(id);
            if (!el) {
                el = document.createElement("div");
                el.id = id;
                el = document.body.appendChild(el)
            }
            this._el = el
        };
        proto._getElementContent = function() {
            var content;
            if ("currentStyle" in this._el) {
                content = this._el.currentStyle["x-content"]
            } else {
                this._invalidateStyles();
                content = window.getComputedStyle(this._el, PSEUDO_SELECTOR).content
            }
            if (content) {
                content = content.replace(/["']/g, "")
            }
            if (content) {
                return content
            }
            return false
        };
        proto._updateViewport = function() {
            var lastViewport = this.viewport;
            var style;
            var eventData;
            this.viewport = this._getElementContent();
            if (this.viewport) {
                this.viewport = this.viewport.split(":").pop()
            }
            if (lastViewport && this.viewport !== lastViewport) {
                eventData = {
                    from: lastViewport,
                    to: this.viewport
                };
                this.trigger("change", eventData);
                this.trigger("from:" + lastViewport, eventData);
                this.trigger("to:" + this.viewport, eventData)
            }
        };
        proto._updateRetina = function(query) {
            var lastRetina = this.retina;
            this.retina = this._retinaQuery.matches;
            if (lastRetina !== this.retina) {
                this.trigger("retinachange", {
                    from: lastRetina,
                    to: this.retina
                })
            }
        };
        proto._invalidateStyles = function() {
            document.documentElement.clientWidth;
            this._el.innerHTML = this._el.innerHTML === " " ? "Â " : " ";
            document.documentElement.clientWidth
        };
        module.exports = ViewportEmitter
    }, {
        "@marcom/ac-dom-events/utils/addEventListener": 560,
        "@marcom/ac-event-emitter-micro": 561,
        "@marcom/ac-feature/mediaQueriesAvailable": 165,
        "@marcom/ac-polyfills/Function/prototype.bind": 394,
        "@marcom/ac-polyfills/Object/create": 396,
        "@marcom/ac-polyfills/Object/keys": 397
    }],
    564: [function(require, module, exports) {
        "use strict";
        var ViewportEmitter = require("./ViewportEmitter");
        module.exports = new ViewportEmitter
    }, {
        "./ViewportEmitter": 563
    }],
    565: [function(require, module, exports) {
        "use strict";
        module.exports = {
            lerp: function(ratio, start, end) {
                return start + (end - start) * ratio
            },
            map: function(val, min1, max1, min2, max2) {
                return this.lerp(this.norm(val, min1, max1), min2, max2)
            },
            mapClamp: function(val, min1, max1, min2, max2) {
                var val = this.lerp(this.norm(val, min1, max1), min2, max2);
                return Math.max(min2, Math.min(max2, val))
            },
            norm: function(val, min, max) {
                return (val - min) / (max - min)
            },
            clamp: function(val, min, max) {
                return Math.max(min, Math.min(max, val))
            },
            randFloat: function(min, max) {
                return Math.random() * (max - min) + min
            },
            randInt: function(min, max) {
                return Math.floor(Math.random() * (max - min) + min)
            }
        }
    }, {}],
    566: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Object/create");
        var EnabledFeatures = require("@marcom/ac-jetpack-lib/model/EnabledFeatures");
        var BaseComponent = require("@marcom/ac-jetpack-lib/core/BaseComponent");
        var superclass = BaseComponent.prototype;

        function CardGridResizerComponent(section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index) {
            this.name = "CardGridResizerComponent_" + index;
            BaseComponent.call(this, section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index);
            this.cardGridWrapper = componentElement;
            this.cardElements = componentElement.querySelectorAll(".card");
            this.numberOfColumns = this._getNumberOfColumnsInRow();
            this._resizeGridToEvenPixel();
            this._resizeCardHeightsToEvenPixel()
        }
        var proto = CardGridResizerComponent.prototype = Object.create(BaseComponent.prototype);
        CardGridResizerComponent.prototype.constructor = CardGridResizerComponent;
        proto._getNumberOfColumnsInRow = function() {
            var offsetTopValue = 0;
            var columns = 0;
            for (var i = this.cardElements.length - 1; i >= 0; i--) {
                if (this.cardElements[i].offsetTop === 0) {
                    columns++
                }
            }
            return columns
        };
        proto._resizeGridToEvenPixel = function() {
            var originalGridWidth = this.cardGridWrapper.clientWidth;
            var newGridWidth = originalGridWidth - originalGridWidth % this.numberOfColumns;
            this.cardGridWrapper.style.width = newGridWidth + "px"
        };
        proto._resizeCardHeightsToEvenPixel = function() {
            var newHeight = this.cardElements[0].clientHeight - 1;
            for (var i = this.cardElements.length - 1; i >= 0; i--) {
                this.cardElements[i].style.height = newHeight + "px"
            }
        };
        proto.onResizeImmediate = function(e, scrollPosition, windowHeight) {
            superclass.onResizeImmediate.call(this, e, scrollPosition, windowHeight);
            if (this.cardGridWrapper.style.width === "100%") {
                return
            }
            for (var i = this.cardElements.length - 1; i >= 0; i--) {
                this.cardElements[i].style.height = "auto"
            }
            this.cardGridWrapper.style.width = "100%"
        };
        proto.onResizeDebounced = function(e, scrollPosition, windowHeight) {
            superclass.onResizeDebounced.call(this, e, scrollPosition, windowHeight);
            this.numberOfColumns = this._getNumberOfColumnsInRow();
            this._resizeGridToEvenPixel();
            this._resizeCardHeightsToEvenPixel()
        };
        CardGridResizerComponent.IS_SUPPORTED = function() {
            if (EnabledFeatures.TOUCH) return false;
            return true
        };
        module.exports = CardGridResizerComponent
    }, {
        "@marcom/ac-jetpack-lib/core/BaseComponent": 371,
        "@marcom/ac-jetpack-lib/model/EnabledFeatures": 377,
        "@marcom/ac-polyfills/Object/create": 396
    }],
    567: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Object/create");
        var EnabledFeatures = require("@marcom/ac-jetpack-lib/model/EnabledFeatures");
        var BaseComponent = require("@marcom/ac-jetpack-lib/core/BaseComponent");
        var superclass = BaseComponent.prototype;
        var viewportEmitter = require("@marcom/ac-viewport-emitter");
        var FluidGridBreakpoints = require("../model/FluidGridBreakpoints");
        var CARD_ACTIVE_CLASSNAME = "card-active";

        function CardManagerComponent(section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index) {
            this.name = "CardManagerComponent_" + index;
            BaseComponent.call(this, section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index);
            this.cardElements = this.element.querySelectorAll(".card");
            this.heroBackgroundElement = document.querySelector(".hero-video-container");
            this.shouldActivateCards = this._isOneColumnGrid();
            this.cardEngagementOptions = {
                timeToEngage: 100,
                inViewThreshold: .8
            };
            this._onCardElementEngaged = this._onCardElementEngaged.bind(this)
        }
        var proto = CardManagerComponent.prototype = Object.create(BaseComponent.prototype);
        CardManagerComponent.prototype.constructor = CardManagerComponent;
        proto._onCardElementEngaged = function(evt) {
            if (!this.shouldActivateCards) {
                return
            }
            this._deactivateAllCards();
            this._deactivateHeroSection();
            evt.element.classList.add(CARD_ACTIVE_CLASSNAME)
        };
        proto._deactivateAllCards = function() {
            for (var i = this.cardElements.length - 1; i >= 0; i--) {
                var cardElement = this.cardElements[i];
                cardElement.classList.remove(CARD_ACTIVE_CLASSNAME)
            }
        };
        proto._activateHeroSection = function() {
            this.heroBackgroundElement.style.opacity = 1
        };
        proto._deactivateHeroSection = function() {
            this.heroBackgroundElement.style.opacity = 0
        };
        proto._isOneColumnGrid = function() {
            if (screen.width > FluidGridBreakpoints.oneColumnMaxWidth) {
                return false
            }
            return this.element.clientWidth < FluidGridBreakpoints.oneColumnMaxWidth
        };
        proto.setupEvents = function() {
            superclass.setupEvents.call(this);
            for (var i = this.cardElements.length - 1; i >= 0; i--) {
                var cardElement = this.cardElements[i];
                var trackedCardElement = this.section.elementEngagement.addElement(cardElement, this.cardEngagementOptions);
                trackedCardElement.on("engaged", this._onCardElementEngaged)
            }
        };
        proto.deactivate = function() {
            superclass.deactivate.call(this);
            this._deactivateAllCards();
            this._activateHeroSection()
        };
        proto.onOrientationChange = function(e, orientation, scrollPosition, windowHeight) {
            superclass.onOrientationChange.call(this, e, orientation, scrollPosition, windowHeight);
            this.shouldActivateCards = this._isOneColumnGrid();
            if (!this.shouldActivateCards) {
                this.deactivate()
            }
        };
        proto.onResizeDebounced = function(e, scrollPosition, windowHeight) {
            superclass.onResizeDebounced.call(this, e, scrollPosition, windowHeight);
            this.shouldActivateCards = this._isOneColumnGrid();
            if (!this.shouldActivateCards) {
                this.deactivate()
            }
        };
        CardManagerComponent.IS_SUPPORTED = function() {
            return EnabledFeatures.TOUCH
        };
        module.exports = CardManagerComponent
    }, {
        "../model/FluidGridBreakpoints": 577,
        "@marcom/ac-jetpack-lib/core/BaseComponent": 371,
        "@marcom/ac-jetpack-lib/model/EnabledFeatures": 377,
        "@marcom/ac-polyfills/Object/create": 396,
        "@marcom/ac-viewport-emitter": 564
    }],
    568: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Object/create");
        var EnabledFeatures = require("@marcom/ac-jetpack-lib/model/EnabledFeatures");
        var BaseComponent = require("@marcom/ac-jetpack-lib/core/BaseComponent");
        var superclass = BaseComponent.prototype;
        var MathUtils = require("@marcom/sm-math-utils");
        var BrowserPrefixed = require("@marcom/ac-browser-prefixed");
        var viewportEmitter = require("@marcom/ac-viewport-emitter");
        var VIDEO_CLASSNAME = "hero-video";
        var VIDEO_PATH_ATTRIBUTE = "data-video-path";

        function HeroBackgroundVideoComponent(section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index) {
            this.name = "HeroBackgroundVideoComponent_" + index;
            BaseComponent.call(this, section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index);
            this.currentBreakpoint = currentBreakpoint;
            this.videoPath = this.element.getAttribute(VIDEO_PATH_ATTRIBUTE);
            this._injectHeroBackgroundVideo()
        }
        var proto = HeroBackgroundVideoComponent.prototype = Object.create(BaseComponent.prototype);
        HeroBackgroundVideoComponent.prototype.constructor = HeroBackgroundVideoComponent;
        proto._injectHeroBackgroundVideo = function() {
            if (this.video) {
                this.element.removeChild(this.video)
            }
            var videoPath = this.videoPath + "_" + this.currentBreakpoint + ".mp4";
            this.video = document.createElement("video");
            this.video.classList.add(VIDEO_CLASSNAME);
            this.video.loop = true;
            this.video.muted = true;
            this.video.src = videoPath;
            this.element.appendChild(this.video)
        };
        proto.setupEvents = function() {
            superclass.setupEvents.call(this);
            this._onCanPlayThrough = this._onCanPlayThrough.bind(this);
            this.video.addEventListener("canplaythrough", this._onCanPlayThrough)
        };
        proto._onCanPlayThrough = function() {
            this._play()
        };
        proto.onSectionWillAppear = function(scrollPosition, windowHeight) {
            superclass.onSectionWillAppear.call(this, scrollPosition, windowHeight);
            this._play()
        };
        proto._play = function() {
            var classlist = document.documentElement.className.split(" ");
            if (classlist.indexOf("ie") === -1 && classlist.indexOf("edge") === -1) {
                this.video.play().then(function() {}).catch(function(error) {})
            } else {
                this.video.play()
            }
        };
        proto.onSectionWillDisappear = function(scrollPosition, windowHeight) {
            superclass.onSectionWillDisappear.call(this, scrollPosition, windowHeight);
            this.video.pause()
        };
        HeroBackgroundVideoComponent.IS_SUPPORTED = function() {
            if (EnabledFeatures.REDUCED_MOTION) return false;
            if (EnabledFeatures.TOUCH && viewportEmitter.viewport === "small") return false;
            return EnabledFeatures.INLINE_VIDEO
        };
        module.exports = HeroBackgroundVideoComponent
    }, {
        "@marcom/ac-browser-prefixed": 19,
        "@marcom/ac-jetpack-lib/core/BaseComponent": 371,
        "@marcom/ac-jetpack-lib/model/EnabledFeatures": 377,
        "@marcom/ac-polyfills/Object/create": 396,
        "@marcom/ac-viewport-emitter": 564,
        "@marcom/sm-math-utils": 565
    }],
    569: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Object/create");
        var EnabledFeatures = require("@marcom/ac-jetpack-lib/model/EnabledFeatures");
        var BaseComponent = require("@marcom/ac-jetpack-lib/core/BaseComponent");
        var superclass = BaseComponent.prototype;
        var MathUtils = require("@marcom/sm-math-utils");
        var BrowserPrefixed = require("@marcom/ac-browser-prefixed");

        function HeroScrollAnimationComponent(section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index) {
            this.name = "HeroScrollAnimationComponent_" + index;
            BaseComponent.call(this, section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index);
            this.currentBreakpoint = currentBreakpoint;
            this.heroContentElement = this.element.querySelector(".hero-content");
            this.yScrollMax = this._getParallaxScrollMax();
            this.parallaxDistance = {
                small: 100,
                medium: 200,
                large: 300,
                xlarge: 300
            };
            this.rafWhenVisible = true;
            this.heroScrollProgress = 0;
            this.onScroll(null, scrollPosition, windowHeight)
        }
        var proto = HeroScrollAnimationComponent.prototype = Object.create(BaseComponent.prototype);
        HeroScrollAnimationComponent.prototype.constructor = HeroScrollAnimationComponent;
        proto._getParallaxScrollMax = function() {
            return this.element.clientHeight
        };
        proto.onScroll = function(e, scrollPosition, windowHeight) {
            superclass.onScroll.call(this, e, scrollPosition, windowHeight);
            this.heroScrollProgress = MathUtils.mapClamp(scrollPosition, 0, this.yScrollMax, 0, 1)
        };
        proto.onRequestAnimationFrame = function() {
            superclass.onRequestAnimationFrame.call(this);
            var parallaxAmount = this.parallaxDistance[this.currentBreakpoint];
            this.heroContentElement.style.opacity = 1 - this.heroScrollProgress;
            this.heroContentElement.style[BrowserPrefixed.transform] = "translate3d(0," + Math.floor(this.heroScrollProgress * parallaxAmount) + "px,0)"
        };
        proto.onResizeDebounced = function(e, scrollPosition, windowHeight) {
            superclass.onResizeDebounced.call(this, e, scrollPosition, windowHeight);
            this.yScrollMax = this._getParallaxScrollMax();
            this.onScroll(null, scrollPosition, windowHeight)
        };
        proto.onBreakpoint = function(newBreakPoint, oldBreakPoint, scrollPosition, windowHeight) {
            this.currentBreakpoint = newBreakPoint
        };
        HeroScrollAnimationComponent.IS_SUPPORTED = function() {
            if (EnabledFeatures.REDUCED_MOTION) return false;
            if (EnabledFeatures.TOUCH) return false;
            return EnabledFeatures.PARALLAX
        };
        module.exports = HeroScrollAnimationComponent
    }, {
        "@marcom/ac-browser-prefixed": 19,
        "@marcom/ac-jetpack-lib/core/BaseComponent": 371,
        "@marcom/ac-jetpack-lib/model/EnabledFeatures": 377,
        "@marcom/ac-polyfills/Object/create": 396,
        "@marcom/sm-math-utils": 565
    }],
    570: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Object/create");
        var EnabledFeatures = require("@marcom/ac-jetpack-lib/model/EnabledFeatures");
        var BaseComponent = require("@marcom/ac-jetpack-lib/core/BaseComponent");
        var superclass = BaseComponent.prototype;
        var viewportEmitter = require("@marcom/ac-viewport-emitter");
        var Clip = require("@marcom/ac-eclipse").Clip;
        var getPagePosition = require("@marcom/ac-dom-metrics/getPagePosition");
        var ac_useragent = require("@marcom/ac-useragent");
        var CANVAS_WIDTH = "1920";
        var CANVAS_HEIGHT = "248";
        var CANVAS_SCALE_FACTOR = 1;
        var WRAPPER_CLASSNAME = "text-mask";
        var SCREEN_ELEMENT_CLASSNAME = "text-mask-screen";
        var CANVAS_CLASSNAME = "text-mask-canvas-background";
        var SVG_CLASSNAME = "text-mask-svg";
        var SVG_CLIP_PATH_ID = "text-mask-svg-path";
        var SVG_TEXT_CLASSNAME = "text-mask-svg-content";
        var MIN_FRAME_TIME = 1e3 / 24;
        var AFTER_SCROLL_DELAY = 250;
        var MIN_FRAME_TIME = 1e3 / 24;

        function HeroTextMaskedVideoComponent(section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index) {
            this.name = "HeroTextMaskedVideoComponent_" + index;
            BaseComponent.call(this, section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index);
            this.textElement = this.element.querySelector("." + WRAPPER_CLASSNAME);
            this.textElementOffsetTop = getPagePosition(this.textElement).top;
            this.text = this.textElement.innerHTML;
            this.heroBackgroundVideo = this.section.getComponentOfType("HeroBackgroundVideoComponent").video;
            this.heroBackgroundVideo.style.display = "none";
            this.svgTextMask = this._createSvgTextMask();
            this.rafWhenVisible = true;
            this.isPlaying = false;
            this._onCanPlayThrough = this._onCanPlayThrough.bind(this);
            this.heroBackgroundVideo.addEventListener("canplaythrough", this._onCanPlayThrough)
        }
        var proto = HeroTextMaskedVideoComponent.prototype = Object.create(BaseComponent.prototype);
        HeroTextMaskedVideoComponent.prototype.constructor = HeroTextMaskedVideoComponent;
        proto._onCanPlayThrough = function() {
            if (this.isPlaying) {
                return
            }
            this.isPlaying = true;
            this.heroBackgroundVideo.style.display = "block";
            this.element.style.display = "block";
            this.movieHeight = this.heroBackgroundVideo.offsetHeight;
            this.textBackgroundCanvasElement = this._createBackgroundCanvas();
            this.textBackgroundCanvasContext = this.textBackgroundCanvasElement.getContext("2d");
            this._updateBackgroundCanvasSize();
            this.textBackgroundScreenElement = this._createScreenLayer();
            this._injectMaskedText();
            this._fadeInMaskedText()
        };
        proto._fadeInMaskedText = function() {
            var mask = this.element.querySelector(".text-mask");
            mask.style.opacity = 0;
            window.setTimeout(function() {
                new Clip(this.element, 1.2, {
                    opacity: 1,
                    transform: {
                        translateY: "0"
                    }
                }, {
                    delay: .1
                }).play();
                new Clip(mask, 1, {
                    opacity: 1
                }, {
                    delay: .4
                }).play()
            }.bind(this), .2)
        };
        proto._createBackgroundCanvas = function() {
            var canvasElement = document.createElement("canvas");
            canvasElement.width = "" + Math.round(parseInt(CANVAS_WIDTH) / CANVAS_SCALE_FACTOR);
            canvasElement.height = "" + Math.round(parseInt(CANVAS_HEIGHT) / CANVAS_SCALE_FACTOR);
            canvasElement.style.width = this.heroBackgroundVideo.clientWidth + "px";
            canvasElement.style.height = CANVAS_HEIGHT + "px";
            canvasElement.classList.add(CANVAS_CLASSNAME);
            return canvasElement
        };
        proto._createScreenLayer = function() {
            var screenElement = document.createElement("div");
            screenElement.classList.add(SCREEN_ELEMENT_CLASSNAME);
            return screenElement
        };
        proto._createSvgTextMask = function() {
            var svgNS = "http://www.w3.org/2000/svg";
            var svg = document.createElementNS(svgNS, "svg");
            svg.classList.add(SVG_CLASSNAME);
            var svgClipPath = document.createElementNS(svgNS, "clipPath");
            svgClipPath.setAttribute("id", SVG_CLIP_PATH_ID);
            var svgText = document.createElementNS(svgNS, "text");
            svgText.classList.add(SVG_TEXT_CLASSNAME);
            svgText.setAttribute("x", "50%");
            svgText.setAttribute("y", "50%");
            svgText.textContent = this.text;
            svgClipPath.appendChild(svgText);
            svg.appendChild(svgClipPath);
            return svg
        };
        proto._updateBackgroundCanvasSize = function() {
            this.textElementOffsetTop = getPagePosition(this.element).top;
            this.textBackgroundCanvasElement.style.width = this.heroBackgroundVideo.clientWidth + "px"
        };
        proto._injectMaskedText = function() {
            this.textElement.innerHTML = "";
            this.textElement.setAttribute("aria-label", this.text);
            this.textElement.insertBefore(this.textBackgroundCanvasElement, this.textElement.firstChild);
            this.textElement.insertBefore(this.textBackgroundScreenElement, this.textElement.firstChild);
            this.textElement.appendChild(this.svgTextMask)
        };
        proto.onScroll = function(e, scrollPosition, windowHeight) {
            superclass.onScroll.call(this, e, scrollPosition, windowHeight);
            this.lastDrawDate = new Date;
            this.lastDrawDate.setMilliseconds(this.lastDrawDate.getMilliseconds() + AFTER_SCROLL_DELAY)
        };
        proto.onRequestAnimationFrame = function() {
            superclass.onRequestAnimationFrame.call(this);
            if (this.scrollTimer) {
                return
            }
            if (this.lastDrawDate && new Date - this.lastDrawDate < MIN_FRAME_TIME) {
                return
            }
            this.lastDrawDate = new Date;
            var sourceWidth = parseInt(CANVAS_WIDTH);
            var sourceHeight = parseInt(CANVAS_HEIGHT);
            var sourceX = 0;
            var sourceY = this.textElementOffsetTop;
            var destX = 0;
            var destY = 0;
            var destWidth = parseInt(CANVAS_WIDTH) / CANVAS_SCALE_FACTOR;
            var destHeight = parseInt(CANVAS_HEIGHT) / CANVAS_SCALE_FACTOR;
            if (this.textBackgroundCanvasElement) {
                this.textBackgroundCanvasContext.drawImage(this.heroBackgroundVideo, sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight)
            }
        };
        proto.onResizeDebounced = function(e, scrollPosition, windowHeight) {
            superclass.onResizeDebounced.call(this, e, scrollPosition, windowHeight);
            this._updateBackgroundCanvasSize()
        };
        HeroTextMaskedVideoComponent.IS_SUPPORTED = function() {
            var htmlEl = document.getElementsByTagName("html")[0];
            if (viewportEmitter.viewport === "small" || viewportEmitter.viewport === "medium") {
                if (ac_useragent.browser.safari && !ac_useragent.os.ios) {
                    htmlEl.classList.remove("svg-clip-path");
                    htmlEl.classList.add("no-svg-clip-path");
                    htmlEl.classList.add("svg-clip-path-white");
                    return false
                }
            }
            if (EnabledFeatures.REDUCED_MOTION) return false;
            if (EnabledFeatures.TOUCH && viewportEmitter.viewport === "small") return false;
            return EnabledFeatures.SVG_CLIP_PATH
        };
        module.exports = HeroTextMaskedVideoComponent
    }, {
        "@marcom/ac-dom-metrics/getPagePosition": 21,
        "@marcom/ac-eclipse": 128,
        "@marcom/ac-jetpack-lib/core/BaseComponent": 371,
        "@marcom/ac-jetpack-lib/model/EnabledFeatures": 377,
        "@marcom/ac-polyfills/Object/create": 396,
        "@marcom/ac-useragent": 403,
        "@marcom/ac-viewport-emitter": 564
    }],
    571: [function(require, module, exports) {
        "use strict";
        require("@marcom/ac-polyfills/Object/create");
        var EnabledFeatures = require("@marcom/ac-jetpack-lib/model/EnabledFeatures");
        var BaseComponent = require("@marcom/ac-jetpack-lib/core/BaseComponent");
        var superclass = BaseComponent.prototype;
        var SharingModule = require("../helpers/sharing/Sharing");
        var TEMPLATE = require("../helpers/sharing/SharesheetTemplate.js");

        function TouchShareComponent(section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index) {
            this.name = "TouchShareComponent_" + index;
            BaseComponent.call(this, section, componentElement, componentName, currentBreakpoint, scrollPosition, windowHeight, index);
            this.cardElements = this.element.querySelectorAll(".card");
            for (var i = 0; i < this.cardElements.length; i++) {
                this._createShareSheet(this.cardElements[i])
            }
        }
        var proto = TouchShareComponent.prototype = Object.create(BaseComponent.prototype);
        TouchShareComponent.prototype.constructor = TouchShareComponent;
        proto._createShareSheet = function(cardElement) {
            var shareData = cardElement.firstElementChild.getAttribute("data-films-options");
            if (shareData) {
                shareData = JSON.parse(shareData);
                var sharesheetContainer = document.createElement("div");
                sharesheetContainer.classList.add("sharesheet");
                sharesheetContainer.innerHTML = TEMPLATE;
                sharesheetContainer = cardElement.appendChild(sharesheetContainer);
                var sharing = new SharingModule(shareData.sharing, sharesheetContainer)
            }
        };
        TouchShareComponent.IS_SUPPORTED = function() {
            return EnabledFeatures.TOUCH
        };
        module.exports = TouchShareComponent
    }, {
        "../helpers/sharing/SharesheetTemplate.js": 572,
        "../helpers/sharing/Sharing": 573,
        "@marcom/ac-jetpack-lib/core/BaseComponent": 371,
        "@marcom/ac-jetpack-lib/model/EnabledFeatures": 377,
        "@marcom/ac-polyfills/Object/create": 396
    }],
    572: [function(require, module, exports) {
        module.exports = '<button class="share-btn" aria-labelledby="label-sharesheet-open-share-btn"></button>' + '<div class="container">' + '<button class="close-button" aria-labelledby="label-sharesheet-close"><span class="icon icon-reset"></span></button>' + '<div class="vert-center-wrap">' + '<div class="sharing-container">' + '<span class="sharing-button-container">' + '<button class="facebook-share" aria-labelledby="label-sharesheet-facebook"></button>' + '<button class="twitter-share" aria-labelledby="label-sharesheet-twitter"></button>' + '<button class="copy-link" aria-labelledby="label-sharesheet-copy-link"></button>' + '<button class="copy-embed-code" aria-labelledby="label-sharesheet-copy-embed-code"></button>' + "</span>" + "</div>" + '<div class="textarea-container">' + "<span>" + '<input class="copy-area form-textbox form-textbox-text disabled" type="text" id="copy-link" aria-labelledby="sharesheet-copy-area"></input>' + '<button class="textinput-close-button ac-video-icon icon-share_close"></button>' + "</span>" + "</div>" + "</div>" + "</div>"
    }, {}],
    573: [function(require, module, exports) {
        "use strict";
        var SharingModule = require("@marcom/ac-video/ui/sharing/SharingModule");
        var ACTIVE_CLASS = "open-sharesheet";
        var Sharing = function(options, el) {
            this.el = el;
            this.cardElement = this.el.parentElement.querySelector(".card-content");
            this.closeShareSheetBtn = this.el.querySelector(".close-button");
            this._openShareSheetBtn = this.el.querySelector(".share-btn");
            options.player = {
                el: {},
                on: function() {},
                getMediaWidth: function() {
                    return options.width || 540
                },
                getMediaHeight: function() {
                    return options.height || 460
                }
            };
            SharingModule.call(this, options);
            this._openShareSheet = this._openShareSheet.bind(this);
            this._setupEvents();
            this._setTemplateData();
            this._setData(options)
        };
        var superProto = SharingModule.prototype;
        var proto = Sharing.prototype = Object.create(superProto);
        proto._setupEvents = function() {
            this._openShareSheetBtn.addEventListener("click", this._openShareSheet)
        };
        proto._closeState = function() {
            this.el.parentElement.classList.remove(ACTIVE_CLASS);
            this.cardElement.setAttribute("aria-hidden", "false");
            this._openShareSheetBtn.focus();
            this._showTextArea(false)
        };
        proto._openShareSheet = function(e) {
            e.preventDefault();
            this.el.parentElement.classList.add(ACTIVE_CLASS);
            this.cardElement.setAttribute("aria-hidden", "true");
            this.closeShareSheetBtn.focus()
        };
        proto._setTemplateData = function() {
            if (!this._templateData) {
                var ariaLabelContainer = document.querySelector(".aria-label-container");
                var copylink = ariaLabelContainer.querySelector("#label-sharesheet-copy-link").innerHTML;
                var selectlink = ariaLabelContainer.querySelector("#label-sharesheet-select-link").innerHTML;
                var selectembed = ariaLabelContainer.querySelector("#label-sharesheet-select-embed").innerHTML;
                var copyembed = ariaLabelContainer.querySelector("#label-sharesheet-copy-embed").innerHTML;
                this._templateData = {
                    copylink: copylink,
                    selectlink: selectlink,
                    selectembed: selectembed,
                    copyembed: copyembed
                }
            }
        };
        proto._setData = function(data) {
            this._sharingUrl = data.originatorUrl;
            this._title = data.title;
            this._description = data.description;
            this._videoid = data.videoid;
            this._hideExtension = data.hideExtension;
            this._embedPath = data.embedpath || DEFAULT_EMBED_PATH;
            this._hideFacebook = data.hideFacebookShare || false;
            this._hideTwitter = data.hideTwitterShare || false;
            this._syncSocialShareHidden();
            if (data.analytics) {
                try {
                    this._initAnalyticsAttributes(data)
                } catch (error) {
                    log("ac-analytics-share failed to load, are you sure you've included it?")
                }
            }
        };
        module.exports = Sharing
    }, {
        "@marcom/ac-video/ui/sharing/SharingModule": 549
    }],
    574: [function(require, module, exports) {
        "use strict";
        var BasePage = require("@marcom/ac-jetpack-lib/src/core/BasePage");
        var EnabledFeatures = require("@marcom/ac-jetpack-lib/model/EnabledFeatures");
        var ComponentMap = require("@marcom/ac-jetpack-lib/model/ComponentMap");
        var SiteComponentMap = require("./model/ComponentMap");
        var createFilm = require("@marcom/ac-films").create;
        var BrowserPrefixed = require("@marcom/ac-browser-prefixed");
        var viewportEmitter = require("@marcom/ac-viewport-emitter");
        var Main = {
            initialize: function() {
                Object.assign(ComponentMap, SiteComponentMap);
                EnabledFeatures.extend(require("./model/EnabledFeatures"));
                EnabledFeatures.init();
                new BasePage;
                var filmsObject = this.initModalFilms();
                var modal = filmsObject.modalVideo;
                if (modal) {
                    var modalCloseButton = modal.modalElement.querySelector(".modal-close");
                    modalCloseButton.setAttribute("aria-labelledby", "label-modal-close")
                }
            },
            initModalFilms: function() {
                var films = document.querySelectorAll("[data-films-modal-link]");
                var filmsArray = Array.prototype.slice.call(films);
                var options = {
                    share: {},
                    closeOnEnd: false,
                    modal: true
                };
                return createFilm(filmsArray, options)
            }
        };
        module.exports = Main.initialize()
    }, {
        "./model/ComponentMap": 575,
        "./model/EnabledFeatures": 576,
        "@marcom/ac-browser-prefixed": 19,
        "@marcom/ac-films": 267,
        "@marcom/ac-jetpack-lib/model/ComponentMap": 375,
        "@marcom/ac-jetpack-lib/model/EnabledFeatures": 377,
        "@marcom/ac-jetpack-lib/src/core/BasePage": 372,
        "@marcom/ac-viewport-emitter": 564
    }],
    575: [function(require, module, exports) {
        "use strict";
        module.exports = {
            HeroScrollAnimationComponent: require("../components/HeroScrollAnimationComponent"),
            HeroBackgroundVideoComponent: require("../components/HeroBackgroundVideoComponent"),
            HeroTextMaskedVideoComponent: require("../components/HeroTextMaskedVideoComponent"),
            CardManagerComponent: require("../components/CardManagerComponent"),
            CardGridResizerComponent: require("../components/CardGridResizerComponent"),
            TouchShareComponent: require("../components/TouchShareComponent")
        }
    }, {
        "../components/CardGridResizerComponent": 566,
        "../components/CardManagerComponent": 567,
        "../components/HeroBackgroundVideoComponent": 568,
        "../components/HeroScrollAnimationComponent": 569,
        "../components/HeroTextMaskedVideoComponent": 570,
        "../components/TouchShareComponent": 571
    }],
    576: [function(require, module, exports) {
        "use strict";
        var htmlEl;
        module.exports = {
            TOUCH: undefined,
            JS: undefined,
            PARALLAX: undefined,
            INLINE_VIDEO: undefined,
            SVG_CLIP_PATH: undefined,
            REDUCED_MOTION: undefined,
            init: function() {
                htmlEl = document.getElementsByTagName("html")[0];
                this.TOUCH = htmlEl.classList.contains("touch");
                this.JS = htmlEl.classList.contains("js");
                this.PARALLAX = htmlEl.classList.contains("parallax");
                this.INLINE_VIDEO = htmlEl.classList.contains("inline-video");
                this.SVG_CLIP_PATH = htmlEl.classList.contains("svg-clip-path");
                this.REDUCED_MOTION = htmlEl.classList.contains("prefers-reduced-motion")
            }
        }
    }, {}],
    577: [function(require, module, exports) {
        "use strict";
        module.exports = {
            fourColumnMaxWidth: 2e3,
            threeColumnMaxWidth: 1440,
            twoColumnMaxWidth: 800,
            oneColumnMaxWidth: 520
        }
    }, {}]
}, {}, [574]);