{"version":3,"file":"assets/js/app.xxxxxxxxxxxxxxxxxxxx.js","mappings":"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","sources":["webpack://agu-portfolio/./src/js/utils.ts","webpack://agu-portfolio/./src/js/animate.ts","webpack://agu-portfolio/./src/js/constants.ts","webpack://agu-portfolio/./node_modules/.pnpm/theaterjs@3.2.0/node_modules/theaterjs/dist/theater.js","webpack://agu-portfolio/./src/js/application.ts","webpack://agu-portfolio/./node_modules/.pnpm/scrollmagic@2.0.8/node_modules/scrollmagic/scrollmagic/uncompressed/ScrollMagic.js","webpack://agu-portfolio/./node_modules/.pnpm/velocity-animate@2.0.6/node_modules/velocity-animate/velocity.es5.js","webpack://agu-portfolio/./node_modules/.pnpm/theaterjs@3.2.0/node_modules/theaterjs/index.js","webpack://agu-portfolio/./node_modules/.pnpm/shufflejs@6.1.2/node_modules/shufflejs/dist/shuffle.js","webpack://agu-portfolio/./src/js/work-viewer.ts","webpack://agu-portfolio/./node_modules/.pnpm/vanilla-tilt@1.8.1/node_modules/vanilla-tilt/lib/vanilla-tilt.js","webpack://agu-portfolio/webpack/bootstrap","webpack://agu-portfolio/webpack/runtime/define property getters","webpack://agu-portfolio/webpack/runtime/hasOwnProperty shorthand","webpack://agu-portfolio/webpack/runtime/make namespace object","webpack://agu-portfolio/./src/index.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getOffset = exports.validateEmail = void 0;\nconst EMAIL_REGEXP = /^(?=.{1,254}$)(?=.{1,64}@)[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;\nconst isEmpty = (value) => value == null || (Array.isArray(value) && value.length === 0);\nconst validateEmail = (value) => {\n    if (isEmpty(value)) {\n        return null;\n    }\n    return EMAIL_REGEXP.test(value);\n};\nexports.validateEmail = validateEmail;\nconst getOffset = (el) => {\n    const box = el.getBoundingClientRect();\n    const docElem = document.documentElement;\n    return {\n        top: box.top + window.scrollY - docElem.clientTop,\n        left: box.left + window.scrollX - docElem.clientLeft,\n    };\n};\nexports.getOffset = getOffset;\n","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst velocity_animate_1 = require(\"velocity-animate\");\nconst constants_1 = require(\"./constants\");\nconst utils_1 = require(\"./utils\");\nconst scrollMagic = require(\"scrollmagic\");\nconst theaterJS = require(\"theaterjs\");\nconst animate = {\n    inputAnimation: () => {\n        const onFormGroupEvent = (event) => {\n            var _a;\n            const currentInput = event.currentTarget;\n            const parentLabel = (_a = currentInput.parentNode) === null || _a === void 0 ? void 0 : _a.querySelector(\"label\");\n            if (event.type === \"keyup\") {\n                if (currentInput.value === \"\") {\n                    parentLabel.classList.add(\"js-hide-label\");\n                }\n                else {\n                    parentLabel.classList.remove(\"js-hide-label\");\n                }\n            }\n            else if (event.type === \"blur\") {\n                if (currentInput.value === \"\") {\n                    parentLabel.classList.add(\"js-hide-label\");\n                }\n                else {\n                    parentLabel.classList.remove(\"js-hide-label\");\n                }\n            }\n        };\n        const formControls = Array.from(document.getElementsByClassName(\"form-control\"));\n        formControls.forEach((formControl) => {\n            formControl.addEventListener(\"focusin\", (event) => {\n                var _a;\n                const selectedInput = event.currentTarget;\n                const selectedPencil = (_a = selectedInput.previousElementSibling) === null || _a === void 0 ? void 0 : _a.querySelector(\".pencil-name\");\n                if (selectedInput.value === \"\") {\n                    selectedPencil.velocity({ y: \"15px\", opacity: 1 }, 500, \"out\");\n                    selectedPencil.nextElementSibling.velocity({ y: \"0px\", opacity: 1 }, 500, \"in\");\n                }\n                animate.visibilityToggle(selectedPencil.nextElementSibling);\n            });\n            formControl.addEventListener(\"focusout\", (event) => {\n                var _a;\n                const selectedInput = event.currentTarget;\n                const selectedPencil = (_a = selectedInput.previousElementSibling) === null || _a === void 0 ? void 0 : _a.querySelector(\".pencil-name\");\n                if (selectedInput.value === \"\") {\n                    selectedPencil.velocity({ y: \"0px\", opacity: 0 }, 500, \"in\");\n                    selectedPencil.nextElementSibling.velocity({ y: \"15px\", opacity: 0 }, 500, \"out\");\n                }\n                animate.visibilityToggle(selectedPencil.nextElementSibling);\n            });\n        });\n        const isPlaceholderSupported = () => {\n            const input = document.createElement(\"input\");\n            return \"placeholder\" in input;\n        };\n        if (isPlaceholderSupported()) {\n            Array.from(document.getElementsByClassName(\"form-label\")).forEach((label) => {\n                label.classList.add(\"js-hide-label\");\n            });\n            Array.from(document.getElementsByClassName(\"form-group\")).forEach((formGroup) => {\n                var _a, _b;\n                (_a = formGroup.querySelector(\"input, textarea\")) === null || _a === void 0 ? void 0 : _a.addEventListener(\"keyup\", onFormGroupEvent);\n                (_b = formGroup.querySelector(\"input, textarea\")) === null || _b === void 0 ? void 0 : _b.addEventListener(\"blur\", onFormGroupEvent);\n            });\n        }\n    },\n    visibilityToggle: (element) => {\n        if (!element.style.visibility || element.style.visibility === \"hidden\") {\n            element.style.visibility = \"visible\";\n        }\n        else {\n            element.style.visibility = \"hidden\";\n        }\n    },\n    rippleEffect: () => {\n        Array.from(document.getElementsByClassName(\"svg-wrapper\")).forEach((svgWrapper) => {\n            svgWrapper.addEventListener(\"click\", (event) => {\n                event.preventDefault();\n                const buttonElement = event.currentTarget;\n                const divCreated = document.createElement(\"div\");\n                const btnOffset = (0, utils_1.getOffset)(buttonElement);\n                const xPos = btnOffset && event.pageX - btnOffset.left;\n                const yPos = btnOffset && event.pageY - btnOffset.top;\n                divCreated.classList.add(\"ripple-effect\");\n                divCreated.style.top = `${yPos - buttonElement.clientHeight / 2 + 20}px`;\n                divCreated.style.left = `${xPos - buttonElement.clientHeight / 2 + 20}px`;\n                divCreated.style.background = \"#e3b673\";\n                buttonElement.appendChild(divCreated);\n                window.setTimeout(() => {\n                    divCreated.remove();\n                }, 2000);\n            });\n        });\n    },\n    showEmailSendFinished: () => {\n        const textArea = document.getElementById(\"hidden-text-success\");\n        textArea.velocity({ opacity: \"1\" }, { duration: 1500, easing: \"easeOutExpo\" });\n    },\n    submitContactForm: (data) => __awaiter(void 0, void 0, void 0, function* () {\n        const formData = new FormData();\n        formData.append(\"access_key\", constants_1.default.WEB3FORMS_KEY);\n        formData.append(\"name\", data.name);\n        formData.append(\"email\", data.email);\n        formData.append(\"subject\", data.subject);\n        formData.append(\"message\", data.message);\n        try {\n            const response = yield fetch(constants_1.default.WEB3FORMS_URL, {\n                method: \"POST\",\n                body: formData,\n            });\n            const result = yield response.json();\n            return response.ok && result.success;\n        }\n        catch (error) {\n            console.error(\"Failed to submit contact form:\", error);\n            return false;\n        }\n    }),\n    emailSend: () => {\n        var _a;\n        (_a = document.getElementById(\"btn-send\")) === null || _a === void 0 ? void 0 : _a.addEventListener(\"click\", (e) => __awaiter(void 0, void 0, void 0, function* () {\n            e.preventDefault();\n            const button = e.currentTarget;\n            const name = document.getElementById(\"name\");\n            const email = document.getElementById(\"email\");\n            const subject = document.getElementById(\"subject\");\n            const message = document.getElementById(\"message\");\n            const isValid = name.value !== \"\" && email.value !== \"\" && (0, utils_1.validateEmail)(email.value) && subject.value !== \"\" && message.value !== \"\";\n            if (isValid) {\n                const item = document.getElementById(\"hidden-contactform\");\n                const mailLoader = document.getElementById(\"mail-loader\");\n                if (item && mailLoader) {\n                    item.style.display = \"block\";\n                    item.velocity({ height: \"730px\" }, {\n                        duration: 1500,\n                        easing: \"easeOutExpo\",\n                    });\n                    (0, velocity_animate_1.default)(mailLoader, { opacity: \"1\" }, { duration: 500, easing: \"easeOutExpo\" });\n                    const success = yield animate.submitContactForm({\n                        name: name.value,\n                        email: email.value,\n                        subject: subject.value,\n                        message: message.value,\n                    });\n                    (0, velocity_animate_1.default)(mailLoader, { opacity: \"0\" }, { duration: 300 });\n                    if (success) {\n                        animate.showEmailSendFinished();\n                        name.value = \"\";\n                        email.value = \"\";\n                        subject.value = \"\";\n                        message.value = \"\";\n                    }\n                    else {\n                        alert(\"Failed to send message. Please try again.\");\n                    }\n                }\n            }\n            else {\n                if (name.value === \"\")\n                    name.style.border = \"1px solid red\";\n                if (email.value === \"\" || !(0, utils_1.validateEmail)(email.value))\n                    email.style.border = \"1px solid red\";\n                if (subject.value === \"\")\n                    subject.style.border = \"1px solid red\";\n                if (message.value === \"\")\n                    message.style.border = \"1px solid red\";\n                name.addEventListener(\"focus\", () => (name.style.border = \"\"));\n                email.addEventListener(\"focus\", () => (email.style.border = \"\"));\n                subject.addEventListener(\"focus\", () => (subject.style.border = \"\"));\n                message.addEventListener(\"focus\", () => (message.style.border = \"\"));\n                setTimeout(() => {\n                    var _a, _b;\n                    (_b = (_a = button.parentElement) === null || _a === void 0 ? void 0 : _a.parentElement) === null || _b === void 0 ? void 0 : _b.classList.remove(\"active\");\n                }, 300);\n            }\n        }));\n    },\n    hexagonRotate: () => {\n        Array.from(document.getElementsByClassName(\"hexagon-wrapper\")).forEach((hexagonWrapper) => {\n            hexagonWrapper.addEventListener(\"mouseenter\", (event) => {\n                const currentHexagon = event.currentTarget;\n                const iconPosition = currentHexagon.querySelector(\".hexagon-icon-position\");\n                iconPosition === null || iconPosition === void 0 ? void 0 : iconPosition.classList.toggle(\"hexagon-hover-rotate\");\n                currentHexagon.querySelector(\".hexagon\").style.backgroundColor = \"#070606\";\n                iconPosition.style.color = \"#E3B673\";\n            });\n            hexagonWrapper.addEventListener(\"mouseleave\", (event) => {\n                const currentHexagon = event.currentTarget;\n                const iconPosition = currentHexagon.querySelector(\".hexagon-icon-position\");\n                iconPosition === null || iconPosition === void 0 ? void 0 : iconPosition.classList.toggle(\"hexagon-hover-rotate\");\n                currentHexagon.querySelector(\".hexagon\").style.backgroundColor = \"#E3B673\";\n                iconPosition.style.color = \"#070606\";\n            });\n        });\n    },\n    hideMoreBtnMobile: () => {\n        const infos = Array.from(document.getElementsByClassName(\"info\"));\n        //If is touchscreen, the \"+ More\" button in works is always visible\n        infos.forEach((info) => {\n            if (\"ontouchstart\" in window) {\n                info.classList.add(\"work-button-mobile\");\n            }\n            else {\n                info.classList.remove(\"work-button-mobile\");\n            }\n        });\n    },\n    typingEffect: () => {\n        try {\n            const controller = new scrollMagic.Controller();\n            const theater = theaterJS();\n            theater.on(\"type:start, erase:start\", () => {\n                const actor = theater.getCurrentActor();\n                actor.$element.classList.add(\"is-typing\");\n            });\n            theater.addActor(\"typing\");\n            theater.addScene(\"typing:Hello\", 200);\n            //typing about\n            new scrollMagic.Scene({ triggerElement: \"#about\", duration: 200, offset: -150, reverse: true }).addTo(controller).on(\"start\", () => {\n                theater.addActor(\"about\");\n                theater.addScene(\"about:About.\", 300);\n            });\n            //typing work\n            new scrollMagic.Scene({ triggerElement: \"#work\", duration: 200, offset: -150, reverse: true }).addTo(controller).on(\"start\", () => {\n                theater.addActor(\"work\");\n                theater.addScene(\"work:Work.\", 300);\n            });\n            //typing contact\n            new scrollMagic.Scene({ triggerElement: \"#contact\", duration: 200, offset: -150, reverse: true })\n                .addTo(controller)\n                .on(\"start\", () => {\n                theater.addActor(\"contact\", { accuracy: 0.4 });\n                theater.addScene(\"contact:Contact.\", 300);\n            });\n        }\n        catch (e) {\n            console.log(\"No element for typing\");\n        }\n    },\n    scrollArrow: () => {\n        var _a;\n        (_a = document.getElementById(\"arrow-down\")) === null || _a === void 0 ? void 0 : _a.addEventListener(\"click\", (e) => {\n            var _a;\n            e.preventDefault();\n            (_a = document.getElementById(\"about\")) === null || _a === void 0 ? void 0 : _a.scrollIntoView({\n                behavior: \"smooth\",\n            });\n        });\n    },\n};\nexports.default = animate;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst CONSTANTS = {\n    WEB3FORMS_URL: \"https://api.web3forms.com/submit\",\n    WEB3FORMS_KEY: \"640935f5-00f7-4dbd-a0aa-50fb0da04ca9\",\n};\nexports.default = CONSTANTS;\n","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"theaterJS\"] = factory();\n\telse\n\t\troot[\"theaterJS\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n\n\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\n\tvar _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();\n\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\n\tfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }\n\n\tfunction _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }\n\n\tvar _actor = __webpack_require__(1);\n\n\tvar _actor2 = _interopRequireDefault(_actor);\n\n\tvar _helpersUtils = __webpack_require__(3);\n\n\tvar _helpersUtils2 = _interopRequireDefault(_helpersUtils);\n\n\tvar _helpersType = __webpack_require__(2);\n\n\tvar _helpersType2 = _interopRequireDefault(_helpersType);\n\n\tvar _helpersKeyboard = __webpack_require__(4);\n\n\tvar _helpersKeyboard2 = _interopRequireDefault(_helpersKeyboard);\n\n\tvar _helpersHtml = __webpack_require__(6);\n\n\tvar _helpersHtml2 = _interopRequireDefault(_helpersHtml);\n\n\tvar NAVIGATOR = typeof window !== 'undefined' && window.navigator;\n\tvar DEFAULTS = {\n\t  autoplay: true,\n\t  erase: true,\n\t  minSpeed: { erase: 80, type: 80 },\n\t  maxSpeed: { erase: 450, type: 450 },\n\t  locale: 'detect'\n\t};\n\n\tfunction theaterJS() {\n\t  var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];\n\n\t  /* ------------------------------------------------- *\\\n\t    init\n\t  \\* ------------------------------------------------- */\n\n\t  options = _helpersUtils2['default'].merge({}, DEFAULTS, options);\n\n\t  if (_helpersType2['default'].isNumber(options.minSpeed)) {\n\t    var _options = options;\n\t    var minSpeed = _options.minSpeed;\n\n\t    options.minSpeed = { erase: minSpeed, type: minSpeed };\n\t  }\n\n\t  if (_helpersType2['default'].isNumber(options.maxSpeed)) {\n\t    var _options2 = options;\n\t    var maxSpeed = _options2.maxSpeed;\n\n\t    options.maxSpeed = { erase: maxSpeed, type: maxSpeed };\n\t  }\n\n\t  if (options.locale === 'detect' && NAVIGATOR) {\n\t    var languages = NAVIGATOR.languages;\n\t    if (_helpersType2['default'].isArray(languages) && _helpersType2['default'].isString(languages[0])) {\n\t      options.locale = languages[0].substr(0, 2);\n\t    }\n\t  }\n\n\t  if (!_helpersKeyboard2['default'].supports(options.locale)) {\n\t    options.locale = _helpersKeyboard2['default'].defaultLocale;\n\t  }\n\n\t  var props = { options: options, casting: {}, status: 'ready', onStage: null, currentScene: -1, scenario: [], events: {} };\n\t  setCurrentActor(null);\n\n\t  /* ------------------------------------------------- *\\\n\t    methods\n\t  \\* ------------------------------------------------- */\n\n\t  function addActor(actorName) {\n\t    var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\t    var callback = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];\n\n\t    var a = (0, _actor2['default'])(actorName, options, callback);\n\t    props.casting[a.name] = a;\n\n\t    return this;\n\t  }\n\n\t  function setCurrentActor(actorName) {\n\t    props.onStage = actorName;\n\t    return this;\n\t  }\n\n\t  function getCurrentActor() {\n\t    return props.casting[props.onStage] || null;\n\t  }\n\n\t  function addScene() {\n\t    var sequence = [];\n\n\t    function addSceneToSequence(scene) {\n\t      if (_helpersType2['default'].isArray(scene)) {\n\t        scene.forEach(function (s) {\n\t          addSceneToSequence(s);\n\t        });\n\t      }\n\n\t      if (_helpersType2['default'].isString(scene)) {\n\t        var partials = scene.split(':');\n\n\t        var actorName = undefined;\n\t        if (partials.length > 1 && partials[0].charAt(partials[0].length - 1) !== '\\\\') {\n\t          actorName = partials.shift();\n\n\t          addSceneToSequence({ name: 'erase', actor: actorName });\n\t        }\n\n\t        var speech = partials.join(':').replace(/\\\\:/g, ':');\n\t        var sceneObj = { name: 'type', args: [speech] };\n\n\t        if (actorName != null) {\n\t          sceneObj.actor = actorName;\n\t        }\n\n\t        addSceneToSequence(sceneObj);\n\t      }\n\n\t      if (_helpersType2['default'].isFunction(scene)) {\n\t        addSceneToSequence({ name: 'callback', args: [scene] });\n\t      }\n\n\t      if (_helpersType2['default'].isNumber(scene)) {\n\t        if (scene > 0) {\n\t          addSceneToSequence({ name: 'wait', args: [scene] });\n\t        } else {\n\t          addSceneToSequence({ name: 'erase', args: [scene] });\n\t        }\n\t      }\n\n\t      if (_helpersType2['default'].isObject(scene)) {\n\t        if (!_helpersType2['default'].isArray(scene.args)) {\n\t          scene.args = [];\n\t        }\n\n\t        scene.args.unshift(function () {\n\t          publish(scene.name + ':end', scene);\n\t          playNextScene();\n\t        });\n\n\t        sequence.push(scene);\n\t      }\n\t    }\n\n\t    for (var _len = arguments.length, scenes = Array(_len), _key = 0; _key < _len; _key++) {\n\t      scenes[_key] = arguments[_key];\n\t    }\n\n\t    addSceneToSequence([{ name: 'publisher', args: ['sequence:start'] }].concat(scenes).concat({ name: 'publisher', args: ['sequence:end'] }));\n\t    Array.prototype.push.apply(props.scenario, sequence);\n\n\t    if (props.options.autoplay) {\n\t      play();\n\t    }\n\n\t    return this;\n\t  }\n\n\t  function getCurrentSpeech() {\n\t    var currentScene = props.scenario[props.currentScene];\n\t    if (!currentScene || !_helpersType2['default'].isArray(currentScene.args)) return null;\n\n\t    var _currentScene$args = _slicedToArray(currentScene.args, 2);\n\n\t    var speech = _currentScene$args[1];\n\n\t    return speech || null;\n\t  }\n\n\t  function play() {\n\t    if (props.status === 'stopping') {\n\t      props.status = 'playing';\n\t    }\n\n\t    if (props.status === 'ready') {\n\t      props.status = 'playing';\n\t      playNextScene();\n\t    }\n\n\t    return this;\n\t  }\n\n\t  function replay(done) {\n\t    if (props.status === 'ready' || _helpersType2['default'].isFunction(done)) {\n\t      props.currentScene = -1;\n\n\t      if (props.status === 'ready') play();else done();\n\t    }\n\n\t    return this;\n\t  }\n\n\t  function stop() {\n\t    props.status = 'stopping';\n\t    return this;\n\t  }\n\n\t  function playNextScene() {\n\t    if (props.status === 'stopping') {\n\t      props.status = 'ready';\n\t      return this;\n\t    }\n\n\t    if (props.status !== 'playing') return this;\n\n\t    if (props.currentScene + 1 >= props.scenario.length) {\n\t      props.status = 'ready';\n\t      publish('scenario:end');\n\t      return this;\n\t    }\n\n\t    var nextScene = props.scenario[++props.currentScene];\n\n\t    if (props.currentScene === 0) {\n\t      publish('scenario:start');\n\t    }\n\n\t    if (nextScene.name === 'publisher') {\n\t      var _nextScene$args = _toArray(nextScene.args);\n\n\t      var done = _nextScene$args[0];\n\n\t      var args = _nextScene$args.slice(1);\n\n\t      publish.apply(undefined, _toConsumableArray(args));\n\n\t      return done();\n\t    }\n\n\t    if (nextScene.actor) {\n\t      setCurrentActor(nextScene.actor);\n\t    }\n\n\t    publish(nextScene.name + ':start', nextScene);\n\n\t    switch (nextScene.name) {\n\t      case 'type':\n\t        typeAction.apply(undefined, _toConsumableArray(nextScene.args));\n\t        break;\n\n\t      case 'erase':\n\t        eraseAction.apply(undefined, _toConsumableArray(nextScene.args));\n\t        break;\n\n\t      case 'callback':\n\t        callbackAction.apply(undefined, _toConsumableArray(nextScene.args));\n\t        break;\n\n\t      case 'wait':\n\t        waitAction.apply(undefined, _toConsumableArray(nextScene.args));\n\t        break;\n\n\t      default:\n\t        console.debug('No scene handler for ' + nextScene.name);\n\t        break;\n\t    }\n\n\t    return this;\n\t  }\n\n\t  function typeAction(done, value) {\n\t    var actor = getCurrentActor();\n\n\t    var locale = props.options.locale;\n\t    var minSpeed = props.options.minSpeed.type;\n\t    var maxSpeed = props.options.maxSpeed.type;\n\t    var initialValue = actor.displayValue;\n\t    var cursor = -1;\n\t    var isFixing = false;\n\t    var previousMistakeCursor = null;\n\t    var previousFixCursor = null;\n\n\t    var htmlMap = _helpersHtml2['default'].map(value);\n\t    value = _helpersHtml2['default'].strip(value);(function type() {\n\t      var actual = _helpersHtml2['default'].strip(actor.displayValue.substr(initialValue.length));\n\n\t      if (actual === value) return done();\n\n\t      var expected = value.substr(0, cursor + 1);\n\n\t      var isMistaking = actual !== expected;\n\t      var shouldBeMistaken = actor.shouldBeMistaken(actual, value, previousMistakeCursor, previousFixCursor);\n\t      var shouldFix = isFixing || !shouldBeMistaken;\n\n\t      if (isMistaking && shouldFix) {\n\t        isFixing = true;\n\t        previousMistakeCursor = null;\n\t        actor.displayValue = initialValue + _helpersHtml2['default'].inject(actual.substr(0, actual.length - 1), htmlMap);\n\t        cursor--;\n\t        previousFixCursor = cursor;\n\t      } else {\n\t        isFixing = false;\n\t        var nextChar = value.charAt(++cursor);\n\n\t        if (shouldBeMistaken) {\n\t          nextChar = _helpersKeyboard2['default'].randomCharNear(nextChar, locale);\n\n\t          if (previousMistakeCursor == null) {\n\t            previousMistakeCursor = cursor;\n\t          }\n\t        }\n\n\t        actor.displayValue = initialValue + _helpersHtml2['default'].inject(actual + nextChar, htmlMap);\n\t      }\n\n\t      return setTimeout(type, actor.getTypingSpeed(minSpeed, maxSpeed));\n\t    })();\n\n\t    return this;\n\t  }\n\n\t  function eraseAction(done, arg) {\n\t    var actor = getCurrentActor();\n\n\t    // erase scenes are added before a type scene\n\t    // so for the first scene, there's no actor yet\n\t    if (actor == null) {\n\t      return done();\n\t    }\n\n\t    if (options.erase !== true) {\n\t      actor.displayValue = '';\n\t      return done();\n\t    }\n\n\t    var minSpeed = props.options.minSpeed.erase;\n\t    var maxSpeed = props.options.maxSpeed.erase;\n\n\t    var value = actor.displayValue;\n\t    var htmlMap = _helpersHtml2['default'].map(value);\n\n\t    value = _helpersHtml2['default'].strip(value);\n\n\t    var cursor = value.length;\n\n\t    var speed = undefined;\n\t    var nbCharactersToErase = 0;\n\n\t    if (_helpersType2['default'].isNumber(arg)) {\n\t      if (arg > 0) speed = arg;else nbCharactersToErase = value.length + arg;\n\t    }\n\n\t    (function erase() {\n\t      if (cursor === nbCharactersToErase) return done();\n\t      actor.displayValue = _helpersHtml2['default'].inject(value.substr(0, --cursor), htmlMap);\n\n\t      return setTimeout(erase, speed || actor.getTypingSpeed(minSpeed, maxSpeed));\n\t    })();\n\n\t    return this;\n\t  }\n\n\t  function callbackAction(done, callback) {\n\t    callback.call(this, done);\n\t    return this;\n\t  }\n\n\t  function waitAction(done, delay) {\n\t    setTimeout(done.bind(this), delay);\n\t    return this;\n\t  }\n\n\t  function subscribe(events, callback) {\n\t    events.split(',').forEach(function (eventName) {\n\t      eventName = eventName.trim();\n\n\t      if (!_helpersType2['default'].isArray(props.events[eventName])) {\n\t        props.events[eventName] = [];\n\t      }\n\n\t      props.events[eventName].push(callback);\n\t    });\n\n\t    return this;\n\t  }\n\n\t  function publish() {\n\t    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n\t      args[_key2] = arguments[_key2];\n\t    }\n\n\t    var eventName = args[0];\n\t    var callbacks = props.events[eventName] || [];\n\n\t    if (callbacks.length > 0) {\n\t      callbacks.concat(props.events['*'] || []).forEach(function (callback) {\n\t        return callback.apply(undefined, args);\n\t      });\n\t    }\n\n\t    return this;\n\t  }\n\n\t  /* ------------------------------------------------- *\\\n\t    public api\n\t  \\* ------------------------------------------------- */\n\n\t  return Object.freeze(Object.defineProperties({\n\t    addActor: addActor,\n\t    getCurrentActor: getCurrentActor,\n\t    addScene: addScene,\n\t    getCurrentSpeech: getCurrentSpeech,\n\t    play: play,\n\t    replay: replay,\n\t    stop: stop,\n\t    on: subscribe\n\t  }, {\n\t    options: {\n\t      get: function get() {\n\t        return props.options;\n\t      },\n\t      configurable: true,\n\t      enumerable: true\n\t    },\n\t    status: {\n\t      get: function get() {\n\t        return props.status;\n\t      },\n\t      configurable: true,\n\t      enumerable: true\n\t    }\n\t  }));\n\t}\n\n\ttheaterJS.init = function () {\n\t  var actorName = arguments.length <= 0 || arguments[0] === undefined ? 'actor' : arguments[0];\n\n\t  var theater = theaterJS();\n\t  theater.addActor(actorName, { accuracy: 1, speed: 0.8 });\n\t  return theater;\n\t};\n\n\texports['default'] = theaterJS;\n\tmodule.exports = exports['default'];\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\n\tvar _helpersType = __webpack_require__(2);\n\n\tvar _helpersType2 = _interopRequireDefault(_helpersType);\n\n\tvar _helpersUtils = __webpack_require__(3);\n\n\tvar _helpersUtils2 = _interopRequireDefault(_helpersUtils);\n\n\tvar DOCUMENT = typeof window !== 'undefined' && window.document;\n\tvar DEFAULTS = { speed: 0.6, accuracy: 0.6 };\n\n\texports['default'] = function (actorName) {\n\t  var props = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];\n\t  var callback = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];\n\n\t  var displayValue = '';\n\t  var $element = undefined;\n\n\t  if (_helpersType2['default'].isNumber(props)) {\n\t    props = { speed: props, accuracy: props };\n\t  }\n\n\t  props = _helpersUtils2['default'].merge({}, DEFAULTS, props);\n\n\t  if (DOCUMENT) {\n\t    if (callback == null) {\n\t      callback = '#' + actorName;\n\t    }\n\n\t    if (_helpersType2['default'].isString(callback)) {\n\t      var selector = callback;\n\t      var $e = DOCUMENT.querySelector(selector);\n\n\t      if ($e != null) {\n\t        $element = $e;\n\t        callback = function (newValue) {\n\t          $element.innerHTML = newValue;\n\t        };\n\t      } else {\n\t        throw new Error('no matches for ' + actorName + '\\'s selector: ' + selector);\n\t      }\n\t    }\n\t  }\n\n\t  if (!_helpersType2['default'].isFunction(callback)) {\n\t    callback = console.log.bind(console);\n\t  }\n\n\t  return Object.defineProperties({\n\t    $element: $element,\n\n\t    getTypingSpeed: function getTypingSpeed(fastest, slowest) {\n\t      var speed = _helpersUtils2['default'].randomFloat(props.speed, 1);\n\t      return _helpersUtils2['default'].getPercentageOf(slowest, fastest, speed);\n\t    },\n\n\t    shouldBeMistaken: function shouldBeMistaken(actual, endValue) {\n\t      var previousMistakeCursor = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];\n\t      var previousFixCursor = arguments.length <= 3 || arguments[3] === undefined ? null : arguments[3];\n\n\t      var accuracy = props.accuracy * 10;\n\n\t      if (accuracy >= 8) {\n\t        return false;\n\t      }\n\n\t      if (actual.length <= accuracy) {\n\t        return false;\n\t      }\n\n\t      if (actual.length === endValue.length) {\n\t        return false;\n\t      }\n\n\t      if (_helpersType2['default'].isNumber(previousMistakeCursor)) {\n\t        var nbOfCharactersTyped = actual.length - previousMistakeCursor;\n\t        var maxWrongCharactersAllowed = accuracy >= 6 ? 10 - accuracy : 4;\n\n\t        if (nbOfCharactersTyped >= maxWrongCharactersAllowed) {\n\t          return false;\n\t        }\n\t      }\n\n\t      if (_helpersType2['default'].isNumber(previousFixCursor)) {\n\t        var nbOfCharactersTyped = actual.length - previousFixCursor;\n\t        var minCharactersBetweenMistakes = Math.max(accuracy, 2) * 2;\n\n\t        if (nbOfCharactersTyped <= minCharactersBetweenMistakes) {\n\t          return false;\n\t        }\n\t      }\n\n\t      return _helpersUtils2['default'].randomFloat(0, 0.8) > props.accuracy;\n\t    }\n\t  }, {\n\t    displayValue: {\n\t      get: function get() {\n\t        return displayValue;\n\t      },\n\t      set: function set(value) {\n\t        displayValue = value;\n\t        callback(value);\n\t      },\n\t      configurable: true,\n\t      enumerable: true\n\t    },\n\t    name: {\n\t      get: function get() {\n\t        return actorName;\n\t      },\n\t      configurable: true,\n\t      enumerable: true\n\t    }\n\t  });\n\t};\n\n\tmodule.exports = exports['default'];\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports) {\n\n\t'use strict';\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\tfunction toString(o) {\n\t  return ({}).toString.call(o);\n\t}\n\n\texports['default'] = {\n\t  isNumber: function isNumber(o) {\n\t    return typeof o === 'number';\n\t  },\n\n\t  isString: function isString(o) {\n\t    return toString(o) === '[object String]';\n\t  },\n\n\t  isObject: function isObject(o) {\n\t    return toString(o) === '[object Object]';\n\t  },\n\n\t  isArray: function isArray(o) {\n\t    return toString(o) === '[object Array]';\n\t  },\n\n\t  isFunction: function isFunction(o) {\n\t    return typeof o === 'function';\n\t  }\n\t};\n\tmodule.exports = exports['default'];\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports) {\n\n\t\"use strict\";\n\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\texports[\"default\"] = {\n\t  merge: function merge(dst) {\n\t    var objs = [].slice.call(arguments, 1);\n\n\t    for (var i = 0, len = objs.length; i < len; i++) {\n\t      var obj = objs[i];\n\n\t      for (var key in obj) {\n\t        if (!obj.hasOwnProperty(key)) continue;\n\t        dst[key] = obj[key];\n\t      }\n\t    }\n\n\t    return dst;\n\t  },\n\n\t  random: function random(min, max) {\n\t    return Math.floor(Math.random() * (max - min + 1)) + min;\n\t  },\n\n\t  randomFloat: function randomFloat(min, max) {\n\t    return Math.random() * (max - min) + min;\n\t  },\n\n\t  getPercentageOf: function getPercentageOf(min, max, percentage) {\n\t    return min - min * percentage + max * percentage;\n\t  }\n\t};\n\tmodule.exports = exports[\"default\"];\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\n\tvar _type = __webpack_require__(2);\n\n\tvar _type2 = _interopRequireDefault(_type);\n\n\tvar _utils = __webpack_require__(3);\n\n\tvar _utils2 = _interopRequireDefault(_utils);\n\n\tvar _keyboardsJson = __webpack_require__(5);\n\n\tvar _keyboardsJson2 = _interopRequireDefault(_keyboardsJson);\n\n\tvar DEFAULT_LOCALE = 'en';\n\n\tfor (var locale in _keyboardsJson2['default']) {\n\t  if (!_keyboardsJson2['default'].hasOwnProperty(locale)) continue;\n\n\t  var keyboard = _keyboardsJson2['default'][locale];\n\t  _keyboardsJson2['default'][locale] = { list: keyboard, mapped: mapKeyboard(keyboard) };\n\t}\n\n\tfunction mapKeyboard(alphabet) {\n\t  var keyboard = {};\n\n\t  for (var y = 0, lines = alphabet.length, chars = undefined; y < lines; y++) {\n\t    chars = alphabet[y];\n\n\t    for (var x = 0, charsLength = chars.length; x < charsLength; x++) {\n\t      keyboard[chars[x]] = { x: x, y: y };\n\t    }\n\t  }\n\n\t  return keyboard;\n\t}\n\n\texports['default'] = {\n\t  defaultLocale: DEFAULT_LOCALE,\n\n\t  supports: function supports(locale) {\n\t    return _type2['default'].isObject(_keyboardsJson2['default'][locale]);\n\t  },\n\n\t  randomCharNear: function randomCharNear(ch, locale) {\n\t    if (!this.supports(locale)) {\n\t      throw new Error('locale \"' + locale + '\" is not supported');\n\t    }\n\n\t    var keyboard = _keyboardsJson2['default'][locale].mapped;\n\t    var threshold = 1;\n\t    var nearbyChars = [];\n\t    var uppercase = /[A-Z]/.test(ch);\n\n\t    ch = ch.toLowerCase();\n\n\t    var charPosition = keyboard[ch] || [];\n\t    var p = undefined;\n\n\t    for (var c in keyboard) {\n\t      if (!keyboard.hasOwnProperty(c) || c === ch) continue;\n\n\t      p = keyboard[c];\n\n\t      if (Math.abs(charPosition.x - p.x) <= threshold && Math.abs(charPosition.y - p.y) <= threshold) {\n\t        nearbyChars.push(c);\n\t      }\n\t    }\n\n\t    var randomChar = nearbyChars.length > 0 ? nearbyChars[_utils2['default'].random(0, nearbyChars.length - 1)] : this.randomChar(locale);\n\n\t    if (uppercase) {\n\t      randomChar = randomChar.toUpperCase();\n\t    }\n\n\t    return randomChar;\n\t  },\n\n\t  randomChar: function randomChar(locale) {\n\t    if (!this.supports(locale)) {\n\t      throw new Error('locale \"' + locale + '\" is not supported');\n\t    }\n\n\t    var chars = _keyboardsJson2['default'][locale].list.join('');\n\t    return chars.charAt(_utils2['default'].random(0, chars.length - 1));\n\t  }\n\t};\n\tmodule.exports = exports['default'];\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports) {\n\n\tmodule.exports = {\"en\":[\"qwertyuiop\",\"asdfghjkl\",\"zxcvbnm\"],\"fr\":[\"azertyuiop\",\"qsdfghjklm\",\"wxcvbn\"],\"da\":[\"qwertyuiopå\",\"asdfghjklæø\",\"zxcvbnm\"],\"de\":[\"qwertzuiopü\",\"asdfghjklöä\",\"yxcvbnm\"],\"pl\":[\"qwertyuiopęó\",\"asdfghjkląśł\",\"zxcvbnmżźćń\"],\"pt\":[\"qwertyuiop\",\"asdfghjklç\",\"zxcvbnm\"],\"ru\":[\"йцукенгшщзх\",\"фывапролджэ\",\"ячсмитьбюъ\"],\"es\":[\"qwertyuiop\",\"asdfghjklñ\",\"zxcvbnm\"],\"el\":[\";ςερτυθιοπ\",\"ασδφγηξκλ\",\"ζχψωβνμ\"]}\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\n\tObject.defineProperty(exports, '__esModule', {\n\t  value: true\n\t});\n\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\n\tvar _voidElementsJson = __webpack_require__(7);\n\n\tvar _voidElementsJson2 = _interopRequireDefault(_voidElementsJson);\n\n\tfunction isVoidElement(tag) {\n\t  var tagName = tag.match(/<([^\\s>]+)/);\n\t  return Boolean(tagName) && _voidElementsJson2['default'].indexOf(tagName[1].toLowerCase()) > -1;\n\t}\n\n\texports['default'] = {\n\t  strip: function strip(str) {\n\t    return str.replace(/(<([^>]+)>)/gi, '');\n\t  },\n\n\t  map: function map(str) {\n\t    var regexp = /<[^>]+>/gi;\n\t    var tags = [];\n\t    var openers = [];\n\t    var result = undefined;\n\t    var tag = undefined;\n\n\t    while (result = regexp.exec(str)) {\n\t      tag = {\n\t        tagName: result[0],\n\t        position: result.index\n\t      };\n\n\t      if (tag.tagName.charAt(1) === '/') {\n\t        tag.opener = openers.pop();\n\t      } else if (tag.tagName.charAt(tag.tagName.length - 2) !== '/' && !isVoidElement(tag.tagName)) {\n\t        openers.push(tag);\n\t      }\n\n\t      tags.push(tag);\n\t    }\n\n\t    return tags;\n\t  },\n\n\t  inject: function inject(str, map) {\n\t    for (var i = 0, tag = undefined; i < map.length; i++) {\n\t      tag = map[i];\n\n\t      if (str.length > 0 && tag.position <= str.length) {\n\t        str = str.substr(0, tag.position) + tag.tagName + str.substr(tag.position);\n\t      } else if (tag.opener && tag.opener.position < str.length) {\n\t        str += tag.tagName;\n\t      }\n\t    }\n\n\t    return str;\n\t  }\n\t};\n\tmodule.exports = exports['default'];\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports) {\n\n\tmodule.exports = [\"area\",\"base\",\"br\",\"col\",\"embed\",\"hr\",\"img\",\"input\",\"keygen\",\"link\",\"menuitem\",\"meta\",\"param\",\"source\",\"track\",\"wbr\"]\n\n/***/ })\n/******/ ])\n});\n;","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst Shuffle = require(\"shufflejs\");\nconst tiltjs = require(\"vanilla-tilt\");\nconst app = {\n    loadApplication: () => {\n        Array.from(document.getElementsByClassName(\"view\")).forEach((element) => {\n            element.addEventListener(\"click\", (e) => {\n                e.preventDefault();\n                return false;\n            });\n        });\n        const element = document.querySelector(\".tilted\");\n        const tiltConfig = {\n            reverse: false,\n            max: 22,\n            startX: 0,\n            startY: 10,\n            perspective: 1000,\n            speed: 200,\n            transition: true,\n            \"mouse-event-element\": \"body\",\n        };\n        tiltjs.init(element, tiltConfig);\n    },\n    worksFilter: () => {\n        const grid = document.getElementById(\"work-grid\");\n        const sizer = document.getElementsByClassName(\"shuffle__sizer\")[0];\n        const btns = document.getElementsByClassName(\"svg-wrapper\");\n        if (grid) {\n            const shfl = new Shuffle(grid, {\n                itemSelector: \".work-item\",\n                easing: \"ease-in-out\",\n                sizer: sizer,\n                speed: 600,\n            });\n            Array.from(btns).forEach((btn) => {\n                btn.addEventListener(\"click\", (e) => {\n                    let group, isActive;\n                    e.preventDefault();\n                    isActive = btn.classList.contains(\"active\");\n                    if (!isActive) {\n                        group = btn.getElementsByTagName(\"a\")[0].getAttribute(\"data-group\") || undefined;\n                        Array.from(document.querySelectorAll(\".active\")).forEach((el) => el.classList.remove(\"active\"));\n                        btn.classList.toggle(\"active\");\n                        shfl.filter(group);\n                    }\n                });\n            });\n        }\n    },\n};\nexports.default = app;\n","/*!\r\n * ScrollMagic v2.0.8 (2020-08-14)\r\n * The javascript library for magical scroll interactions.\r\n * (c) 2020 Jan Paepke (@janpaepke)\r\n * Project Website: http://scrollmagic.io\r\n * \r\n * @version 2.0.8\r\n * @license Dual licensed under MIT license and GPL.\r\n * @author Jan Paepke - e-mail@janpaepke.de\r\n *\r\n * @file ScrollMagic main library.\r\n */\r\n/**\r\n * @namespace ScrollMagic\r\n */\r\n(function (root, factory) {\r\n\tif (typeof define === 'function' && define.amd) {\r\n\t\t// AMD. Register as an anonymous module.\r\n\t\tdefine(factory);\r\n\t} else if (typeof exports === 'object') {\r\n\t\t// CommonJS\r\n\t\tmodule.exports = factory();\r\n\t} else {\r\n\t\t// Browser global\r\n\t\troot.ScrollMagic = factory();\r\n\t}\r\n}(this, function () {\r\n\t\"use strict\";\r\n\r\n\tvar ScrollMagic = function () {\r\n\t\t_util.log(2, '(COMPATIBILITY NOTICE) -> As of ScrollMagic 2.0.0 you need to use \\'new ScrollMagic.Controller()\\' to create a new controller instance. Use \\'new ScrollMagic.Scene()\\' to instance a scene.');\r\n\t};\r\n\r\n\tScrollMagic.version = \"2.0.8\";\r\n\r\n\t// TODO: temporary workaround for chrome's scroll jitter bug\r\n\tif (typeof (window) !== 'undefined') {\r\n\t\twindow.addEventListener(\"mousewheel\", void(0));\r\n\t}\r\n\r\n\t// global const\r\n\tvar PIN_SPACER_ATTRIBUTE = \"data-scrollmagic-pin-spacer\";\r\n\r\n\t/**\r\n\t * The main class that is needed once per scroll container.\r\n\t *\r\n\t * @class\r\n\t *\r\n\t * @example\r\n\t * // basic initialization\r\n\t * var controller = new ScrollMagic.Controller();\r\n\t *\r\n\t * // passing options\r\n\t * var controller = new ScrollMagic.Controller({container: \"#myContainer\", loglevel: 3});\r\n\t *\r\n\t * @param {object} [options] - An object containing one or more options for the controller.\r\n\t * @param {(string|object)} [options.container=window] - A selector, DOM object that references the main container for scrolling.\r\n\t * @param {boolean} [options.vertical=true] - Sets the scroll mode to vertical (`true`) or horizontal (`false`) scrolling.\r\n\t * @param {object} [options.globalSceneOptions={}] - These options will be passed to every Scene that is added to the controller using the addScene method. For more information on Scene options see {@link ScrollMagic.Scene}.\r\n\t * @param {number} [options.loglevel=2] Loglevel for debugging. Note that logging is disabled in the minified version of ScrollMagic.\r\n\t\t\t\t\t\t\t\t\t\t\t ** `0` => silent\r\n\t\t\t\t\t\t\t\t\t\t\t ** `1` => errors\r\n\t\t\t\t\t\t\t\t\t\t\t ** `2` => errors, warnings\r\n\t\t\t\t\t\t\t\t\t\t\t ** `3` => errors, warnings, debuginfo\r\n\t * @param {boolean} [options.refreshInterval=100] - Some changes don't call events by default, like changing the container size or moving a scene trigger element.  \r\n\t \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t This interval polls these parameters to fire the necessary events.  \r\n\t \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t If you don't use custom containers, trigger elements or have static layouts, where the positions of the trigger elements don't change, you can set this to 0 disable interval checking and improve performance.\r\n\t *\r\n\t */\r\n\tScrollMagic.Controller = function (options) {\r\n\t\t/*\r\n\t\t * ----------------------------------------------------------------\r\n\t\t * settings\r\n\t\t * ----------------------------------------------------------------\r\n\t\t */\r\n\t\tvar\r\n\t\t\tNAMESPACE = 'ScrollMagic.Controller',\r\n\t\t\tSCROLL_DIRECTION_FORWARD = 'FORWARD',\r\n\t\t\tSCROLL_DIRECTION_REVERSE = 'REVERSE',\r\n\t\t\tSCROLL_DIRECTION_PAUSED = 'PAUSED',\r\n\t\t\tDEFAULT_OPTIONS = CONTROLLER_OPTIONS.defaults;\r\n\r\n\t\t/*\r\n\t\t * ----------------------------------------------------------------\r\n\t\t * private vars\r\n\t\t * ----------------------------------------------------------------\r\n\t\t */\r\n\t\tvar\r\n\t\t\tController = this,\r\n\t\t\t_options = _util.extend({}, DEFAULT_OPTIONS, options),\r\n\t\t\t_sceneObjects = [],\r\n\t\t\t_updateScenesOnNextCycle = false, // can be boolean (true => all scenes) or an array of scenes to be updated\r\n\t\t\t_scrollPos = 0,\r\n\t\t\t_scrollDirection = SCROLL_DIRECTION_PAUSED,\r\n\t\t\t_isDocument = true,\r\n\t\t\t_viewPortSize = 0,\r\n\t\t\t_enabled = true,\r\n\t\t\t_updateTimeout,\r\n\t\t\t_refreshTimeout;\r\n\r\n\t\t/*\r\n\t\t * ----------------------------------------------------------------\r\n\t\t * private functions\r\n\t\t * ----------------------------------------------------------------\r\n\t\t */\r\n\r\n\t\t/**\r\n\t\t * Internal constructor function of the ScrollMagic Controller\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar construct = function () {\r\n\t\t\tfor (var key in _options) {\r\n\t\t\t\tif (!DEFAULT_OPTIONS.hasOwnProperty(key)) {\r\n\t\t\t\t\tlog(2, \"WARNING: Unknown option \\\"\" + key + \"\\\"\");\r\n\t\t\t\t\tdelete _options[key];\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t_options.container = _util.get.elements(_options.container)[0];\r\n\t\t\t// check ScrollContainer\r\n\t\t\tif (!_options.container) {\r\n\t\t\t\tlog(1, \"ERROR creating object \" + NAMESPACE + \": No valid scroll container supplied\");\r\n\t\t\t\tthrow NAMESPACE + \" init failed.\"; // cancel\r\n\t\t\t}\r\n\t\t\t_isDocument = _options.container === window || _options.container === document.body || !document.body.contains(_options.container);\r\n\t\t\t// normalize to window\r\n\t\t\tif (_isDocument) {\r\n\t\t\t\t_options.container = window;\r\n\t\t\t}\r\n\t\t\t// update container size immediately\r\n\t\t\t_viewPortSize = getViewportSize();\r\n\t\t\t// set event handlers\r\n\t\t\t_options.container.addEventListener(\"resize\", onChange);\r\n\t\t\t_options.container.addEventListener(\"scroll\", onChange);\r\n\r\n\t\t\tvar ri = parseInt(_options.refreshInterval, 10);\r\n\t\t\t_options.refreshInterval = _util.type.Number(ri) ? ri : DEFAULT_OPTIONS.refreshInterval;\r\n\t\t\tscheduleRefresh();\r\n\r\n\t\t\tlog(3, \"added new \" + NAMESPACE + \" controller (v\" + ScrollMagic.version + \")\");\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Schedule the next execution of the refresh function\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar scheduleRefresh = function () {\r\n\t\t\tif (_options.refreshInterval > 0) {\r\n\t\t\t\t_refreshTimeout = window.setTimeout(refresh, _options.refreshInterval);\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Default function to get scroll pos - overwriteable using `Controller.scrollPos(newFunction)`\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar getScrollPos = function () {\r\n\t\t\treturn _options.vertical ? _util.get.scrollTop(_options.container) : _util.get.scrollLeft(_options.container);\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Returns the current viewport Size (width vor horizontal, height for vertical)\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar getViewportSize = function () {\r\n\t\t\treturn _options.vertical ? _util.get.height(_options.container) : _util.get.width(_options.container);\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Default function to set scroll pos - overwriteable using `Controller.scrollTo(newFunction)`\r\n\t\t * Make available publicly for pinned mousewheel workaround.\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar setScrollPos = this._setScrollPos = function (pos) {\r\n\t\t\tif (_options.vertical) {\r\n\t\t\t\tif (_isDocument) {\r\n\t\t\t\t\twindow.scrollTo(_util.get.scrollLeft(), pos);\r\n\t\t\t\t} else {\r\n\t\t\t\t\t_options.container.scrollTop = pos;\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tif (_isDocument) {\r\n\t\t\t\t\twindow.scrollTo(pos, _util.get.scrollTop());\r\n\t\t\t\t} else {\r\n\t\t\t\t\t_options.container.scrollLeft = pos;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Handle updates in cycles instead of on scroll (performance)\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar updateScenes = function () {\r\n\t\t\tif (_enabled && _updateScenesOnNextCycle) {\r\n\t\t\t\t// determine scenes to update\r\n\t\t\t\tvar scenesToUpdate = _util.type.Array(_updateScenesOnNextCycle) ? _updateScenesOnNextCycle : _sceneObjects.slice(0);\r\n\t\t\t\t// reset scenes\r\n\t\t\t\t_updateScenesOnNextCycle = false;\r\n\t\t\t\tvar oldScrollPos = _scrollPos;\r\n\t\t\t\t// update scroll pos now instead of onChange, as it might have changed since scheduling (i.e. in-browser smooth scroll)\r\n\t\t\t\t_scrollPos = Controller.scrollPos();\r\n\t\t\t\tvar deltaScroll = _scrollPos - oldScrollPos;\r\n\t\t\t\tif (deltaScroll !== 0) { // scroll position changed?\r\n\t\t\t\t\t_scrollDirection = (deltaScroll > 0) ? SCROLL_DIRECTION_FORWARD : SCROLL_DIRECTION_REVERSE;\r\n\t\t\t\t}\r\n\t\t\t\t// reverse order of scenes if scrolling reverse\r\n\t\t\t\tif (_scrollDirection === SCROLL_DIRECTION_REVERSE) {\r\n\t\t\t\t\tscenesToUpdate.reverse();\r\n\t\t\t\t}\r\n\t\t\t\t// update scenes\r\n\t\t\t\tscenesToUpdate.forEach(function (scene, index) {\r\n\t\t\t\t\tlog(3, \"updating Scene \" + (index + 1) + \"/\" + scenesToUpdate.length + \" (\" + _sceneObjects.length + \" total)\");\r\n\t\t\t\t\tscene.update(true);\r\n\t\t\t\t});\r\n\t\t\t\tif (scenesToUpdate.length === 0 && _options.loglevel >= 3) {\r\n\t\t\t\t\tlog(3, \"updating 0 Scenes (nothing added to controller)\");\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Initializes rAF callback\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar debounceUpdate = function () {\r\n\t\t\t_updateTimeout = _util.rAF(updateScenes);\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Handles Container changes\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar onChange = function (e) {\r\n\t\t\tlog(3, \"event fired causing an update:\", e.type);\r\n\t\t\tif (e.type == \"resize\") {\r\n\t\t\t\t// resize\r\n\t\t\t\t_viewPortSize = getViewportSize();\r\n\t\t\t\t_scrollDirection = SCROLL_DIRECTION_PAUSED;\r\n\t\t\t}\r\n\t\t\t// schedule update\r\n\t\t\tif (_updateScenesOnNextCycle !== true) {\r\n\t\t\t\t_updateScenesOnNextCycle = true;\r\n\t\t\t\tdebounceUpdate();\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\tvar refresh = function () {\r\n\t\t\tif (!_isDocument) {\r\n\t\t\t\t// simulate resize event. Only works for viewport relevant param (performance)\r\n\t\t\t\tif (_viewPortSize != getViewportSize()) {\r\n\t\t\t\t\tvar resizeEvent;\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tresizeEvent = new Event('resize', {\r\n\t\t\t\t\t\t\tbubbles: false,\r\n\t\t\t\t\t\t\tcancelable: false\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t} catch (e) { // stupid IE\r\n\t\t\t\t\t\tresizeEvent = document.createEvent(\"Event\");\r\n\t\t\t\t\t\tresizeEvent.initEvent(\"resize\", false, false);\r\n\t\t\t\t\t}\r\n\t\t\t\t\t_options.container.dispatchEvent(resizeEvent);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t_sceneObjects.forEach(function (scene, index) { // refresh all scenes\r\n\t\t\t\tscene.refresh();\r\n\t\t\t});\r\n\t\t\tscheduleRefresh();\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Send a debug message to the console.\r\n\t\t * provided publicly with _log for plugins\r\n\t\t * @private\r\n\t\t *\r\n\t\t * @param {number} loglevel - The loglevel required to initiate output for the message.\r\n\t\t * @param {...mixed} output - One or more variables that should be passed to the console.\r\n\t\t */\r\n\t\tvar log = this._log = function (loglevel, output) {\r\n\t\t\tif (_options.loglevel >= loglevel) {\r\n\t\t\t\tArray.prototype.splice.call(arguments, 1, 0, \"(\" + NAMESPACE + \") ->\");\r\n\t\t\t\t_util.log.apply(window, arguments);\r\n\t\t\t}\r\n\t\t};\r\n\t\t// for scenes we have getters for each option, but for the controller we don't, so we need to make it available externally for plugins\r\n\t\tthis._options = _options;\r\n\r\n\t\t/**\r\n\t\t * Sort scenes in ascending order of their start offset.\r\n\t\t * @private\r\n\t\t *\r\n\t\t * @param {array} ScenesArray - an array of ScrollMagic Scenes that should be sorted\r\n\t\t * @return {array} The sorted array of Scenes.\r\n\t\t */\r\n\t\tvar sortScenes = function (ScenesArray) {\r\n\t\t\tif (ScenesArray.length <= 1) {\r\n\t\t\t\treturn ScenesArray;\r\n\t\t\t} else {\r\n\t\t\t\tvar scenes = ScenesArray.slice(0);\r\n\t\t\t\tscenes.sort(function (a, b) {\r\n\t\t\t\t\treturn a.scrollOffset() > b.scrollOffset() ? 1 : -1;\r\n\t\t\t\t});\r\n\t\t\t\treturn scenes;\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * ----------------------------------------------------------------\r\n\t\t * public functions\r\n\t\t * ----------------------------------------------------------------\r\n\t\t */\r\n\r\n\t\t/**\r\n\t\t * Add one ore more scene(s) to the controller.  \r\n\t\t * This is the equivalent to `Scene.addTo(controller)`.\r\n\t\t * @public\r\n\t\t * @example\r\n\t\t * // with a previously defined scene\r\n\t\t * controller.addScene(scene);\r\n\t\t *\r\n\t\t * // with a newly created scene.\r\n\t\t * controller.addScene(new ScrollMagic.Scene({duration : 0}));\r\n\t\t *\r\n\t\t * // adding multiple scenes\r\n\t\t * controller.addScene([scene, scene2, new ScrollMagic.Scene({duration : 0})]);\r\n\t\t *\r\n\t\t * @param {(ScrollMagic.Scene|array)} newScene - ScrollMagic Scene or Array of Scenes to be added to the controller.\r\n\t\t * @return {Controller} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.addScene = function (newScene) {\r\n\t\t\tif (_util.type.Array(newScene)) {\r\n\t\t\t\tnewScene.forEach(function (scene, index) {\r\n\t\t\t\t\tController.addScene(scene);\r\n\t\t\t\t});\r\n\t\t\t} else if (newScene instanceof ScrollMagic.Scene) {\r\n\t\t\t\tif (newScene.controller() !== Controller) {\r\n\t\t\t\t\tnewScene.addTo(Controller);\r\n\t\t\t\t} else if (_sceneObjects.indexOf(newScene) < 0) {\r\n\t\t\t\t\t// new scene\r\n\t\t\t\t\t_sceneObjects.push(newScene); // add to array\r\n\t\t\t\t\t_sceneObjects = sortScenes(_sceneObjects); // sort\r\n\t\t\t\t\tnewScene.on(\"shift.controller_sort\", function () { // resort whenever scene moves\r\n\t\t\t\t\t\t_sceneObjects = sortScenes(_sceneObjects);\r\n\t\t\t\t\t});\r\n\t\t\t\t\t// insert Global defaults.\r\n\t\t\t\t\tfor (var key in _options.globalSceneOptions) {\r\n\t\t\t\t\t\tif (newScene[key]) {\r\n\t\t\t\t\t\t\tnewScene[key].call(newScene, _options.globalSceneOptions[key]);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\tlog(3, \"adding Scene (now \" + _sceneObjects.length + \" total)\");\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tlog(1, \"ERROR: invalid argument supplied for '.addScene()'\");\r\n\t\t\t}\r\n\t\t\treturn Controller;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Remove one ore more scene(s) from the controller.  \r\n\t\t * This is the equivalent to `Scene.remove()`.\r\n\t\t * @public\r\n\t\t * @example\r\n\t\t * // remove a scene from the controller\r\n\t\t * controller.removeScene(scene);\r\n\t\t *\r\n\t\t * // remove multiple scenes from the controller\r\n\t\t * controller.removeScene([scene, scene2, scene3]);\r\n\t\t *\r\n\t\t * @param {(ScrollMagic.Scene|array)} Scene - ScrollMagic Scene or Array of Scenes to be removed from the controller.\r\n\t\t * @returns {Controller} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.removeScene = function (Scene) {\r\n\t\t\tif (_util.type.Array(Scene)) {\r\n\t\t\t\tScene.forEach(function (scene, index) {\r\n\t\t\t\t\tController.removeScene(scene);\r\n\t\t\t\t});\r\n\t\t\t} else {\r\n\t\t\t\tvar index = _sceneObjects.indexOf(Scene);\r\n\t\t\t\tif (index > -1) {\r\n\t\t\t\t\tScene.off(\"shift.controller_sort\");\r\n\t\t\t\t\t_sceneObjects.splice(index, 1);\r\n\t\t\t\t\tlog(3, \"removing Scene (now \" + _sceneObjects.length + \" left)\");\r\n\t\t\t\t\tScene.remove();\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn Controller;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t * Update one ore more scene(s) according to the scroll position of the container.  \r\n\t * This is the equivalent to `Scene.update()`.  \r\n\t * The update method calculates the scene's start and end position (based on the trigger element, trigger hook, duration and offset) and checks it against the current scroll position of the container.  \r\n\t * It then updates the current scene state accordingly (or does nothing, if the state is already correct) – Pins will be set to their correct position and tweens will be updated to their correct progress.  \r\n\t * _**Note:** This method gets called constantly whenever Controller detects a change. The only application for you is if you change something outside of the realm of ScrollMagic, like moving the trigger or changing tween parameters._\r\n\t * @public\r\n\t * @example\r\n\t * // update a specific scene on next cycle\r\n \t * controller.updateScene(scene);\r\n \t *\r\n\t * // update a specific scene immediately\r\n\t * controller.updateScene(scene, true);\r\n \t *\r\n\t * // update multiple scenes scene on next cycle\r\n\t * controller.updateScene([scene1, scene2, scene3]);\r\n\t *\r\n\t * @param {ScrollMagic.Scene} Scene - ScrollMagic Scene or Array of Scenes that is/are supposed to be updated.\r\n\t * @param {boolean} [immediately=false] - If `true` the update will be instant, if `false` it will wait until next update cycle.  \r\n\t \t\t\t\t\t\t\t\t\t\t  This is useful when changing multiple properties of the scene - this way it will only be updated once all new properties are set (updateScenes).\r\n\t * @return {Controller} Parent object for chaining.\r\n\t */\r\n\t\tthis.updateScene = function (Scene, immediately) {\r\n\t\t\tif (_util.type.Array(Scene)) {\r\n\t\t\t\tScene.forEach(function (scene, index) {\r\n\t\t\t\t\tController.updateScene(scene, immediately);\r\n\t\t\t\t});\r\n\t\t\t} else {\r\n\t\t\t\tif (immediately) {\r\n\t\t\t\t\tScene.update(true);\r\n\t\t\t\t} else if (_updateScenesOnNextCycle !== true && Scene instanceof ScrollMagic.Scene) { // if _updateScenesOnNextCycle is true, all connected scenes are already scheduled for update\r\n\t\t\t\t\t// prep array for next update cycle\r\n\t\t\t\t\t_updateScenesOnNextCycle = _updateScenesOnNextCycle || [];\r\n\t\t\t\t\tif (_updateScenesOnNextCycle.indexOf(Scene) == -1) {\r\n\t\t\t\t\t\t_updateScenesOnNextCycle.push(Scene);\r\n\t\t\t\t\t}\r\n\t\t\t\t\t_updateScenesOnNextCycle = sortScenes(_updateScenesOnNextCycle); // sort\r\n\t\t\t\t\tdebounceUpdate();\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn Controller;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Updates the controller params and calls updateScene on every scene, that is attached to the controller.  \r\n\t\t * See `Controller.updateScene()` for more information about what this means.  \r\n\t\t * In most cases you will not need this function, as it is called constantly, whenever ScrollMagic detects a state change event, like resize or scroll.  \r\n\t\t * The only application for this method is when ScrollMagic fails to detect these events.  \r\n\t\t * One application is with some external scroll libraries (like iScroll) that move an internal container to a negative offset instead of actually scrolling. In this case the update on the controller needs to be called whenever the child container's position changes.\r\n\t\t * For this case there will also be the need to provide a custom function to calculate the correct scroll position. See `Controller.scrollPos()` for details.\r\n\t\t * @public\r\n\t\t * @example\r\n\t\t * // update the controller on next cycle (saves performance due to elimination of redundant updates)\r\n\t\t * controller.update();\r\n\t\t *\r\n\t\t * // update the controller immediately\r\n\t\t * controller.update(true);\r\n\t\t *\r\n\t\t * @param {boolean} [immediately=false] - If `true` the update will be instant, if `false` it will wait until next update cycle (better performance)\r\n\t\t * @return {Controller} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.update = function (immediately) {\r\n\t\t\tonChange({\r\n\t\t\t\ttype: \"resize\"\r\n\t\t\t}); // will update size and set _updateScenesOnNextCycle to true\r\n\t\t\tif (immediately) {\r\n\t\t\t\tupdateScenes();\r\n\t\t\t}\r\n\t\t\treturn Controller;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Scroll to a numeric scroll offset, a DOM element, the start of a scene or provide an alternate method for scrolling.  \r\n\t\t * For vertical controllers it will change the top scroll offset and for horizontal applications it will change the left offset.\r\n\t\t * @public\r\n\t\t *\r\n\t\t * @since 1.1.0\r\n\t\t * @example\r\n\t\t * // scroll to an offset of 100\r\n\t\t * controller.scrollTo(100);\r\n\t\t *\r\n\t\t * // scroll to a DOM element\r\n\t\t * controller.scrollTo(\"#anchor\");\r\n\t\t *\r\n\t\t * // scroll to the beginning of a scene\r\n\t\t * var scene = new ScrollMagic.Scene({offset: 200});\r\n\t\t * controller.scrollTo(scene);\r\n\t\t *\r\n\t\t * // define a new scroll position modification function (jQuery animate instead of jump)\r\n\t\t * controller.scrollTo(function (newScrollPos) {\r\n\t\t *\t$(\"html, body\").animate({scrollTop: newScrollPos});\r\n\t\t * });\r\n\t\t * controller.scrollTo(100); // call as usual, but the new function will be used instead\r\n\t\t *\r\n\t\t * // define a new scroll function with an additional parameter\r\n\t\t * controller.scrollTo(function (newScrollPos, message) {\r\n\t\t *  console.log(message);\r\n\t\t *\t$(this).animate({scrollTop: newScrollPos});\r\n\t\t * });\r\n\t\t * // call as usual, but supply an extra parameter to the defined custom function\r\n\t\t * controller.scrollTo(100, \"my message\");\r\n\t\t *\r\n\t\t * // define a new scroll function with an additional parameter containing multiple variables\r\n\t\t * controller.scrollTo(function (newScrollPos, options) {\r\n\t\t *  someGlobalVar = options.a + options.b;\r\n\t\t *\t$(this).animate({scrollTop: newScrollPos});\r\n\t\t * });\r\n\t\t * // call as usual, but supply an extra parameter containing multiple options\r\n\t\t * controller.scrollTo(100, {a: 1, b: 2});\r\n\t\t *\r\n\t\t * // define a new scroll function with a callback supplied as an additional parameter\r\n\t\t * controller.scrollTo(function (newScrollPos, callback) {\r\n\t\t *\t$(this).animate({scrollTop: newScrollPos}, 400, \"swing\", callback);\r\n\t\t * });\r\n\t\t * // call as usual, but supply an extra parameter, which is used as a callback in the previously defined custom scroll function\r\n\t\t * controller.scrollTo(100, function() {\r\n\t\t *\tconsole.log(\"scroll has finished.\");\r\n\t\t * });\r\n\t\t *\r\n\t\t * @param {mixed} scrollTarget - The supplied argument can be one of these types:\r\n\t\t * 1. `number` -> The container will scroll to this new scroll offset.\r\n\t\t * 2. `string` or `object` -> Can be a selector or a DOM object.  \r\n\t\t *  The container will scroll to the position of this element.\r\n\t\t * 3. `ScrollMagic Scene` -> The container will scroll to the start of this scene.\r\n\t\t * 4. `function` -> This function will be used for future scroll position modifications.  \r\n\t\t *  This provides a way for you to change the behaviour of scrolling and adding new behaviour like animation. The function receives the new scroll position as a parameter and a reference to the container element using `this`.  \r\n\t\t *  It may also optionally receive an optional additional parameter (see below)  \r\n\t\t *  _**NOTE:**  \r\n\t\t *  All other options will still work as expected, using the new function to scroll._\r\n\t\t * @param {mixed} [additionalParameter] - If a custom scroll function was defined (see above 4.), you may want to supply additional parameters to it, when calling it. You can do this using this parameter – see examples for details. Please note, that this parameter will have no effect, if you use the default scrolling function.\r\n\t\t * @returns {Controller} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.scrollTo = function (scrollTarget, additionalParameter) {\r\n\t\t\tif (_util.type.Number(scrollTarget)) { // excecute\r\n\t\t\t\tsetScrollPos.call(_options.container, scrollTarget, additionalParameter);\r\n\t\t\t} else if (scrollTarget instanceof ScrollMagic.Scene) { // scroll to scene\r\n\t\t\t\tif (scrollTarget.controller() === Controller) { // check if the controller is associated with this scene\r\n\t\t\t\t\tController.scrollTo(scrollTarget.scrollOffset(), additionalParameter);\r\n\t\t\t\t} else {\r\n\t\t\t\t\tlog(2, \"scrollTo(): The supplied scene does not belong to this controller. Scroll cancelled.\", scrollTarget);\r\n\t\t\t\t}\r\n\t\t\t} else if (_util.type.Function(scrollTarget)) { // assign new scroll function\r\n\t\t\t\tsetScrollPos = scrollTarget;\r\n\t\t\t} else { // scroll to element\r\n\t\t\t\tvar elem = _util.get.elements(scrollTarget)[0];\r\n\t\t\t\tif (elem) {\r\n\t\t\t\t\t// if parent is pin spacer, use spacer position instead so correct start position is returned for pinned elements.\r\n\t\t\t\t\twhile (elem.parentNode.hasAttribute(PIN_SPACER_ATTRIBUTE)) {\r\n\t\t\t\t\t\telem = elem.parentNode;\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tvar\r\n\t\t\t\t\t\tparam = _options.vertical ? \"top\" : \"left\", // which param is of interest ?\r\n\t\t\t\t\t\tcontainerOffset = _util.get.offset(_options.container), // container position is needed because element offset is returned in relation to document, not in relation to container.\r\n\t\t\t\t\t\telementOffset = _util.get.offset(elem);\r\n\r\n\t\t\t\t\tif (!_isDocument) { // container is not the document root, so substract scroll Position to get correct trigger element position relative to scrollcontent\r\n\t\t\t\t\t\tcontainerOffset[param] -= Controller.scrollPos();\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tController.scrollTo(elementOffset[param] - containerOffset[param], additionalParameter);\r\n\t\t\t\t} else {\r\n\t\t\t\t\tlog(2, \"scrollTo(): The supplied argument is invalid. Scroll cancelled.\", scrollTarget);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn Controller;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * **Get** the current scrollPosition or **Set** a new method to calculate it.  \r\n\t\t * -> **GET**:\r\n\t\t * When used as a getter this function will return the current scroll position.  \r\n\t\t * To get a cached value use Controller.info(\"scrollPos\"), which will be updated in the update cycle.  \r\n\t\t * For vertical controllers it will return the top scroll offset and for horizontal applications it will return the left offset.\r\n\t\t *\r\n\t\t * -> **SET**:\r\n\t\t * When used as a setter this method prodes a way to permanently overwrite the controller's scroll position calculation.  \r\n\t\t * A typical usecase is when the scroll position is not reflected by the containers scrollTop or scrollLeft values, but for example by the inner offset of a child container.  \r\n\t\t * Moving a child container inside a parent is a commonly used method for several scrolling frameworks, including iScroll.  \r\n\t\t * By providing an alternate calculation function you can make sure ScrollMagic receives the correct scroll position.  \r\n\t\t * Please also bear in mind that your function should return y values for vertical scrolls an x for horizontals.\r\n\t\t *\r\n\t\t * To change the current scroll position please use `Controller.scrollTo()`.\r\n\t\t * @public\r\n\t\t *\r\n\t\t * @example\r\n\t\t * // get the current scroll Position\r\n\t\t * var scrollPos = controller.scrollPos();\r\n\t\t *\r\n\t\t * // set a new scroll position calculation method\r\n\t\t * controller.scrollPos(function () {\r\n\t\t *\treturn this.info(\"vertical\") ? -mychildcontainer.y : -mychildcontainer.x\r\n\t\t * });\r\n\t\t *\r\n\t\t * @param {function} [scrollPosMethod] - The function to be used for the scroll position calculation of the container.\r\n\t\t * @returns {(number|Controller)} Current scroll position or parent object for chaining.\r\n\t\t */\r\n\t\tthis.scrollPos = function (scrollPosMethod) {\r\n\t\t\tif (!arguments.length) { // get\r\n\t\t\t\treturn getScrollPos.call(Controller);\r\n\t\t\t} else { // set\r\n\t\t\t\tif (_util.type.Function(scrollPosMethod)) {\r\n\t\t\t\t\tgetScrollPos = scrollPosMethod;\r\n\t\t\t\t} else {\r\n\t\t\t\t\tlog(2, \"Provided value for method 'scrollPos' is not a function. To change the current scroll position use 'scrollTo()'.\");\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn Controller;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * **Get** all infos or one in particular about the controller.\r\n\t\t * @public\r\n\t\t * @example\r\n\t\t * // returns the current scroll position (number)\r\n\t\t * var scrollPos = controller.info(\"scrollPos\");\r\n\t\t *\r\n\t\t * // returns all infos as an object\r\n\t\t * var infos = controller.info();\r\n\t\t *\r\n\t\t * @param {string} [about] - If passed only this info will be returned instead of an object containing all.  \r\n\t\t \t\t\t\t\t\t\t Valid options are:\r\n\t\t \t\t\t\t\t\t\t ** `\"size\"` => the current viewport size of the container\r\n\t\t \t\t\t\t\t\t\t ** `\"vertical\"` => true if vertical scrolling, otherwise false\r\n\t\t \t\t\t\t\t\t\t ** `\"scrollPos\"` => the current scroll position\r\n\t\t \t\t\t\t\t\t\t ** `\"scrollDirection\"` => the last known direction of the scroll\r\n\t\t \t\t\t\t\t\t\t ** `\"container\"` => the container element\r\n\t\t \t\t\t\t\t\t\t ** `\"isDocument\"` => true if container element is the document.\r\n\t\t * @returns {(mixed|object)} The requested info(s).\r\n\t\t */\r\n\t\tthis.info = function (about) {\r\n\t\t\tvar values = {\r\n\t\t\t\tsize: _viewPortSize, // contains height or width (in regard to orientation);\r\n\t\t\t\tvertical: _options.vertical,\r\n\t\t\t\tscrollPos: _scrollPos,\r\n\t\t\t\tscrollDirection: _scrollDirection,\r\n\t\t\t\tcontainer: _options.container,\r\n\t\t\t\tisDocument: _isDocument\r\n\t\t\t};\r\n\t\t\tif (!arguments.length) { // get all as an object\r\n\t\t\t\treturn values;\r\n\t\t\t} else if (values[about] !== undefined) {\r\n\t\t\t\treturn values[about];\r\n\t\t\t} else {\r\n\t\t\t\tlog(1, \"ERROR: option \\\"\" + about + \"\\\" is not available\");\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * **Get** or **Set** the current loglevel option value.\r\n\t\t * @public\r\n\t\t *\r\n\t\t * @example\r\n\t\t * // get the current value\r\n\t\t * var loglevel = controller.loglevel();\r\n\t\t *\r\n\t\t * // set a new value\r\n\t\t * controller.loglevel(3);\r\n\t\t *\r\n\t\t * @param {number} [newLoglevel] - The new loglevel setting of the Controller. `[0-3]`\r\n\t\t * @returns {(number|Controller)} Current loglevel or parent object for chaining.\r\n\t\t */\r\n\t\tthis.loglevel = function (newLoglevel) {\r\n\t\t\tif (!arguments.length) { // get\r\n\t\t\t\treturn _options.loglevel;\r\n\t\t\t} else if (_options.loglevel != newLoglevel) { // set\r\n\t\t\t\t_options.loglevel = newLoglevel;\r\n\t\t\t}\r\n\t\t\treturn Controller;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * **Get** or **Set** the current enabled state of the controller.  \r\n\t\t * This can be used to disable all Scenes connected to the controller without destroying or removing them.\r\n\t\t * @public\r\n\t\t *\r\n\t\t * @example\r\n\t\t * // get the current value\r\n\t\t * var enabled = controller.enabled();\r\n\t\t *\r\n\t\t * // disable the controller\r\n\t\t * controller.enabled(false);\r\n\t\t *\r\n\t\t * @param {boolean} [newState] - The new enabled state of the controller `true` or `false`.\r\n\t\t * @returns {(boolean|Controller)} Current enabled state or parent object for chaining.\r\n\t\t */\r\n\t\tthis.enabled = function (newState) {\r\n\t\t\tif (!arguments.length) { // get\r\n\t\t\t\treturn _enabled;\r\n\t\t\t} else if (_enabled != newState) { // set\r\n\t\t\t\t_enabled = !!newState;\r\n\t\t\t\tController.updateScene(_sceneObjects, true);\r\n\t\t\t}\r\n\t\t\treturn Controller;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Destroy the Controller, all Scenes and everything.\r\n\t\t * @public\r\n\t\t *\r\n\t\t * @example\r\n\t\t * // without resetting the scenes\r\n\t\t * controller = controller.destroy();\r\n\t\t *\r\n\t\t * // with scene reset\r\n\t\t * controller = controller.destroy(true);\r\n\t\t *\r\n\t\t * @param {boolean} [resetScenes=false] - If `true` the pins and tweens (if existent) of all scenes will be reset.\r\n\t\t * @returns {null} Null to unset handler variables.\r\n\t\t */\r\n\t\tthis.destroy = function (resetScenes) {\r\n\t\t\twindow.clearTimeout(_refreshTimeout);\r\n\t\t\tvar i = _sceneObjects.length;\r\n\t\t\twhile (i--) {\r\n\t\t\t\t_sceneObjects[i].destroy(resetScenes);\r\n\t\t\t}\r\n\t\t\t_options.container.removeEventListener(\"resize\", onChange);\r\n\t\t\t_options.container.removeEventListener(\"scroll\", onChange);\r\n\t\t\t_util.cAF(_updateTimeout);\r\n\t\t\tlog(3, \"destroyed \" + NAMESPACE + \" (reset: \" + (resetScenes ? \"true\" : \"false\") + \")\");\r\n\t\t\treturn null;\r\n\t\t};\r\n\r\n\t\t// INIT\r\n\t\tconstruct();\r\n\t\treturn Controller;\r\n\t};\r\n\r\n\t// store pagewide controller options\r\n\tvar CONTROLLER_OPTIONS = {\r\n\t\tdefaults: {\r\n\t\t\tcontainer: window,\r\n\t\t\tvertical: true,\r\n\t\t\tglobalSceneOptions: {},\r\n\t\t\tloglevel: 2,\r\n\t\t\trefreshInterval: 100\r\n\t\t}\r\n\t};\r\n\t/*\r\n\t * method used to add an option to ScrollMagic Scenes.\r\n\t */\r\n\tScrollMagic.Controller.addOption = function (name, defaultValue) {\r\n\t\tCONTROLLER_OPTIONS.defaults[name] = defaultValue;\r\n\t};\r\n\t// instance extension function for plugins\r\n\tScrollMagic.Controller.extend = function (extension) {\r\n\t\tvar oldClass = this;\r\n\t\tScrollMagic.Controller = function () {\r\n\t\t\toldClass.apply(this, arguments);\r\n\t\t\tthis.$super = _util.extend({}, this); // copy parent state\r\n\t\t\treturn extension.apply(this, arguments) || this;\r\n\t\t};\r\n\t\t_util.extend(ScrollMagic.Controller, oldClass); // copy properties\r\n\t\tScrollMagic.Controller.prototype = oldClass.prototype; // copy prototype\r\n\t\tScrollMagic.Controller.prototype.constructor = ScrollMagic.Controller; // restore constructor\r\n\t};\r\n\r\n\r\n\t/**\r\n\t * A Scene defines where the controller should react and how.\r\n\t *\r\n\t * @class\r\n\t *\r\n\t * @example\r\n\t * // create a standard scene and add it to a controller\r\n\t * new ScrollMagic.Scene()\r\n\t *\t\t.addTo(controller);\r\n\t *\r\n\t * // create a scene with custom options and assign a handler to it.\r\n\t * var scene = new ScrollMagic.Scene({\r\n\t * \t\tduration: 100,\r\n\t *\t\toffset: 200,\r\n\t *\t\ttriggerHook: \"onEnter\",\r\n\t *\t\treverse: false\r\n\t * });\r\n\t *\r\n\t * @param {object} [options] - Options for the Scene. The options can be updated at any time.  \r\n\t \t\t\t\t\t\t\t   Instead of setting the options for each scene individually you can also set them globally in the controller as the controllers `globalSceneOptions` option. The object accepts the same properties as the ones below.  \r\n\t \t\t\t\t\t\t\t   When a scene is added to the controller the options defined using the Scene constructor will be overwritten by those set in `globalSceneOptions`.\r\n\t * @param {(number|string|function)} [options.duration=0] - The duration of the scene. \r\n\t \t\t\t\t\tPlease see `Scene.duration()` for details.\r\n\t * @param {number} [options.offset=0] - Offset Value for the Trigger Position. If no triggerElement is defined this will be the scroll distance from the start of the page, after which the scene will start.\r\n\t * @param {(string|object)} [options.triggerElement=null] - Selector or DOM object that defines the start of the scene. If undefined the scene will start right at the start of the page (unless an offset is set).\r\n\t * @param {(number|string)} [options.triggerHook=\"onCenter\"] - Can be a number between 0 and 1 defining the position of the trigger Hook in relation to the viewport.  \r\n\t \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t  Can also be defined using a string:\r\n\t \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t  ** `\"onEnter\"` => `1`\r\n\t \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t  ** `\"onCenter\"` => `0.5`\r\n\t \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t  ** `\"onLeave\"` => `0`\r\n\t * @param {boolean} [options.reverse=true] - Should the scene reverse, when scrolling up?\r\n\t * @param {number} [options.loglevel=2] - Loglevel for debugging. Note that logging is disabled in the minified version of ScrollMagic.\r\n\t \t\t\t\t\t\t\t\t\t\t  ** `0` => silent\r\n\t \t\t\t\t\t\t\t\t\t\t  ** `1` => errors\r\n\t \t\t\t\t\t\t\t\t\t\t  ** `2` => errors, warnings\r\n\t \t\t\t\t\t\t\t\t\t\t  ** `3` => errors, warnings, debuginfo\r\n\t * \r\n\t */\r\n\tScrollMagic.Scene = function (options) {\r\n\r\n\t\t/*\r\n\t\t * ----------------------------------------------------------------\r\n\t\t * settings\r\n\t\t * ----------------------------------------------------------------\r\n\t\t */\r\n\r\n\t\tvar\r\n\t\t\tNAMESPACE = 'ScrollMagic.Scene',\r\n\t\t\tSCENE_STATE_BEFORE = 'BEFORE',\r\n\t\t\tSCENE_STATE_DURING = 'DURING',\r\n\t\t\tSCENE_STATE_AFTER = 'AFTER',\r\n\t\t\tDEFAULT_OPTIONS = SCENE_OPTIONS.defaults;\r\n\r\n\t\t/*\r\n\t\t * ----------------------------------------------------------------\r\n\t\t * private vars\r\n\t\t * ----------------------------------------------------------------\r\n\t\t */\r\n\r\n\t\tvar\r\n\t\t\tScene = this,\r\n\t\t\t_options = _util.extend({}, DEFAULT_OPTIONS, options),\r\n\t\t\t_state = SCENE_STATE_BEFORE,\r\n\t\t\t_progress = 0,\r\n\t\t\t_scrollOffset = {\r\n\t\t\t\tstart: 0,\r\n\t\t\t\tend: 0\r\n\t\t\t}, // reflects the controllers's scroll position for the start and end of the scene respectively\r\n\t\t\t_triggerPos = 0,\r\n\t\t\t_enabled = true,\r\n\t\t\t_durationUpdateMethod,\r\n\t\t\t_controller;\r\n\r\n\t\t/**\r\n\t\t * Internal constructor function of the ScrollMagic Scene\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar construct = function () {\r\n\t\t\tfor (var key in _options) { // check supplied options\r\n\t\t\t\tif (!DEFAULT_OPTIONS.hasOwnProperty(key)) {\r\n\t\t\t\t\tlog(2, \"WARNING: Unknown option \\\"\" + key + \"\\\"\");\r\n\t\t\t\t\tdelete _options[key];\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t// add getters/setters for all possible options\r\n\t\t\tfor (var optionName in DEFAULT_OPTIONS) {\r\n\t\t\t\taddSceneOption(optionName);\r\n\t\t\t}\r\n\t\t\t// validate all options\r\n\t\t\tvalidateOption();\r\n\t\t};\r\n\r\n\t\t/*\r\n\t\t * ----------------------------------------------------------------\r\n\t\t * Event Management\r\n\t\t * ----------------------------------------------------------------\r\n\t\t */\r\n\r\n\t\tvar _listeners = {};\r\n\t\t/**\r\n\t\t * Scene start event.  \r\n\t\t * Fires whenever the scroll position its the starting point of the scene.  \r\n\t\t * It will also fire when scrolling back up going over the start position of the scene. If you want something to happen only when scrolling down/right, use the scrollDirection parameter passed to the callback.\r\n\t\t *\r\n\t\t * For details on this event and the order in which it is fired, please review the {@link Scene.progress} method.\r\n\t\t *\r\n\t\t * @event ScrollMagic.Scene#start\r\n\t\t *\r\n\t\t * @example\r\n\t\t * scene.on(\"start\", function (event) {\r\n\t\t * \tconsole.log(\"Hit start point of scene.\");\r\n\t\t * });\r\n\t\t *\r\n\t\t * @property {object} event - The event Object passed to each callback\r\n\t\t * @property {string} event.type - The name of the event\r\n\t\t * @property {Scene} event.target - The Scene object that triggered this event\r\n\t\t * @property {number} event.progress - Reflects the current progress of the scene\r\n\t\t * @property {string} event.state - The current state of the scene `\"BEFORE\"` or `\"DURING\"`\r\n\t\t * @property {string} event.scrollDirection - Indicates which way we are scrolling `\"PAUSED\"`, `\"FORWARD\"` or `\"REVERSE\"`\r\n\t\t */\r\n\t\t/**\r\n\t\t * Scene end event.  \r\n\t\t * Fires whenever the scroll position its the ending point of the scene.  \r\n\t\t * It will also fire when scrolling back up from after the scene and going over its end position. If you want something to happen only when scrolling down/right, use the scrollDirection parameter passed to the callback.\r\n\t\t *\r\n\t\t * For details on this event and the order in which it is fired, please review the {@link Scene.progress} method.\r\n\t\t *\r\n\t\t * @event ScrollMagic.Scene#end\r\n\t\t *\r\n\t\t * @example\r\n\t\t * scene.on(\"end\", function (event) {\r\n\t\t * \tconsole.log(\"Hit end point of scene.\");\r\n\t\t * });\r\n\t\t *\r\n\t\t * @property {object} event - The event Object passed to each callback\r\n\t\t * @property {string} event.type - The name of the event\r\n\t\t * @property {Scene} event.target - The Scene object that triggered this event\r\n\t\t * @property {number} event.progress - Reflects the current progress of the scene\r\n\t\t * @property {string} event.state - The current state of the scene `\"DURING\"` or `\"AFTER\"`\r\n\t\t * @property {string} event.scrollDirection - Indicates which way we are scrolling `\"PAUSED\"`, `\"FORWARD\"` or `\"REVERSE\"`\r\n\t\t */\r\n\t\t/**\r\n\t\t * Scene enter event.  \r\n\t\t * Fires whenever the scene enters the \"DURING\" state.  \r\n\t\t * Keep in mind that it doesn't matter if the scene plays forward or backward: This event always fires when the scene enters its active scroll timeframe, regardless of the scroll-direction.\r\n\t\t *\r\n\t\t * For details on this event and the order in which it is fired, please review the {@link Scene.progress} method.\r\n\t\t *\r\n\t\t * @event ScrollMagic.Scene#enter\r\n\t\t *\r\n\t\t * @example\r\n\t\t * scene.on(\"enter\", function (event) {\r\n\t\t * \tconsole.log(\"Scene entered.\");\r\n\t\t * });\r\n\t\t *\r\n\t\t * @property {object} event - The event Object passed to each callback\r\n\t\t * @property {string} event.type - The name of the event\r\n\t\t * @property {Scene} event.target - The Scene object that triggered this event\r\n\t\t * @property {number} event.progress - Reflects the current progress of the scene\r\n\t\t * @property {string} event.state - The current state of the scene - always `\"DURING\"`\r\n\t\t * @property {string} event.scrollDirection - Indicates which way we are scrolling `\"PAUSED\"`, `\"FORWARD\"` or `\"REVERSE\"`\r\n\t\t */\r\n\t\t/**\r\n\t\t * Scene leave event.  \r\n\t\t * Fires whenever the scene's state goes from \"DURING\" to either \"BEFORE\" or \"AFTER\".  \r\n\t\t * Keep in mind that it doesn't matter if the scene plays forward or backward: This event always fires when the scene leaves its active scroll timeframe, regardless of the scroll-direction.\r\n\t\t *\r\n\t\t * For details on this event and the order in which it is fired, please review the {@link Scene.progress} method.\r\n\t\t *\r\n\t\t * @event ScrollMagic.Scene#leave\r\n\t\t *\r\n\t\t * @example\r\n\t\t * scene.on(\"leave\", function (event) {\r\n\t\t * \tconsole.log(\"Scene left.\");\r\n\t\t * });\r\n\t\t *\r\n\t\t * @property {object} event - The event Object passed to each callback\r\n\t\t * @property {string} event.type - The name of the event\r\n\t\t * @property {Scene} event.target - The Scene object that triggered this event\r\n\t\t * @property {number} event.progress - Reflects the current progress of the scene\r\n\t\t * @property {string} event.state - The current state of the scene `\"BEFORE\"` or `\"AFTER\"`\r\n\t\t * @property {string} event.scrollDirection - Indicates which way we are scrolling `\"PAUSED\"`, `\"FORWARD\"` or `\"REVERSE\"`\r\n\t\t */\r\n\t\t/**\r\n\t\t * Scene update event.  \r\n\t\t * Fires whenever the scene is updated (but not necessarily changes the progress).\r\n\t\t *\r\n\t\t * @event ScrollMagic.Scene#update\r\n\t\t *\r\n\t\t * @example\r\n\t\t * scene.on(\"update\", function (event) {\r\n\t\t * \tconsole.log(\"Scene updated.\");\r\n\t\t * });\r\n\t\t *\r\n\t\t * @property {object} event - The event Object passed to each callback\r\n\t\t * @property {string} event.type - The name of the event\r\n\t\t * @property {Scene} event.target - The Scene object that triggered this event\r\n\t\t * @property {number} event.startPos - The starting position of the scene (in relation to the conainer)\r\n\t\t * @property {number} event.endPos - The ending position of the scene (in relation to the conainer)\r\n\t\t * @property {number} event.scrollPos - The current scroll position of the container\r\n\t\t */\r\n\t\t/**\r\n\t\t * Scene progress event.  \r\n\t\t * Fires whenever the progress of the scene changes.\r\n\t\t *\r\n\t\t * For details on this event and the order in which it is fired, please review the {@link Scene.progress} method.\r\n\t\t *\r\n\t\t * @event ScrollMagic.Scene#progress\r\n\t\t *\r\n\t\t * @example\r\n\t\t * scene.on(\"progress\", function (event) {\r\n\t\t * \tconsole.log(\"Scene progress changed to \" + event.progress);\r\n\t\t * });\r\n\t\t *\r\n\t\t * @property {object} event - The event Object passed to each callback\r\n\t\t * @property {string} event.type - The name of the event\r\n\t\t * @property {Scene} event.target - The Scene object that triggered this event\r\n\t\t * @property {number} event.progress - Reflects the current progress of the scene\r\n\t\t * @property {string} event.state - The current state of the scene `\"BEFORE\"`, `\"DURING\"` or `\"AFTER\"`\r\n\t\t * @property {string} event.scrollDirection - Indicates which way we are scrolling `\"PAUSED\"`, `\"FORWARD\"` or `\"REVERSE\"`\r\n\t\t */\r\n\t\t/**\r\n\t\t * Scene change event.  \r\n\t\t * Fires whenvever a property of the scene is changed.\r\n\t\t *\r\n\t\t * @event ScrollMagic.Scene#change\r\n\t\t *\r\n\t\t * @example\r\n\t\t * scene.on(\"change\", function (event) {\r\n\t\t * \tconsole.log(\"Scene Property \\\"\" + event.what + \"\\\" changed to \" + event.newval);\r\n\t\t * });\r\n\t\t *\r\n\t\t * @property {object} event - The event Object passed to each callback\r\n\t\t * @property {string} event.type - The name of the event\r\n\t\t * @property {Scene} event.target - The Scene object that triggered this event\r\n\t\t * @property {string} event.what - Indicates what value has been changed\r\n\t\t * @property {mixed} event.newval - The new value of the changed property\r\n\t\t */\r\n\t\t/**\r\n\t\t * Scene shift event.  \r\n\t\t * Fires whenvever the start or end **scroll offset** of the scene change.\r\n\t\t * This happens explicitely, when one of these values change: `offset`, `duration` or `triggerHook`.\r\n\t\t * It will fire implicitly when the `triggerElement` changes, if the new element has a different position (most cases).\r\n\t\t * It will also fire implicitly when the size of the container changes and the triggerHook is anything other than `onLeave`.\r\n\t\t *\r\n\t\t * @event ScrollMagic.Scene#shift\r\n\t\t * @since 1.1.0\r\n\t\t *\r\n\t\t * @example\r\n\t\t * scene.on(\"shift\", function (event) {\r\n\t\t * \tconsole.log(\"Scene moved, because the \" + event.reason + \" has changed.)\");\r\n\t\t * });\r\n\t\t *\r\n\t\t * @property {object} event - The event Object passed to each callback\r\n\t\t * @property {string} event.type - The name of the event\r\n\t\t * @property {Scene} event.target - The Scene object that triggered this event\r\n\t\t * @property {string} event.reason - Indicates why the scene has shifted\r\n\t\t */\r\n\t\t/**\r\n\t\t * Scene destroy event.  \r\n\t\t * Fires whenvever the scene is destroyed.\r\n\t\t * This can be used to tidy up custom behaviour used in events.\r\n\t\t *\r\n\t\t * @event ScrollMagic.Scene#destroy\r\n\t\t * @since 1.1.0\r\n\t\t *\r\n\t\t * @example\r\n\t\t * scene.on(\"enter\", function (event) {\r\n\t\t *        // add custom action\r\n\t\t *        $(\"#my-elem\").left(\"200\");\r\n\t\t *      })\r\n\t\t *      .on(\"destroy\", function (event) {\r\n\t\t *        // reset my element to start position\r\n\t\t *        if (event.reset) {\r\n\t\t *          $(\"#my-elem\").left(\"0\");\r\n\t\t *        }\r\n\t\t *      });\r\n\t\t *\r\n\t\t * @property {object} event - The event Object passed to each callback\r\n\t\t * @property {string} event.type - The name of the event\r\n\t\t * @property {Scene} event.target - The Scene object that triggered this event\r\n\t\t * @property {boolean} event.reset - Indicates if the destroy method was called with reset `true` or `false`.\r\n\t\t */\r\n\t\t/**\r\n\t\t * Scene add event.  \r\n\t\t * Fires when the scene is added to a controller.\r\n\t\t * This is mostly used by plugins to know that change might be due.\r\n\t\t *\r\n\t\t * @event ScrollMagic.Scene#add\r\n\t\t * @since 2.0.0\r\n\t\t *\r\n\t\t * @example\r\n\t\t * scene.on(\"add\", function (event) {\r\n\t\t * \tconsole.log('Scene was added to a new controller.');\r\n\t\t * });\r\n\t\t *\r\n\t\t * @property {object} event - The event Object passed to each callback\r\n\t\t * @property {string} event.type - The name of the event\r\n\t\t * @property {Scene} event.target - The Scene object that triggered this event\r\n\t\t * @property {boolean} event.controller - The controller object the scene was added to.\r\n\t\t */\r\n\t\t/**\r\n\t\t * Scene remove event.  \r\n\t\t * Fires when the scene is removed from a controller.\r\n\t\t * This is mostly used by plugins to know that change might be due.\r\n\t\t *\r\n\t\t * @event ScrollMagic.Scene#remove\r\n\t\t * @since 2.0.0\r\n\t\t *\r\n\t\t * @example\r\n\t\t * scene.on(\"remove\", function (event) {\r\n\t\t * \tconsole.log('Scene was removed from its controller.');\r\n\t\t * });\r\n\t\t *\r\n\t\t * @property {object} event - The event Object passed to each callback\r\n\t\t * @property {string} event.type - The name of the event\r\n\t\t * @property {Scene} event.target - The Scene object that triggered this event\r\n\t\t */\r\n\r\n\t\t/**\r\n\t\t * Add one ore more event listener.  \r\n\t\t * The callback function will be fired at the respective event, and an object containing relevant data will be passed to the callback.\r\n\t\t * @method ScrollMagic.Scene#on\r\n\t\t *\r\n\t\t * @example\r\n\t\t * function callback (event) {\r\n\t\t * \t\tconsole.log(\"Event fired! (\" + event.type + \")\");\r\n\t\t * }\r\n\t\t * // add listeners\r\n\t\t * scene.on(\"change update progress start end enter leave\", callback);\r\n\t\t *\r\n\t\t * @param {string} names - The name or names of the event the callback should be attached to.\r\n\t\t * @param {function} callback - A function that should be executed, when the event is dispatched. An event object will be passed to the callback.\r\n\t\t * @returns {Scene} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.on = function (names, callback) {\r\n\t\t\tif (_util.type.Function(callback)) {\r\n\t\t\t\tnames = names.trim().split(' ');\r\n\t\t\t\tnames.forEach(function (fullname) {\r\n\t\t\t\t\tvar\r\n\t\t\t\t\t\tnameparts = fullname.split('.'),\r\n\t\t\t\t\t\teventname = nameparts[0],\r\n\t\t\t\t\t\tnamespace = nameparts[1];\r\n\t\t\t\t\tif (eventname != \"*\") { // disallow wildcards\r\n\t\t\t\t\t\tif (!_listeners[eventname]) {\r\n\t\t\t\t\t\t\t_listeners[eventname] = [];\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\t_listeners[eventname].push({\r\n\t\t\t\t\t\t\tnamespace: namespace || '',\r\n\t\t\t\t\t\t\tcallback: callback\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t}\r\n\t\t\t\t});\r\n\t\t\t} else {\r\n\t\t\t\tlog(1, \"ERROR when calling '.on()': Supplied callback for '\" + names + \"' is not a valid function!\");\r\n\t\t\t}\r\n\t\t\treturn Scene;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Remove one or more event listener.\r\n\t\t * @method ScrollMagic.Scene#off\r\n\t\t *\r\n\t\t * @example\r\n\t\t * function callback (event) {\r\n\t\t * \t\tconsole.log(\"Event fired! (\" + event.type + \")\");\r\n\t\t * }\r\n\t\t * // add listeners\r\n\t\t * scene.on(\"change update\", callback);\r\n\t\t * // remove listeners\r\n\t\t * scene.off(\"change update\", callback);\r\n\t\t *\r\n\t\t * @param {string} names - The name or names of the event that should be removed.\r\n\t\t * @param {function} [callback] - A specific callback function that should be removed. If none is passed all callbacks to the event listener will be removed.\r\n\t\t * @returns {Scene} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.off = function (names, callback) {\r\n\t\t\tif (!names) {\r\n\t\t\t\tlog(1, \"ERROR: Invalid event name supplied.\");\r\n\t\t\t\treturn Scene;\r\n\t\t\t}\r\n\t\t\tnames = names.trim().split(' ');\r\n\t\t\tnames.forEach(function (fullname, key) {\r\n\t\t\t\tvar\r\n\t\t\t\t\tnameparts = fullname.split('.'),\r\n\t\t\t\t\teventname = nameparts[0],\r\n\t\t\t\t\tnamespace = nameparts[1] || '',\r\n\t\t\t\t\tremoveList = eventname === '*' ? Object.keys(_listeners) : [eventname];\r\n\t\t\t\tremoveList.forEach(function (remove) {\r\n\t\t\t\t\tvar\r\n\t\t\t\t\t\tlist = _listeners[remove] || [],\r\n\t\t\t\t\t\ti = list.length;\r\n\t\t\t\t\twhile (i--) {\r\n\t\t\t\t\t\tvar listener = list[i];\r\n\t\t\t\t\t\tif (listener && (namespace === listener.namespace || namespace === '*') && (!callback || callback == listener.callback)) {\r\n\t\t\t\t\t\t\tlist.splice(i, 1);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (!list.length) {\r\n\t\t\t\t\t\tdelete _listeners[remove];\r\n\t\t\t\t\t}\r\n\t\t\t\t});\r\n\t\t\t});\r\n\t\t\treturn Scene;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Trigger an event.\r\n\t\t * @method ScrollMagic.Scene#trigger\r\n\t\t *\r\n\t\t * @example\r\n\t\t * this.trigger(\"change\");\r\n\t\t *\r\n\t\t * @param {string} name - The name of the event that should be triggered.\r\n\t\t * @param {object} [vars] - An object containing info that should be passed to the callback.\r\n\t\t * @returns {Scene} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.trigger = function (name, vars) {\r\n\t\t\tif (name) {\r\n\t\t\t\tvar\r\n\t\t\t\t\tnameparts = name.trim().split('.'),\r\n\t\t\t\t\teventname = nameparts[0],\r\n\t\t\t\t\tnamespace = nameparts[1],\r\n\t\t\t\t\tlisteners = _listeners[eventname];\r\n\t\t\t\tlog(3, 'event fired:', eventname, vars ? \"->\" : '', vars || '');\r\n\t\t\t\tif (listeners) {\r\n\t\t\t\t\tlisteners.forEach(function (listener, key) {\r\n\t\t\t\t\t\tif (!namespace || namespace === listener.namespace) {\r\n\t\t\t\t\t\t\tlistener.callback.call(Scene, new ScrollMagic.Event(eventname, listener.namespace, Scene, vars));\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tlog(1, \"ERROR: Invalid event name supplied.\");\r\n\t\t\t}\r\n\t\t\treturn Scene;\r\n\t\t};\r\n\r\n\t\t// set event listeners\r\n\t\tScene\r\n\t\t\t.on(\"change.internal\", function (e) {\r\n\t\t\t\tif (e.what !== \"loglevel\" && e.what !== \"tweenChanges\") { // no need for a scene update scene with these options...\r\n\t\t\t\t\tif (e.what === \"triggerElement\") {\r\n\t\t\t\t\t\tupdateTriggerElementPosition();\r\n\t\t\t\t\t} else if (e.what === \"reverse\") { // the only property left that may have an impact on the current scene state. Everything else is handled by the shift event.\r\n\t\t\t\t\t\tScene.update();\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t\t.on(\"shift.internal\", function (e) {\r\n\t\t\t\tupdateScrollOffset();\r\n\t\t\t\tScene.update(); // update scene to reflect new position\r\n\t\t\t});\r\n\r\n\t\t/**\r\n\t\t * Send a debug message to the console.\r\n\t\t * @private\r\n\t\t * but provided publicly with _log for plugins\r\n\t\t *\r\n\t\t * @param {number} loglevel - The loglevel required to initiate output for the message.\r\n\t\t * @param {...mixed} output - One or more variables that should be passed to the console.\r\n\t\t */\r\n\t\tvar log = this._log = function (loglevel, output) {\r\n\t\t\tif (_options.loglevel >= loglevel) {\r\n\t\t\t\tArray.prototype.splice.call(arguments, 1, 0, \"(\" + NAMESPACE + \") ->\");\r\n\t\t\t\t_util.log.apply(window, arguments);\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Add the scene to a controller.  \r\n\t\t * This is the equivalent to `Controller.addScene(scene)`.\r\n\t\t * @method ScrollMagic.Scene#addTo\r\n\t\t *\r\n\t\t * @example\r\n\t\t * // add a scene to a ScrollMagic Controller\r\n\t\t * scene.addTo(controller);\r\n\t\t *\r\n\t\t * @param {ScrollMagic.Controller} controller - The controller to which the scene should be added.\r\n\t\t * @returns {Scene} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.addTo = function (controller) {\r\n\t\t\tif (!(controller instanceof ScrollMagic.Controller)) {\r\n\t\t\t\tlog(1, \"ERROR: supplied argument of 'addTo()' is not a valid ScrollMagic Controller\");\r\n\t\t\t} else if (_controller != controller) {\r\n\t\t\t\t// new controller\r\n\t\t\t\tif (_controller) { // was associated to a different controller before, so remove it...\r\n\t\t\t\t\t_controller.removeScene(Scene);\r\n\t\t\t\t}\r\n\t\t\t\t_controller = controller;\r\n\t\t\t\tvalidateOption();\r\n\t\t\t\tupdateDuration(true);\r\n\t\t\t\tupdateTriggerElementPosition(true);\r\n\t\t\t\tupdateScrollOffset();\r\n\t\t\t\t_controller.info(\"container\").addEventListener('resize', onContainerResize);\r\n\t\t\t\tcontroller.addScene(Scene);\r\n\t\t\t\tScene.trigger(\"add\", {\r\n\t\t\t\t\tcontroller: _controller\r\n\t\t\t\t});\r\n\t\t\t\tlog(3, \"added \" + NAMESPACE + \" to controller\");\r\n\t\t\t\tScene.update();\r\n\t\t\t}\r\n\t\t\treturn Scene;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * **Get** or **Set** the current enabled state of the scene.  \r\n\t\t * This can be used to disable this scene without removing or destroying it.\r\n\t\t * @method ScrollMagic.Scene#enabled\r\n\t\t *\r\n\t\t * @example\r\n\t\t * // get the current value\r\n\t\t * var enabled = scene.enabled();\r\n\t\t *\r\n\t\t * // disable the scene\r\n\t\t * scene.enabled(false);\r\n\t\t *\r\n\t\t * @param {boolean} [newState] - The new enabled state of the scene `true` or `false`.\r\n\t\t * @returns {(boolean|Scene)} Current enabled state or parent object for chaining.\r\n\t\t */\r\n\t\tthis.enabled = function (newState) {\r\n\t\t\tif (!arguments.length) { // get\r\n\t\t\t\treturn _enabled;\r\n\t\t\t} else if (_enabled != newState) { // set\r\n\t\t\t\t_enabled = !!newState;\r\n\t\t\t\tScene.update(true);\r\n\t\t\t}\r\n\t\t\treturn Scene;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Remove the scene from the controller.  \r\n\t\t * This is the equivalent to `Controller.removeScene(scene)`.\r\n\t\t * The scene will not be updated anymore until you readd it to a controller.\r\n\t\t * To remove the pin or the tween you need to call removeTween() or removePin() respectively.\r\n\t\t * @method ScrollMagic.Scene#remove\r\n\t\t * @example\r\n\t\t * // remove the scene from its controller\r\n\t\t * scene.remove();\r\n\t\t *\r\n\t\t * @returns {Scene} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.remove = function () {\r\n\t\t\tif (_controller) {\r\n\t\t\t\t_controller.info(\"container\").removeEventListener('resize', onContainerResize);\r\n\t\t\t\tvar tmpParent = _controller;\r\n\t\t\t\t_controller = undefined;\r\n\t\t\t\ttmpParent.removeScene(Scene);\r\n\t\t\t\tScene.trigger(\"remove\");\r\n\t\t\t\tlog(3, \"removed \" + NAMESPACE + \" from controller\");\r\n\t\t\t}\r\n\t\t\treturn Scene;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Destroy the scene and everything.\r\n\t\t * @method ScrollMagic.Scene#destroy\r\n\t\t * @example\r\n\t\t * // destroy the scene without resetting the pin and tween to their initial positions\r\n\t\t * scene = scene.destroy();\r\n\t\t *\r\n\t\t * // destroy the scene and reset the pin and tween\r\n\t\t * scene = scene.destroy(true);\r\n\t\t *\r\n\t\t * @param {boolean} [reset=false] - If `true` the pin and tween (if existent) will be reset.\r\n\t\t * @returns {null} Null to unset handler variables.\r\n\t\t */\r\n\t\tthis.destroy = function (reset) {\r\n\t\t\tScene.trigger(\"destroy\", {\r\n\t\t\t\treset: reset\r\n\t\t\t});\r\n\t\t\tScene.remove();\r\n\t\t\tScene.off(\"*.*\");\r\n\t\t\tlog(3, \"destroyed \" + NAMESPACE + \" (reset: \" + (reset ? \"true\" : \"false\") + \")\");\r\n\t\t\treturn null;\r\n\t\t};\r\n\r\n\r\n\t\t/**\r\n\t\t * Updates the Scene to reflect the current state.  \r\n\t\t * This is the equivalent to `Controller.updateScene(scene, immediately)`.  \r\n\t\t * The update method calculates the scene's start and end position (based on the trigger element, trigger hook, duration and offset) and checks it against the current scroll position of the container.  \r\n\t\t * It then updates the current scene state accordingly (or does nothing, if the state is already correct) – Pins will be set to their correct position and tweens will be updated to their correct progress.\r\n\t\t * This means an update doesn't necessarily result in a progress change. The `progress` event will be fired if the progress has indeed changed between this update and the last.  \r\n\t\t * _**NOTE:** This method gets called constantly whenever ScrollMagic detects a change. The only application for you is if you change something outside of the realm of ScrollMagic, like moving the trigger or changing tween parameters._\r\n\t\t * @method ScrollMagic.Scene#update\r\n\t\t * @example\r\n\t\t * // update the scene on next tick\r\n\t\t * scene.update();\r\n\t\t *\r\n\t\t * // update the scene immediately\r\n\t\t * scene.update(true);\r\n\t\t *\r\n\t\t * @fires Scene.update\r\n\t\t *\r\n\t\t * @param {boolean} [immediately=false] - If `true` the update will be instant, if `false` it will wait until next update cycle (better performance).\r\n\t\t * @returns {Scene} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.update = function (immediately) {\r\n\t\t\tif (_controller) {\r\n\t\t\t\tif (immediately) {\r\n\t\t\t\t\tif (_controller.enabled() && _enabled) {\r\n\t\t\t\t\t\tvar\r\n\t\t\t\t\t\t\tscrollPos = _controller.info(\"scrollPos\"),\r\n\t\t\t\t\t\t\tnewProgress;\r\n\r\n\t\t\t\t\t\tif (_options.duration > 0) {\r\n\t\t\t\t\t\t\tnewProgress = (scrollPos - _scrollOffset.start) / (_scrollOffset.end - _scrollOffset.start);\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tnewProgress = scrollPos >= _scrollOffset.start ? 1 : 0;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tScene.trigger(\"update\", {\r\n\t\t\t\t\t\t\tstartPos: _scrollOffset.start,\r\n\t\t\t\t\t\t\tendPos: _scrollOffset.end,\r\n\t\t\t\t\t\t\tscrollPos: scrollPos\r\n\t\t\t\t\t\t});\r\n\r\n\t\t\t\t\t\tScene.progress(newProgress);\r\n\t\t\t\t\t} else if (_pin && _state === SCENE_STATE_DURING) {\r\n\t\t\t\t\t\tupdatePinState(true); // unpin in position\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\t_controller.updateScene(Scene, false);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn Scene;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Updates dynamic scene variables like the trigger element position or the duration.\r\n\t\t * This method is automatically called in regular intervals from the controller. See {@link ScrollMagic.Controller} option `refreshInterval`.\r\n\t\t * \r\n\t\t * You can call it to minimize lag, for example when you intentionally change the position of the triggerElement.\r\n\t\t * If you don't it will simply be updated in the next refresh interval of the container, which is usually sufficient.\r\n\t\t *\r\n\t\t * @method ScrollMagic.Scene#refresh\r\n\t\t * @since 1.1.0\r\n\t\t * @example\r\n\t\t * scene = new ScrollMagic.Scene({triggerElement: \"#trigger\"});\r\n\t\t * \r\n\t\t * // change the position of the trigger\r\n\t\t * $(\"#trigger\").css(\"top\", 500);\r\n\t\t * // immediately let the scene know of this change\r\n\t\t * scene.refresh();\r\n\t\t *\r\n\t\t * @fires {@link Scene.shift}, if the trigger element position or the duration changed\r\n\t\t * @fires {@link Scene.change}, if the duration changed\r\n\t\t *\r\n\t\t * @returns {Scene} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.refresh = function () {\r\n\t\t\tupdateDuration();\r\n\t\t\tupdateTriggerElementPosition();\r\n\t\t\t// update trigger element position\r\n\t\t\treturn Scene;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * **Get** or **Set** the scene's progress.  \r\n\t\t * Usually it shouldn't be necessary to use this as a setter, as it is set automatically by scene.update().  \r\n\t\t * The order in which the events are fired depends on the duration of the scene:\r\n\t\t *  1. Scenes with `duration == 0`:  \r\n\t\t *  Scenes that have no duration by definition have no ending. Thus the `end` event will never be fired.  \r\n\t\t *  When the trigger position of the scene is passed the events are always fired in this order:  \r\n\t\t *  `enter`, `start`, `progress` when scrolling forward  \r\n\t\t *  and  \r\n\t\t *  `progress`, `start`, `leave` when scrolling in reverse\r\n\t\t *  2. Scenes with `duration > 0`:  \r\n\t\t *  Scenes with a set duration have a defined start and end point.  \r\n\t\t *  When scrolling past the start position of the scene it will fire these events in this order:  \r\n\t\t *  `enter`, `start`, `progress`  \r\n\t\t *  When continuing to scroll and passing the end point it will fire these events:  \r\n\t\t *  `progress`, `end`, `leave`  \r\n\t\t *  When reversing through the end point these events are fired:  \r\n\t\t *  `enter`, `end`, `progress`  \r\n\t\t *  And when continuing to scroll past the start position in reverse it will fire:  \r\n\t\t *  `progress`, `start`, `leave`  \r\n\t\t *  In between start and end the `progress` event will be called constantly, whenever the progress changes.\r\n\t\t * \r\n\t\t * In short:  \r\n\t\t * `enter` events will always trigger **before** the progress update and `leave` envents will trigger **after** the progress update.  \r\n\t\t * `start` and `end` will always trigger at their respective position.\r\n\t\t * \r\n\t\t * Please review the event descriptions for details on the events and the event object that is passed to the callback.\r\n\t\t * \r\n\t\t * @method ScrollMagic.Scene#progress\r\n\t\t * @example\r\n\t\t * // get the current scene progress\r\n\t\t * var progress = scene.progress();\r\n\t\t *\r\n\t\t * // set new scene progress\r\n\t\t * scene.progress(0.3);\r\n\t\t *\r\n\t\t * @fires {@link Scene.enter}, when used as setter\r\n\t\t * @fires {@link Scene.start}, when used as setter\r\n\t\t * @fires {@link Scene.progress}, when used as setter\r\n\t\t * @fires {@link Scene.end}, when used as setter\r\n\t\t * @fires {@link Scene.leave}, when used as setter\r\n\t\t *\r\n\t\t * @param {number} [progress] - The new progress value of the scene `[0-1]`.\r\n\t\t * @returns {number} `get` -  Current scene progress.\r\n\t\t * @returns {Scene} `set` -  Parent object for chaining.\r\n\t\t */\r\n\t\tthis.progress = function (progress) {\r\n\t\t\tif (!arguments.length) { // get\r\n\t\t\t\treturn _progress;\r\n\t\t\t} else { // set\r\n\t\t\t\tvar\r\n\t\t\t\t\tdoUpdate = false,\r\n\t\t\t\t\toldState = _state,\r\n\t\t\t\t\tscrollDirection = _controller ? _controller.info(\"scrollDirection\") : 'PAUSED',\r\n\t\t\t\t\treverseOrForward = _options.reverse || progress >= _progress;\r\n\t\t\t\tif (_options.duration === 0) {\r\n\t\t\t\t\t// zero duration scenes\r\n\t\t\t\t\tdoUpdate = _progress != progress;\r\n\t\t\t\t\t_progress = progress < 1 && reverseOrForward ? 0 : 1;\r\n\t\t\t\t\t_state = _progress === 0 ? SCENE_STATE_BEFORE : SCENE_STATE_DURING;\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// scenes with start and end\r\n\t\t\t\t\tif (progress < 0 && _state !== SCENE_STATE_BEFORE && reverseOrForward) {\r\n\t\t\t\t\t\t// go back to initial state\r\n\t\t\t\t\t\t_progress = 0;\r\n\t\t\t\t\t\t_state = SCENE_STATE_BEFORE;\r\n\t\t\t\t\t\tdoUpdate = true;\r\n\t\t\t\t\t} else if (progress >= 0 && progress < 1 && reverseOrForward) {\r\n\t\t\t\t\t\t_progress = progress;\r\n\t\t\t\t\t\t_state = SCENE_STATE_DURING;\r\n\t\t\t\t\t\tdoUpdate = true;\r\n\t\t\t\t\t} else if (progress >= 1 && _state !== SCENE_STATE_AFTER) {\r\n\t\t\t\t\t\t_progress = 1;\r\n\t\t\t\t\t\t_state = SCENE_STATE_AFTER;\r\n\t\t\t\t\t\tdoUpdate = true;\r\n\t\t\t\t\t} else if (_state === SCENE_STATE_DURING && !reverseOrForward) {\r\n\t\t\t\t\t\tupdatePinState(); // in case we scrolled backwards mid-scene and reverse is disabled => update the pin position, so it doesn't move back as well.\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tif (doUpdate) {\r\n\t\t\t\t\t// fire events\r\n\t\t\t\t\tvar\r\n\t\t\t\t\t\teventVars = {\r\n\t\t\t\t\t\t\tprogress: _progress,\r\n\t\t\t\t\t\t\tstate: _state,\r\n\t\t\t\t\t\t\tscrollDirection: scrollDirection\r\n\t\t\t\t\t\t},\r\n\t\t\t\t\t\tstateChanged = _state != oldState;\r\n\r\n\t\t\t\t\tvar trigger = function (eventName) { // tmp helper to simplify code\r\n\t\t\t\t\t\tScene.trigger(eventName, eventVars);\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\tif (stateChanged) { // enter events\r\n\t\t\t\t\t\tif (oldState !== SCENE_STATE_DURING) {\r\n\t\t\t\t\t\t\ttrigger(\"enter\");\r\n\t\t\t\t\t\t\ttrigger(oldState === SCENE_STATE_BEFORE ? \"start\" : \"end\");\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\ttrigger(\"progress\");\r\n\t\t\t\t\tif (stateChanged) { // leave events\r\n\t\t\t\t\t\tif (_state !== SCENE_STATE_DURING) {\r\n\t\t\t\t\t\t\ttrigger(_state === SCENE_STATE_BEFORE ? \"start\" : \"end\");\r\n\t\t\t\t\t\t\ttrigger(\"leave\");\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\treturn Scene;\r\n\t\t\t}\r\n\t\t};\r\n\r\n\r\n\t\t/**\r\n\t\t * Update the start and end scrollOffset of the container.\r\n\t\t * The positions reflect what the controller's scroll position will be at the start and end respectively.\r\n\t\t * Is called, when:\r\n\t\t *   - Scene event \"change\" is called with: offset, triggerHook, duration \r\n\t\t *   - scroll container event \"resize\" is called\r\n\t\t *   - the position of the triggerElement changes\r\n\t\t *   - the controller changes -> addTo()\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar updateScrollOffset = function () {\r\n\t\t\t_scrollOffset = {\r\n\t\t\t\tstart: _triggerPos + _options.offset\r\n\t\t\t};\r\n\t\t\tif (_controller && _options.triggerElement) {\r\n\t\t\t\t// take away triggerHook portion to get relative to top\r\n\t\t\t\t_scrollOffset.start -= _controller.info(\"size\") * _options.triggerHook;\r\n\t\t\t}\r\n\t\t\t_scrollOffset.end = _scrollOffset.start + _options.duration;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Updates the duration if set to a dynamic function.\r\n\t\t * This method is called when the scene is added to a controller and in regular intervals from the controller through scene.refresh().\r\n\t\t * \r\n\t\t * @fires {@link Scene.change}, if the duration changed\r\n\t\t * @fires {@link Scene.shift}, if the duration changed\r\n\t\t *\r\n\t\t * @param {boolean} [suppressEvents=false] - If true the shift event will be suppressed.\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar updateDuration = function (suppressEvents) {\r\n\t\t\t// update duration\r\n\t\t\tif (_durationUpdateMethod) {\r\n\t\t\t\tvar varname = \"duration\";\r\n\t\t\t\tif (changeOption(varname, _durationUpdateMethod.call(Scene)) && !suppressEvents) { // set\r\n\t\t\t\t\tScene.trigger(\"change\", {\r\n\t\t\t\t\t\twhat: varname,\r\n\t\t\t\t\t\tnewval: _options[varname]\r\n\t\t\t\t\t});\r\n\t\t\t\t\tScene.trigger(\"shift\", {\r\n\t\t\t\t\t\treason: varname\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Updates the position of the triggerElement, if present.\r\n\t\t * This method is called ...\r\n\t\t *  - ... when the triggerElement is changed\r\n\t\t *  - ... when the scene is added to a (new) controller\r\n\t\t *  - ... in regular intervals from the controller through scene.refresh().\r\n\t\t * \r\n\t\t * @fires {@link Scene.shift}, if the position changed\r\n\t\t *\r\n\t\t * @param {boolean} [suppressEvents=false] - If true the shift event will be suppressed.\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar updateTriggerElementPosition = function (suppressEvents) {\r\n\t\t\tvar\r\n\t\t\t\telementPos = 0,\r\n\t\t\t\ttelem = _options.triggerElement;\r\n\t\t\tif (_controller && (telem || _triggerPos > 0)) { // either an element exists or was removed and the triggerPos is still > 0\r\n\t\t\t\tif (telem) { // there currently a triggerElement set\r\n\t\t\t\t\tif (telem.parentNode) { // check if element is still attached to DOM\r\n\t\t\t\t\t\tvar\r\n\t\t\t\t\t\t\tcontrollerInfo = _controller.info(),\r\n\t\t\t\t\t\t\tcontainerOffset = _util.get.offset(controllerInfo.container), // container position is needed because element offset is returned in relation to document, not in relation to container.\r\n\t\t\t\t\t\t\tparam = controllerInfo.vertical ? \"top\" : \"left\"; // which param is of interest ?\r\n\r\n\t\t\t\t\t\t// if parent is spacer, use spacer position instead so correct start position is returned for pinned elements.\r\n\t\t\t\t\t\twhile (telem.parentNode.hasAttribute(PIN_SPACER_ATTRIBUTE)) {\r\n\t\t\t\t\t\t\ttelem = telem.parentNode;\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tvar elementOffset = _util.get.offset(telem);\r\n\r\n\t\t\t\t\t\tif (!controllerInfo.isDocument) { // container is not the document root, so substract scroll Position to get correct trigger element position relative to scrollcontent\r\n\t\t\t\t\t\t\tcontainerOffset[param] -= _controller.scrollPos();\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\telementPos = elementOffset[param] - containerOffset[param];\r\n\r\n\t\t\t\t\t} else { // there was an element, but it was removed from DOM\r\n\t\t\t\t\t\tlog(2, \"WARNING: triggerElement was removed from DOM and will be reset to\", undefined);\r\n\t\t\t\t\t\tScene.triggerElement(undefined); // unset, so a change event is triggered\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\tvar changed = elementPos != _triggerPos;\r\n\t\t\t\t_triggerPos = elementPos;\r\n\t\t\t\tif (changed && !suppressEvents) {\r\n\t\t\t\t\tScene.trigger(\"shift\", {\r\n\t\t\t\t\t\treason: \"triggerElementPosition\"\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Trigger a shift event, when the container is resized and the triggerHook is > 1.\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar onContainerResize = function (e) {\r\n\t\t\tif (_options.triggerHook > 0) {\r\n\t\t\t\tScene.trigger(\"shift\", {\r\n\t\t\t\t\treason: \"containerResize\"\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t};\r\n\r\n\r\n\t\tvar _validate = _util.extend(SCENE_OPTIONS.validate, {\r\n\t\t\t// validation for duration handled internally for reference to private var _durationMethod\r\n\t\t\tduration: function (val) {\r\n\t\t\t\tif (_util.type.String(val) && val.match(/^(\\.|\\d)*\\d+%$/)) {\r\n\t\t\t\t\t// percentage value\r\n\t\t\t\t\tvar perc = parseFloat(val) / 100;\r\n\t\t\t\t\tval = function () {\r\n\t\t\t\t\t\treturn _controller ? _controller.info(\"size\") * perc : 0;\r\n\t\t\t\t\t};\r\n\t\t\t\t}\r\n\t\t\t\tif (_util.type.Function(val)) {\r\n\t\t\t\t\t// function\r\n\t\t\t\t\t_durationUpdateMethod = val;\r\n\t\t\t\t\ttry {\r\n\t\t\t\t\t\tval = parseFloat(_durationUpdateMethod.call(Scene));\r\n\t\t\t\t\t} catch (e) {\r\n\t\t\t\t\t\tval = -1; // will cause error below\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\t// val has to be float\r\n\t\t\t\tval = parseFloat(val);\r\n\t\t\t\tif (!_util.type.Number(val) || val < 0) {\r\n\t\t\t\t\tif (_durationUpdateMethod) {\r\n\t\t\t\t\t\t_durationUpdateMethod = undefined;\r\n\t\t\t\t\t\tthrow [\"Invalid return value of supplied function for option \\\"duration\\\":\", val];\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tthrow [\"Invalid value for option \\\"duration\\\":\", val];\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\treturn val;\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\t/**\r\n\t\t * Checks the validity of a specific or all options and reset to default if neccessary.\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar validateOption = function (check) {\r\n\t\t\tcheck = arguments.length ? [check] : Object.keys(_validate);\r\n\t\t\tcheck.forEach(function (optionName, key) {\r\n\t\t\t\tvar value;\r\n\t\t\t\tif (_validate[optionName]) { // there is a validation method for this option\r\n\t\t\t\t\ttry { // validate value\r\n\t\t\t\t\t\tvalue = _validate[optionName](_options[optionName]);\r\n\t\t\t\t\t} catch (e) { // validation failed -> reset to default\r\n\t\t\t\t\t\tvalue = DEFAULT_OPTIONS[optionName];\r\n\t\t\t\t\t\tvar logMSG = _util.type.String(e) ? [e] : e;\r\n\t\t\t\t\t\tif (_util.type.Array(logMSG)) {\r\n\t\t\t\t\t\t\tlogMSG[0] = \"ERROR: \" + logMSG[0];\r\n\t\t\t\t\t\t\tlogMSG.unshift(1); // loglevel 1 for error msg\r\n\t\t\t\t\t\t\tlog.apply(this, logMSG);\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tlog(1, \"ERROR: Problem executing validation callback for option '\" + optionName + \"':\", e.message);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} finally {\r\n\t\t\t\t\t\t_options[optionName] = value;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Helper used by the setter/getters for scene options\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar changeOption = function (varname, newval) {\r\n\t\t\tvar\r\n\t\t\t\tchanged = false,\r\n\t\t\t\toldval = _options[varname];\r\n\t\t\tif (_options[varname] != newval) {\r\n\t\t\t\t_options[varname] = newval;\r\n\t\t\t\tvalidateOption(varname); // resets to default if necessary\r\n\t\t\t\tchanged = oldval != _options[varname];\r\n\t\t\t}\r\n\t\t\treturn changed;\r\n\t\t};\r\n\r\n\t\t// generate getters/setters for all options\r\n\t\tvar addSceneOption = function (optionName) {\r\n\t\t\tif (!Scene[optionName]) {\r\n\t\t\t\tScene[optionName] = function (newVal) {\r\n\t\t\t\t\tif (!arguments.length) { // get\r\n\t\t\t\t\t\treturn _options[optionName];\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tif (optionName === \"duration\") { // new duration is set, so any previously set function must be unset\r\n\t\t\t\t\t\t\t_durationUpdateMethod = undefined;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tif (changeOption(optionName, newVal)) { // set\r\n\t\t\t\t\t\t\tScene.trigger(\"change\", {\r\n\t\t\t\t\t\t\t\twhat: optionName,\r\n\t\t\t\t\t\t\t\tnewval: _options[optionName]\r\n\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t\tif (SCENE_OPTIONS.shifts.indexOf(optionName) > -1) {\r\n\t\t\t\t\t\t\t\tScene.trigger(\"shift\", {\r\n\t\t\t\t\t\t\t\t\treason: optionName\r\n\t\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\treturn Scene;\r\n\t\t\t\t};\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * **Get** or **Set** the duration option value.\r\n\t\t *\r\n\t\t * As a **setter** it accepts three types of parameters:\r\n\t\t * 1. `number`: Sets the duration of the scene to exactly this amount of pixels.  \r\n\t\t *   This means the scene will last for exactly this amount of pixels scrolled. Sub-Pixels are also valid.\r\n\t\t *   A value of `0` means that the scene is 'open end' and no end will be triggered. Pins will never unpin and animations will play independently of scroll progress.\r\n\t\t * 2. `string`: Always updates the duration relative to parent scroll container.  \r\n\t\t *   For example `\"100%\"` will keep the duration always exactly at the inner height of the scroll container.\r\n\t\t *   When scrolling vertically the width is used for reference respectively.\r\n\t\t * 3. `function`: The supplied function will be called to return the scene duration.\r\n\t\t *   This is useful in setups where the duration depends on other elements who might change size. By supplying a function you can return a value instead of updating potentially multiple scene durations.  \r\n\t\t *   The scene can be referenced inside the callback using `this`.\r\n\t\t *   _**WARNING:** This is an easy way to kill performance, as the callback will be executed every time `Scene.refresh()` is called, which happens a lot. The interval is defined by the controller (see ScrollMagic.Controller option `refreshInterval`).  \r\n\t\t *   It's recomended to avoid calculations within the function and use cached variables as return values.  \r\n\t\t *   This counts double if you use the same function for multiple scenes._\r\n\t\t *\r\n\t\t * @method ScrollMagic.Scene#duration\r\n\t\t * @example\r\n\t\t * // get the current duration value\r\n\t\t * var duration = scene.duration();\r\n\t\t *\r\n\t\t * // set a new duration\r\n\t\t * scene.duration(300);\r\n\t\t *\r\n\t\t * // set duration responsively to container size\r\n\t\t * scene.duration(\"100%\");\r\n\t\t *\r\n\t\t * // use a function to randomize the duration for some reason.\r\n\t\t * var durationValueCache;\r\n\t\t * function durationCallback () {\r\n\t\t *   return durationValueCache;\r\n\t\t * }\r\n\t\t * function updateDuration () {\r\n\t\t *   durationValueCache = Math.random() * 100;\r\n\t\t * }\r\n\t\t * updateDuration(); // set to initial value\r\n\t\t * scene.duration(durationCallback); // set duration callback\r\n\t\t *\r\n\t\t * @fires {@link Scene.change}, when used as setter\r\n\t\t * @fires {@link Scene.shift}, when used as setter\r\n\t\t * @param {(number|string|function)} [newDuration] - The new duration setting for the scene.\r\n\t\t * @returns {number} `get` -  Current scene duration.\r\n\t\t * @returns {Scene} `set` -  Parent object for chaining.\r\n\t\t */\r\n\r\n\t\t/**\r\n\t\t * **Get** or **Set** the offset option value.\r\n\t\t * @method ScrollMagic.Scene#offset\r\n\t\t * @example\r\n\t\t * // get the current offset\r\n\t\t * var offset = scene.offset();\r\n\t\t *\r\n\t\t * // set a new offset\r\n\t\t * scene.offset(100);\r\n\t\t *\r\n\t\t * @fires {@link Scene.change}, when used as setter\r\n\t\t * @fires {@link Scene.shift}, when used as setter\r\n\t\t * @param {number} [newOffset] - The new offset of the scene.\r\n\t\t * @returns {number} `get` -  Current scene offset.\r\n\t\t * @returns {Scene} `set` -  Parent object for chaining.\r\n\t\t */\r\n\r\n\t\t/**\r\n\t\t * **Get** or **Set** the triggerElement option value.\r\n\t\t * Does **not** fire `Scene.shift`, because changing the trigger Element doesn't necessarily mean the start position changes. This will be determined in `Scene.refresh()`, which is automatically triggered.\r\n\t\t * @method ScrollMagic.Scene#triggerElement\r\n\t\t * @example\r\n\t\t * // get the current triggerElement\r\n\t\t * var triggerElement = scene.triggerElement();\r\n\t\t *\r\n\t\t * // set a new triggerElement using a selector\r\n\t\t * scene.triggerElement(\"#trigger\");\r\n\t\t * // set a new triggerElement using a DOM object\r\n\t\t * scene.triggerElement(document.getElementById(\"trigger\"));\r\n\t\t *\r\n\t\t * @fires {@link Scene.change}, when used as setter\r\n\t\t * @param {(string|object)} [newTriggerElement] - The new trigger element for the scene.\r\n\t\t * @returns {(string|object)} `get` -  Current triggerElement.\r\n\t\t * @returns {Scene} `set` -  Parent object for chaining.\r\n\t\t */\r\n\r\n\t\t/**\r\n\t\t * **Get** or **Set** the triggerHook option value.\r\n\t\t * @method ScrollMagic.Scene#triggerHook\r\n\t\t * @example\r\n\t\t * // get the current triggerHook value\r\n\t\t * var triggerHook = scene.triggerHook();\r\n\t\t *\r\n\t\t * // set a new triggerHook using a string\r\n\t\t * scene.triggerHook(\"onLeave\");\r\n\t\t * // set a new triggerHook using a number\r\n\t\t * scene.triggerHook(0.7);\r\n\t\t *\r\n\t\t * @fires {@link Scene.change}, when used as setter\r\n\t\t * @fires {@link Scene.shift}, when used as setter\r\n\t\t * @param {(number|string)} [newTriggerHook] - The new triggerHook of the scene. See {@link Scene} parameter description for value options.\r\n\t\t * @returns {number} `get` -  Current triggerHook (ALWAYS numerical).\r\n\t\t * @returns {Scene} `set` -  Parent object for chaining.\r\n\t\t */\r\n\r\n\t\t/**\r\n\t\t * **Get** or **Set** the reverse option value.\r\n\t\t * @method ScrollMagic.Scene#reverse\r\n\t\t * @example\r\n\t\t * // get the current reverse option\r\n\t\t * var reverse = scene.reverse();\r\n\t\t *\r\n\t\t * // set new reverse option\r\n\t\t * scene.reverse(false);\r\n\t\t *\r\n\t\t * @fires {@link Scene.change}, when used as setter\r\n\t\t * @param {boolean} [newReverse] - The new reverse setting of the scene.\r\n\t\t * @returns {boolean} `get` -  Current reverse option value.\r\n\t\t * @returns {Scene} `set` -  Parent object for chaining.\r\n\t\t */\r\n\r\n\t\t/**\r\n\t\t * **Get** or **Set** the loglevel option value.\r\n\t\t * @method ScrollMagic.Scene#loglevel\r\n\t\t * @example\r\n\t\t * // get the current loglevel\r\n\t\t * var loglevel = scene.loglevel();\r\n\t\t *\r\n\t\t * // set new loglevel\r\n\t\t * scene.loglevel(3);\r\n\t\t *\r\n\t\t * @fires {@link Scene.change}, when used as setter\r\n\t\t * @param {number} [newLoglevel] - The new loglevel setting of the scene. `[0-3]`\r\n\t\t * @returns {number} `get` -  Current loglevel.\r\n\t\t * @returns {Scene} `set` -  Parent object for chaining.\r\n\t\t */\r\n\r\n\t\t/**\r\n\t\t * **Get** the associated controller.\r\n\t\t * @method ScrollMagic.Scene#controller\r\n\t\t * @example\r\n\t\t * // get the controller of a scene\r\n\t\t * var controller = scene.controller();\r\n\t\t *\r\n\t\t * @returns {ScrollMagic.Controller} Parent controller or `undefined`\r\n\t\t */\r\n\t\tthis.controller = function () {\r\n\t\t\treturn _controller;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * **Get** the current state.\r\n\t\t * @method ScrollMagic.Scene#state\r\n\t\t * @example\r\n\t\t * // get the current state\r\n\t\t * var state = scene.state();\r\n\t\t *\r\n\t\t * @returns {string} `\"BEFORE\"`, `\"DURING\"` or `\"AFTER\"`\r\n\t\t */\r\n\t\tthis.state = function () {\r\n\t\t\treturn _state;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * **Get** the current scroll offset for the start of the scene.  \r\n\t\t * Mind, that the scrollOffset is related to the size of the container, if `triggerHook` is bigger than `0` (or `\"onLeave\"`).  \r\n\t\t * This means, that resizing the container or changing the `triggerHook` will influence the scene's start offset.\r\n\t\t * @method ScrollMagic.Scene#scrollOffset\r\n\t\t * @example\r\n\t\t * // get the current scroll offset for the start and end of the scene.\r\n\t\t * var start = scene.scrollOffset();\r\n\t\t * var end = scene.scrollOffset() + scene.duration();\r\n\t\t * console.log(\"the scene starts at\", start, \"and ends at\", end);\r\n\t\t *\r\n\t\t * @returns {number} The scroll offset (of the container) at which the scene will trigger. Y value for vertical and X value for horizontal scrolls.\r\n\t\t */\r\n\t\tthis.scrollOffset = function () {\r\n\t\t\treturn _scrollOffset.start;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * **Get** the trigger position of the scene (including the value of the `offset` option).  \r\n\t\t * @method ScrollMagic.Scene#triggerPosition\r\n\t\t * @example\r\n\t\t * // get the scene's trigger position\r\n\t\t * var triggerPosition = scene.triggerPosition();\r\n\t\t *\r\n\t\t * @returns {number} Start position of the scene. Top position value for vertical and left position value for horizontal scrolls.\r\n\t\t */\r\n\t\tthis.triggerPosition = function () {\r\n\t\t\tvar pos = _options.offset; // the offset is the basis\r\n\t\t\tif (_controller) {\r\n\t\t\t\t// get the trigger position\r\n\t\t\t\tif (_options.triggerElement) {\r\n\t\t\t\t\t// Element as trigger\r\n\t\t\t\t\tpos += _triggerPos;\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// return the height of the triggerHook to start at the beginning\r\n\t\t\t\t\tpos += _controller.info(\"size\") * Scene.triggerHook();\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn pos;\r\n\t\t};\r\n\r\n\r\n\t\tvar\r\n\t\t\t_pin,\r\n\t\t\t_pinOptions;\r\n\r\n\t\tScene\r\n\t\t\t.on(\"shift.internal\", function (e) {\r\n\t\t\t\tvar durationChanged = e.reason === \"duration\";\r\n\t\t\t\tif ((_state === SCENE_STATE_AFTER && durationChanged) || (_state === SCENE_STATE_DURING && _options.duration === 0)) {\r\n\t\t\t\t\t// if [duration changed after a scene (inside scene progress updates pin position)] or [duration is 0, we are in pin phase and some other value changed].\r\n\t\t\t\t\tupdatePinState();\r\n\t\t\t\t}\r\n\t\t\t\tif (durationChanged) {\r\n\t\t\t\t\tupdatePinDimensions();\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t\t.on(\"progress.internal\", function (e) {\r\n\t\t\t\tupdatePinState();\r\n\t\t\t})\r\n\t\t\t.on(\"add.internal\", function (e) {\r\n\t\t\t\tupdatePinDimensions();\r\n\t\t\t})\r\n\t\t\t.on(\"destroy.internal\", function (e) {\r\n\t\t\t\tScene.removePin(e.reset);\r\n\t\t\t});\r\n\t\t/**\r\n\t\t * Update the pin state.\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar updatePinState = function (forceUnpin) {\r\n\t\t\tif (_pin && _controller) {\r\n\t\t\t\tvar\r\n\t\t\t\t\tcontainerInfo = _controller.info(),\r\n\t\t\t\t\tpinTarget = _pinOptions.spacer.firstChild; // may be pin element or another spacer, if cascading pins\r\n\r\n\t\t\t\tif (!forceUnpin && _state === SCENE_STATE_DURING) { // during scene or if duration is 0 and we are past the trigger\r\n\t\t\t\t\t// pinned state\r\n\t\t\t\t\tif (_util.css(pinTarget, \"position\") != \"fixed\") {\r\n\t\t\t\t\t\t// change state before updating pin spacer (position changes due to fixed collapsing might occur.)\r\n\t\t\t\t\t\t_util.css(pinTarget, {\r\n\t\t\t\t\t\t\t\"position\": \"fixed\"\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t\t// update pin spacer\r\n\t\t\t\t\t\tupdatePinDimensions();\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tvar\r\n\t\t\t\t\t\tfixedPos = _util.get.offset(_pinOptions.spacer, true), // get viewport position of spacer\r\n\t\t\t\t\t\tscrollDistance = _options.reverse || _options.duration === 0 ?\r\n\t\t\t\t\t\tcontainerInfo.scrollPos - _scrollOffset.start // quicker\r\n\t\t\t\t\t\t:\r\n\t\t\t\t\t\tMath.round(_progress * _options.duration * 10) / 10; // if no reverse and during pin the position needs to be recalculated using the progress\r\n\r\n\t\t\t\t\t// add scrollDistance\r\n\t\t\t\t\tfixedPos[containerInfo.vertical ? \"top\" : \"left\"] += scrollDistance;\r\n\r\n\t\t\t\t\t// set new values\r\n\t\t\t\t\t_util.css(_pinOptions.spacer.firstChild, {\r\n\t\t\t\t\t\ttop: fixedPos.top,\r\n\t\t\t\t\t\tleft: fixedPos.left\r\n\t\t\t\t\t});\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// unpinned state\r\n\t\t\t\t\tvar\r\n\t\t\t\t\t\tnewCSS = {\r\n\t\t\t\t\t\t\tposition: _pinOptions.inFlow ? \"relative\" : \"absolute\",\r\n\t\t\t\t\t\t\ttop: 0,\r\n\t\t\t\t\t\t\tleft: 0\r\n\t\t\t\t\t\t},\r\n\t\t\t\t\t\tchange = _util.css(pinTarget, \"position\") != newCSS.position;\r\n\r\n\t\t\t\t\tif (!_pinOptions.pushFollowers) {\r\n\t\t\t\t\t\tnewCSS[containerInfo.vertical ? \"top\" : \"left\"] = _options.duration * _progress;\r\n\t\t\t\t\t} else if (_options.duration > 0) { // only concerns scenes with duration\r\n\t\t\t\t\t\tif (_state === SCENE_STATE_AFTER && parseFloat(_util.css(_pinOptions.spacer, \"padding-top\")) === 0) {\r\n\t\t\t\t\t\t\tchange = true; // if in after state but havent updated spacer yet (jumped past pin)\r\n\t\t\t\t\t\t} else if (_state === SCENE_STATE_BEFORE && parseFloat(_util.css(_pinOptions.spacer, \"padding-bottom\")) === 0) { // before\r\n\t\t\t\t\t\t\tchange = true; // jumped past fixed state upward direction\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\t// set new values\r\n\t\t\t\t\t_util.css(pinTarget, newCSS);\r\n\t\t\t\t\tif (change) {\r\n\t\t\t\t\t\t// update pin spacer if state changed\r\n\t\t\t\t\t\tupdatePinDimensions();\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Update the pin spacer and/or element size.\r\n\t\t * The size of the spacer needs to be updated whenever the duration of the scene changes, if it is to push down following elements.\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar updatePinDimensions = function () {\r\n\t\t\tif (_pin && _controller && _pinOptions.inFlow) { // no spacerresize, if original position is absolute\r\n\t\t\t\tvar\r\n\t\t\t\t\tafter = (_state === SCENE_STATE_AFTER),\r\n\t\t\t\t\tbefore = (_state === SCENE_STATE_BEFORE),\r\n\t\t\t\t\tduring = (_state === SCENE_STATE_DURING),\r\n\t\t\t\t\tvertical = _controller.info(\"vertical\"),\r\n\t\t\t\t\tpinTarget = _pinOptions.spacer.firstChild, // usually the pined element but can also be another spacer (cascaded pins)\r\n\t\t\t\t\tmarginCollapse = _util.isMarginCollapseType(_util.css(_pinOptions.spacer, \"display\")),\r\n\t\t\t\t\tcss = {};\r\n\r\n\t\t\t\t// set new size\r\n\t\t\t\t// if relsize: spacer -> pin | else: pin -> spacer\r\n\t\t\t\tif (_pinOptions.relSize.width || _pinOptions.relSize.autoFullWidth) {\r\n\t\t\t\t\tif (during) {\r\n\t\t\t\t\t\t_util.css(_pin, {\r\n\t\t\t\t\t\t\t\"width\": _util.get.width(_pinOptions.spacer)\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\t_util.css(_pin, {\r\n\t\t\t\t\t\t\t\"width\": \"100%\"\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// minwidth is needed for cascaded pins.\r\n\t\t\t\t\tcss[\"min-width\"] = _util.get.width(vertical ? _pin : pinTarget, true, true);\r\n\t\t\t\t\tcss.width = during ? css[\"min-width\"] : \"auto\";\r\n\t\t\t\t}\r\n\t\t\t\tif (_pinOptions.relSize.height) {\r\n\t\t\t\t\tif (during) {\r\n\t\t\t\t\t\t// the only padding the spacer should ever include is the duration (if pushFollowers = true), so we need to substract that.\r\n\t\t\t\t\t\t_util.css(_pin, {\r\n\t\t\t\t\t\t\t\"height\": _util.get.height(_pinOptions.spacer) - (_pinOptions.pushFollowers ? _options.duration : 0)\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\t_util.css(_pin, {\r\n\t\t\t\t\t\t\t\"height\": \"100%\"\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// margin is only included if it's a cascaded pin to resolve an IE9 bug\r\n\t\t\t\t\tcss[\"min-height\"] = _util.get.height(vertical ? pinTarget : _pin, true, !marginCollapse); // needed for cascading pins\r\n\t\t\t\t\tcss.height = during ? css[\"min-height\"] : \"auto\";\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// add space for duration if pushFollowers is true\r\n\t\t\t\tif (_pinOptions.pushFollowers) {\r\n\t\t\t\t\tcss[\"padding\" + (vertical ? \"Top\" : \"Left\")] = _options.duration * _progress;\r\n\t\t\t\t\tcss[\"padding\" + (vertical ? \"Bottom\" : \"Right\")] = _options.duration * (1 - _progress);\r\n\t\t\t\t}\r\n\t\t\t\t_util.css(_pinOptions.spacer, css);\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Updates the Pin state (in certain scenarios)\r\n\t\t * If the controller container is not the document and we are mid-pin-phase scrolling or resizing the main document can result to wrong pin positions.\r\n\t\t * So this function is called on resize and scroll of the document.\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar updatePinInContainer = function () {\r\n\t\t\tif (_controller && _pin && _state === SCENE_STATE_DURING && !_controller.info(\"isDocument\")) {\r\n\t\t\t\tupdatePinState();\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Updates the Pin spacer size state (in certain scenarios)\r\n\t\t * If container is resized during pin and relatively sized the size of the pin might need to be updated...\r\n\t\t * So this function is called on resize of the container.\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar updateRelativePinSpacer = function () {\r\n\t\t\tif (_controller && _pin && // well, duh\r\n\t\t\t\t_state === SCENE_STATE_DURING && // element in pinned state?\r\n\t\t\t\t( // is width or height relatively sized, but not in relation to body? then we need to recalc.\r\n\t\t\t\t\t((_pinOptions.relSize.width || _pinOptions.relSize.autoFullWidth) && _util.get.width(window) != _util.get.width(_pinOptions.spacer.parentNode)) ||\r\n\t\t\t\t\t(_pinOptions.relSize.height && _util.get.height(window) != _util.get.height(_pinOptions.spacer.parentNode))\r\n\t\t\t\t)\r\n\t\t\t) {\r\n\t\t\t\tupdatePinDimensions();\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Is called, when the mousewhel is used while over a pinned element inside a div container.\r\n\t\t * If the scene is in fixed state scroll events would be counted towards the body. This forwards the event to the scroll container.\r\n\t\t * @private\r\n\t\t */\r\n\t\tvar onMousewheelOverPin = function (e) {\r\n\t\t\tif (_controller && _pin && _state === SCENE_STATE_DURING && !_controller.info(\"isDocument\")) { // in pin state\r\n\t\t\t\te.preventDefault();\r\n\t\t\t\t_controller._setScrollPos(_controller.info(\"scrollPos\") - ((e.wheelDelta || e[_controller.info(\"vertical\") ? \"wheelDeltaY\" : \"wheelDeltaX\"]) / 3 || -e.detail * 30));\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Pin an element for the duration of the scene.\r\n\t\t * If the scene duration is 0 the element will only be unpinned, if the user scrolls back past the start position.  \r\n\t\t * Make sure only one pin is applied to an element at the same time.\r\n\t\t * An element can be pinned multiple times, but only successively.\r\n\t\t * _**NOTE:** The option `pushFollowers` has no effect, when the scene duration is 0._\r\n\t\t * @method ScrollMagic.Scene#setPin\r\n\t\t * @example\r\n\t\t * // pin element and push all following elements down by the amount of the pin duration.\r\n\t\t * scene.setPin(\"#pin\");\r\n\t\t *\r\n\t\t * // pin element and keeping all following elements in their place. The pinned element will move past them.\r\n\t\t * scene.setPin(\"#pin\", {pushFollowers: false});\r\n\t\t *\r\n\t\t * @param {(string|object)} element - A Selector targeting an element or a DOM object that is supposed to be pinned.\r\n\t\t * @param {object} [settings] - settings for the pin\r\n\t\t * @param {boolean} [settings.pushFollowers=true] - If `true` following elements will be \"pushed\" down for the duration of the pin, if `false` the pinned element will just scroll past them.  \r\n\t\t \t\t\t\t\t\t\t\t\t\t\t\t   Ignored, when duration is `0`.\r\n\t\t * @param {string} [settings.spacerClass=\"scrollmagic-pin-spacer\"] - Classname of the pin spacer element, which is used to replace the element.\r\n\t\t *\r\n\t\t * @returns {Scene} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.setPin = function (element, settings) {\r\n\t\t\tvar\r\n\t\t\t\tdefaultSettings = {\r\n\t\t\t\t\tpushFollowers: true,\r\n\t\t\t\t\tspacerClass: \"scrollmagic-pin-spacer\"\r\n\t\t\t\t};\r\n\t\t\tvar pushFollowersActivelySet = settings && settings.hasOwnProperty('pushFollowers');\r\n\t\t\tsettings = _util.extend({}, defaultSettings, settings);\r\n\r\n\t\t\t// validate Element\r\n\t\t\telement = _util.get.elements(element)[0];\r\n\t\t\tif (!element) {\r\n\t\t\t\tlog(1, \"ERROR calling method 'setPin()': Invalid pin element supplied.\");\r\n\t\t\t\treturn Scene; // cancel\r\n\t\t\t} else if (_util.css(element, \"position\") === \"fixed\") {\r\n\t\t\t\tlog(1, \"ERROR calling method 'setPin()': Pin does not work with elements that are positioned 'fixed'.\");\r\n\t\t\t\treturn Scene; // cancel\r\n\t\t\t}\r\n\r\n\t\t\tif (_pin) { // preexisting pin?\r\n\t\t\t\tif (_pin === element) {\r\n\t\t\t\t\t// same pin we already have -> do nothing\r\n\t\t\t\t\treturn Scene; // cancel\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// kill old pin\r\n\t\t\t\t\tScene.removePin();\r\n\t\t\t\t}\r\n\r\n\t\t\t}\r\n\t\t\t_pin = element;\r\n\r\n\t\t\tvar\r\n\t\t\t\tparentDisplay = _pin.parentNode.style.display,\r\n\t\t\t\tboundsParams = [\"top\", \"left\", \"bottom\", \"right\", \"margin\", \"marginLeft\", \"marginRight\", \"marginTop\", \"marginBottom\"];\r\n\r\n\t\t\t_pin.parentNode.style.display = 'none'; // hack start to force css to return stylesheet values instead of calculated px values.\r\n\t\t\tvar\r\n\t\t\t\tinFlow = _util.css(_pin, \"position\") != \"absolute\",\r\n\t\t\t\tpinCSS = _util.css(_pin, boundsParams.concat([\"display\"])),\r\n\t\t\t\tsizeCSS = _util.css(_pin, [\"width\", \"height\"]);\r\n\t\t\t_pin.parentNode.style.display = parentDisplay; // hack end.\r\n\r\n\t\t\tif (!inFlow && settings.pushFollowers) {\r\n\t\t\t\tlog(2, \"WARNING: If the pinned element is positioned absolutely pushFollowers will be disabled.\");\r\n\t\t\t\tsettings.pushFollowers = false;\r\n\t\t\t}\r\n\t\t\twindow.setTimeout(function () { // wait until all finished, because with responsive duration it will only be set after scene is added to controller\r\n\t\t\t\tif (_pin && _options.duration === 0 && pushFollowersActivelySet && settings.pushFollowers) {\r\n\t\t\t\t\tlog(2, \"WARNING: pushFollowers =\", true, \"has no effect, when scene duration is 0.\");\r\n\t\t\t\t}\r\n\t\t\t}, 0);\r\n\r\n\t\t\t// create spacer and insert\r\n\t\t\tvar\r\n\t\t\t\tspacer = _pin.parentNode.insertBefore(document.createElement('div'), _pin),\r\n\t\t\t\tspacerCSS = _util.extend(pinCSS, {\r\n\t\t\t\t\tposition: inFlow ? \"relative\" : \"absolute\",\r\n\t\t\t\t\tboxSizing: \"content-box\",\r\n\t\t\t\t\tmozBoxSizing: \"content-box\",\r\n\t\t\t\t\twebkitBoxSizing: \"content-box\"\r\n\t\t\t\t});\r\n\r\n\t\t\tif (!inFlow) { // copy size if positioned absolutely, to work for bottom/right positioned elements.\r\n\t\t\t\t_util.extend(spacerCSS, _util.css(_pin, [\"width\", \"height\"]));\r\n\t\t\t}\r\n\r\n\t\t\t_util.css(spacer, spacerCSS);\r\n\t\t\tspacer.setAttribute(PIN_SPACER_ATTRIBUTE, \"\");\r\n\t\t\t_util.addClass(spacer, settings.spacerClass);\r\n\r\n\t\t\t// set the pin Options\r\n\t\t\t_pinOptions = {\r\n\t\t\t\tspacer: spacer,\r\n\t\t\t\trelSize: { // save if size is defined using % values. if so, handle spacer resize differently...\r\n\t\t\t\t\twidth: sizeCSS.width.slice(-1) === \"%\",\r\n\t\t\t\t\theight: sizeCSS.height.slice(-1) === \"%\",\r\n\t\t\t\t\tautoFullWidth: sizeCSS.width === \"auto\" && inFlow && _util.isMarginCollapseType(pinCSS.display)\r\n\t\t\t\t},\r\n\t\t\t\tpushFollowers: settings.pushFollowers,\r\n\t\t\t\tinFlow: inFlow, // stores if the element takes up space in the document flow\r\n\t\t\t};\r\n\r\n\t\t\tif (!_pin.___origStyle) {\r\n\t\t\t\t_pin.___origStyle = {};\r\n\t\t\t\tvar\r\n\t\t\t\t\tpinInlineCSS = _pin.style,\r\n\t\t\t\t\tcopyStyles = boundsParams.concat([\"width\", \"height\", \"position\", \"boxSizing\", \"mozBoxSizing\", \"webkitBoxSizing\"]);\r\n\t\t\t\tcopyStyles.forEach(function (val) {\r\n\t\t\t\t\t_pin.___origStyle[val] = pinInlineCSS[val] || \"\";\r\n\t\t\t\t});\r\n\t\t\t}\r\n\r\n\t\t\t// if relative size, transfer it to spacer and make pin calculate it...\r\n\t\t\tif (_pinOptions.relSize.width) {\r\n\t\t\t\t_util.css(spacer, {\r\n\t\t\t\t\twidth: sizeCSS.width\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t\tif (_pinOptions.relSize.height) {\r\n\t\t\t\t_util.css(spacer, {\r\n\t\t\t\t\theight: sizeCSS.height\r\n\t\t\t\t});\r\n\t\t\t}\r\n\r\n\t\t\t// now place the pin element inside the spacer\t\r\n\t\t\tspacer.appendChild(_pin);\r\n\t\t\t// and set new css\r\n\t\t\t_util.css(_pin, {\r\n\t\t\t\tposition: inFlow ? \"relative\" : \"absolute\",\r\n\t\t\t\tmargin: \"auto\",\r\n\t\t\t\ttop: \"auto\",\r\n\t\t\t\tleft: \"auto\",\r\n\t\t\t\tbottom: \"auto\",\r\n\t\t\t\tright: \"auto\"\r\n\t\t\t});\r\n\r\n\t\t\tif (_pinOptions.relSize.width || _pinOptions.relSize.autoFullWidth) {\r\n\t\t\t\t_util.css(_pin, {\r\n\t\t\t\t\tboxSizing: \"border-box\",\r\n\t\t\t\t\tmozBoxSizing: \"border-box\",\r\n\t\t\t\t\twebkitBoxSizing: \"border-box\"\r\n\t\t\t\t});\r\n\t\t\t}\r\n\r\n\t\t\t// add listener to document to update pin position in case controller is not the document.\r\n\t\t\twindow.addEventListener('scroll', updatePinInContainer);\r\n\t\t\twindow.addEventListener('resize', updatePinInContainer);\r\n\t\t\twindow.addEventListener('resize', updateRelativePinSpacer);\r\n\t\t\t// add mousewheel listener to catch scrolls over fixed elements\r\n\t\t\t_pin.addEventListener(\"mousewheel\", onMousewheelOverPin);\r\n\t\t\t_pin.addEventListener(\"DOMMouseScroll\", onMousewheelOverPin);\r\n\r\n\t\t\tlog(3, \"added pin\");\r\n\r\n\t\t\t// finally update the pin to init\r\n\t\t\tupdatePinState();\r\n\r\n\t\t\treturn Scene;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Remove the pin from the scene.\r\n\t\t * @method ScrollMagic.Scene#removePin\r\n\t\t * @example\r\n\t\t * // remove the pin from the scene without resetting it (the spacer is not removed)\r\n\t\t * scene.removePin();\r\n\t\t *\r\n\t\t * // remove the pin from the scene and reset the pin element to its initial position (spacer is removed)\r\n\t\t * scene.removePin(true);\r\n\t\t *\r\n\t\t * @param {boolean} [reset=false] - If `false` the spacer will not be removed and the element's position will not be reset.\r\n\t\t * @returns {Scene} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.removePin = function (reset) {\r\n\t\t\tif (_pin) {\r\n\t\t\t\tif (_state === SCENE_STATE_DURING) {\r\n\t\t\t\t\tupdatePinState(true); // force unpin at position\r\n\t\t\t\t}\r\n\t\t\t\tif (reset || !_controller) { // if there's no controller no progress was made anyway...\r\n\t\t\t\t\tvar pinTarget = _pinOptions.spacer.firstChild; // usually the pin element, but may be another spacer (cascaded pins)...\r\n\t\t\t\t\tif (pinTarget.hasAttribute(PIN_SPACER_ATTRIBUTE)) { // copy margins to child spacer\r\n\t\t\t\t\t\tvar\r\n\t\t\t\t\t\t\tstyle = _pinOptions.spacer.style,\r\n\t\t\t\t\t\t\tvalues = [\"margin\", \"marginLeft\", \"marginRight\", \"marginTop\", \"marginBottom\"],\r\n\t\t\t\t\t\t\tmargins = {};\r\n\t\t\t\t\t\tvalues.forEach(function (val) {\r\n\t\t\t\t\t\t\tmargins[val] = style[val] || \"\";\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t\t_util.css(pinTarget, margins);\r\n\t\t\t\t\t}\r\n\t\t\t\t\t_pinOptions.spacer.parentNode.insertBefore(pinTarget, _pinOptions.spacer);\r\n\t\t\t\t\t_pinOptions.spacer.parentNode.removeChild(_pinOptions.spacer);\r\n\t\t\t\t\tif (!_pin.parentNode.hasAttribute(PIN_SPACER_ATTRIBUTE)) { // if it's the last pin for this element -> restore inline styles\r\n\t\t\t\t\t\t// TODO: only correctly set for first pin (when cascading) - how to fix?\r\n\t\t\t\t\t\t_util.css(_pin, _pin.___origStyle);\r\n\t\t\t\t\t\tdelete _pin.___origStyle;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\twindow.removeEventListener('scroll', updatePinInContainer);\r\n\t\t\t\twindow.removeEventListener('resize', updatePinInContainer);\r\n\t\t\t\twindow.removeEventListener('resize', updateRelativePinSpacer);\r\n\t\t\t\t_pin.removeEventListener(\"mousewheel\", onMousewheelOverPin);\r\n\t\t\t\t_pin.removeEventListener(\"DOMMouseScroll\", onMousewheelOverPin);\r\n\t\t\t\t_pin = undefined;\r\n\t\t\t\tlog(3, \"removed pin (reset: \" + (reset ? \"true\" : \"false\") + \")\");\r\n\t\t\t}\r\n\t\t\treturn Scene;\r\n\t\t};\r\n\r\n\r\n\t\tvar\r\n\t\t\t_cssClasses,\r\n\t\t\t_cssClassElems = [];\r\n\r\n\t\tScene\r\n\t\t\t.on(\"destroy.internal\", function (e) {\r\n\t\t\t\tScene.removeClassToggle(e.reset);\r\n\t\t\t});\r\n\t\t/**\r\n\t\t * Define a css class modification while the scene is active.  \r\n\t\t * When the scene triggers the classes will be added to the supplied element and removed, when the scene is over.\r\n\t\t * If the scene duration is 0 the classes will only be removed if the user scrolls back past the start position.\r\n\t\t * @method ScrollMagic.Scene#setClassToggle\r\n\t\t * @example\r\n\t\t * // add the class 'myclass' to the element with the id 'my-elem' for the duration of the scene\r\n\t\t * scene.setClassToggle(\"#my-elem\", \"myclass\");\r\n\t\t *\r\n\t\t * // add multiple classes to multiple elements defined by the selector '.classChange'\r\n\t\t * scene.setClassToggle(\".classChange\", \"class1 class2 class3\");\r\n\t\t *\r\n\t\t * @param {(string|object)} element - A Selector targeting one or more elements or a DOM object that is supposed to be modified.\r\n\t\t * @param {string} classes - One or more Classnames (separated by space) that should be added to the element during the scene.\r\n\t\t *\r\n\t\t * @returns {Scene} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.setClassToggle = function (element, classes) {\r\n\t\t\tvar elems = _util.get.elements(element);\r\n\t\t\tif (elems.length === 0 || !_util.type.String(classes)) {\r\n\t\t\t\tlog(1, \"ERROR calling method 'setClassToggle()': Invalid \" + (elems.length === 0 ? \"element\" : \"classes\") + \" supplied.\");\r\n\t\t\t\treturn Scene;\r\n\t\t\t}\r\n\t\t\tif (_cssClassElems.length > 0) {\r\n\t\t\t\t// remove old ones\r\n\t\t\t\tScene.removeClassToggle();\r\n\t\t\t}\r\n\t\t\t_cssClasses = classes;\r\n\t\t\t_cssClassElems = elems;\r\n\t\t\tScene.on(\"enter.internal_class leave.internal_class\", function (e) {\r\n\t\t\t\tvar toggle = e.type === \"enter\" ? _util.addClass : _util.removeClass;\r\n\t\t\t\t_cssClassElems.forEach(function (elem, key) {\r\n\t\t\t\t\ttoggle(elem, _cssClasses);\r\n\t\t\t\t});\r\n\t\t\t});\r\n\t\t\treturn Scene;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * Remove the class binding from the scene.\r\n\t\t * @method ScrollMagic.Scene#removeClassToggle\r\n\t\t * @example\r\n\t\t * // remove class binding from the scene without reset\r\n\t\t * scene.removeClassToggle();\r\n\t\t *\r\n\t\t * // remove class binding and remove the changes it caused\r\n\t\t * scene.removeClassToggle(true);\r\n\t\t *\r\n\t\t * @param {boolean} [reset=false] - If `false` and the classes are currently active, they will remain on the element. If `true` they will be removed.\r\n\t\t * @returns {Scene} Parent object for chaining.\r\n\t\t */\r\n\t\tthis.removeClassToggle = function (reset) {\r\n\t\t\tif (reset) {\r\n\t\t\t\t_cssClassElems.forEach(function (elem, key) {\r\n\t\t\t\t\t_util.removeClass(elem, _cssClasses);\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t\tScene.off(\"start.internal_class end.internal_class\");\r\n\t\t\t_cssClasses = undefined;\r\n\t\t\t_cssClassElems = [];\r\n\t\t\treturn Scene;\r\n\t\t};\r\n\r\n\t\t// INIT\r\n\t\tconstruct();\r\n\t\treturn Scene;\r\n\t};\r\n\r\n\t// store pagewide scene options\r\n\tvar SCENE_OPTIONS = {\r\n\t\tdefaults: {\r\n\t\t\tduration: 0,\r\n\t\t\toffset: 0,\r\n\t\t\ttriggerElement: undefined,\r\n\t\t\ttriggerHook: 0.5,\r\n\t\t\treverse: true,\r\n\t\t\tloglevel: 2\r\n\t\t},\r\n\t\tvalidate: {\r\n\t\t\toffset: function (val) {\r\n\t\t\t\tval = parseFloat(val);\r\n\t\t\t\tif (!_util.type.Number(val)) {\r\n\t\t\t\t\tthrow [\"Invalid value for option \\\"offset\\\":\", val];\r\n\t\t\t\t}\r\n\t\t\t\treturn val;\r\n\t\t\t},\r\n\t\t\ttriggerElement: function (val) {\r\n\t\t\t\tval = val || undefined;\r\n\t\t\t\tif (val) {\r\n\t\t\t\t\tvar elem = _util.get.elements(val)[0];\r\n\t\t\t\t\tif (elem && elem.parentNode) {\r\n\t\t\t\t\t\tval = elem;\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tthrow [\"Element defined in option \\\"triggerElement\\\" was not found:\", val];\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\treturn val;\r\n\t\t\t},\r\n\t\t\ttriggerHook: function (val) {\r\n\t\t\t\tvar translate = {\r\n\t\t\t\t\t\"onCenter\": 0.5,\r\n\t\t\t\t\t\"onEnter\": 1,\r\n\t\t\t\t\t\"onLeave\": 0\r\n\t\t\t\t};\r\n\t\t\t\tif (_util.type.Number(val)) {\r\n\t\t\t\t\tval = Math.max(0, Math.min(parseFloat(val), 1)); //  make sure its betweeen 0 and 1\r\n\t\t\t\t} else if (val in translate) {\r\n\t\t\t\t\tval = translate[val];\r\n\t\t\t\t} else {\r\n\t\t\t\t\tthrow [\"Invalid value for option \\\"triggerHook\\\": \", val];\r\n\t\t\t\t}\r\n\t\t\t\treturn val;\r\n\t\t\t},\r\n\t\t\treverse: function (val) {\r\n\t\t\t\treturn !!val; // force boolean\r\n\t\t\t},\r\n\t\t\tloglevel: function (val) {\r\n\t\t\t\tval = parseInt(val);\r\n\t\t\t\tif (!_util.type.Number(val) || val < 0 || val > 3) {\r\n\t\t\t\t\tthrow [\"Invalid value for option \\\"loglevel\\\":\", val];\r\n\t\t\t\t}\r\n\t\t\t\treturn val;\r\n\t\t\t}\r\n\t\t}, // holder for  validation methods. duration validation is handled in 'getters-setters.js'\r\n\t\tshifts: [\"duration\", \"offset\", \"triggerHook\"], // list of options that trigger a `shift` event\r\n\t};\r\n\t/*\r\n\t * method used to add an option to ScrollMagic Scenes.\r\n\t * TODO: DOC (private for dev)\r\n\t */\r\n\tScrollMagic.Scene.addOption = function (name, defaultValue, validationCallback, shifts) {\r\n\t\tif (!(name in SCENE_OPTIONS.defaults)) {\r\n\t\t\tSCENE_OPTIONS.defaults[name] = defaultValue;\r\n\t\t\tSCENE_OPTIONS.validate[name] = validationCallback;\r\n\t\t\tif (shifts) {\r\n\t\t\t\tSCENE_OPTIONS.shifts.push(name);\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tScrollMagic._util.log(1, \"[static] ScrollMagic.Scene -> Cannot add Scene option '\" + name + \"', because it already exists.\");\r\n\t\t}\r\n\t};\r\n\t// instance extension function for plugins\r\n\t// TODO: DOC (private for dev)\r\n\tScrollMagic.Scene.extend = function (extension) {\r\n\t\tvar oldClass = this;\r\n\t\tScrollMagic.Scene = function () {\r\n\t\t\toldClass.apply(this, arguments);\r\n\t\t\tthis.$super = _util.extend({}, this); // copy parent state\r\n\t\t\treturn extension.apply(this, arguments) || this;\r\n\t\t};\r\n\t\t_util.extend(ScrollMagic.Scene, oldClass); // copy properties\r\n\t\tScrollMagic.Scene.prototype = oldClass.prototype; // copy prototype\r\n\t\tScrollMagic.Scene.prototype.constructor = ScrollMagic.Scene; // restore constructor\r\n\t};\r\n\r\n\r\n\r\n\t/**\r\n\t * TODO: DOCS (private for dev)\r\n\t * @class\r\n\t * @private\r\n\t */\r\n\r\n\tScrollMagic.Event = function (type, namespace, target, vars) {\r\n\t\tvars = vars || {};\r\n\t\tfor (var key in vars) {\r\n\t\t\tthis[key] = vars[key];\r\n\t\t}\r\n\t\tthis.type = type;\r\n\t\tthis.target = this.currentTarget = target;\r\n\t\tthis.namespace = namespace || '';\r\n\t\tthis.timeStamp = this.timestamp = Date.now();\r\n\t\treturn this;\r\n\t};\r\n\r\n\t/*\r\n\t * TODO: DOCS (private for dev)\r\n\t */\r\n\r\n\tvar _util = ScrollMagic._util = (function (window) {\r\n\t\tvar U = {},\r\n\t\t\ti;\r\n\r\n\t\t/**\r\n\t\t * ------------------------------\r\n\t\t * internal helpers\r\n\t\t * ------------------------------\r\n\t\t */\r\n\r\n\t\t// parse float and fall back to 0.\r\n\t\tvar floatval = function (number) {\r\n\t\t\treturn parseFloat(number) || 0;\r\n\t\t};\r\n\t\t// get current style IE safe (otherwise IE would return calculated values for 'auto')\r\n\t\tvar _getComputedStyle = function (elem) {\r\n\t\t\treturn elem.currentStyle ? elem.currentStyle : window.getComputedStyle(elem);\r\n\t\t};\r\n\r\n\t\t// get element dimension (width or height)\r\n\t\tvar _dimension = function (which, elem, outer, includeMargin) {\r\n\t\t\telem = (elem === document) ? window : elem;\r\n\t\t\tif (elem === window) {\r\n\t\t\t\tincludeMargin = false;\r\n\t\t\t} else if (!_type.DomElement(elem)) {\r\n\t\t\t\treturn 0;\r\n\t\t\t}\r\n\t\t\twhich = which.charAt(0).toUpperCase() + which.substr(1).toLowerCase();\r\n\t\t\tvar dimension = (outer ? elem['offset' + which] || elem['outer' + which] : elem['client' + which] || elem['inner' + which]) || 0;\r\n\t\t\tif (outer && includeMargin) {\r\n\t\t\t\tvar style = _getComputedStyle(elem);\r\n\t\t\t\tdimension += which === 'Height' ? floatval(style.marginTop) + floatval(style.marginBottom) : floatval(style.marginLeft) + floatval(style.marginRight);\r\n\t\t\t}\r\n\t\t\treturn dimension;\r\n\t\t};\r\n\t\t// converts 'margin-top' into 'marginTop'\r\n\t\tvar _camelCase = function (str) {\r\n\t\t\treturn str.replace(/^[^a-z]+([a-z])/g, '$1').replace(/-([a-z])/g, function (g) {\r\n\t\t\t\treturn g[1].toUpperCase();\r\n\t\t\t});\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * ------------------------------\r\n\t\t * external helpers\r\n\t\t * ------------------------------\r\n\t\t */\r\n\r\n\t\t// extend obj – same as jQuery.extend({}, objA, objB)\r\n\t\tU.extend = function (obj) {\r\n\t\t\tobj = obj || {};\r\n\t\t\tfor (i = 1; i < arguments.length; i++) {\r\n\t\t\t\tif (!arguments[i]) {\r\n\t\t\t\t\tcontinue;\r\n\t\t\t\t}\r\n\t\t\t\tfor (var key in arguments[i]) {\r\n\t\t\t\t\tif (arguments[i].hasOwnProperty(key)) {\r\n\t\t\t\t\t\tobj[key] = arguments[i][key];\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn obj;\r\n\t\t};\r\n\r\n\t\t// check if a css display type results in margin-collapse or not\r\n\t\tU.isMarginCollapseType = function (str) {\r\n\t\t\treturn [\"block\", \"flex\", \"list-item\", \"table\", \"-webkit-box\"].indexOf(str) > -1;\r\n\t\t};\r\n\r\n\t\t// implementation of requestAnimationFrame\r\n\t\t// based on https://gist.github.com/paulirish/1579671\r\n\t\tvar\r\n\t\t\tlastTime = 0,\r\n\t\t\tvendors = ['ms', 'moz', 'webkit', 'o'];\r\n\t\tvar _requestAnimationFrame = window.requestAnimationFrame;\r\n\t\tvar _cancelAnimationFrame = window.cancelAnimationFrame;\r\n\t\t// try vendor prefixes if the above doesn't work\r\n\t\tfor (i = 0; !_requestAnimationFrame && i < vendors.length; ++i) {\r\n\t\t\t_requestAnimationFrame = window[vendors[i] + 'RequestAnimationFrame'];\r\n\t\t\t_cancelAnimationFrame = window[vendors[i] + 'CancelAnimationFrame'] || window[vendors[i] + 'CancelRequestAnimationFrame'];\r\n\t\t}\r\n\r\n\t\t// fallbacks\r\n\t\tif (!_requestAnimationFrame) {\r\n\t\t\t_requestAnimationFrame = function (callback) {\r\n\t\t\t\tvar\r\n\t\t\t\t\tcurrTime = new Date().getTime(),\r\n\t\t\t\t\ttimeToCall = Math.max(0, 16 - (currTime - lastTime)),\r\n\t\t\t\t\tid = window.setTimeout(function () {\r\n\t\t\t\t\t\tcallback(currTime + timeToCall);\r\n\t\t\t\t\t}, timeToCall);\r\n\t\t\t\tlastTime = currTime + timeToCall;\r\n\t\t\t\treturn id;\r\n\t\t\t};\r\n\t\t}\r\n\t\tif (!_cancelAnimationFrame) {\r\n\t\t\t_cancelAnimationFrame = function (id) {\r\n\t\t\t\twindow.clearTimeout(id);\r\n\t\t\t};\r\n\t\t}\r\n\t\tU.rAF = _requestAnimationFrame.bind(window);\r\n\t\tU.cAF = _cancelAnimationFrame.bind(window);\r\n\r\n\t\tvar\r\n\t\t\tloglevels = [\"error\", \"warn\", \"log\"],\r\n\t\t\tconsole = window.console || {};\r\n\r\n\t\tconsole.log = console.log || function () {}; // no console log, well - do nothing then...\r\n\t\t// make sure methods for all levels exist.\r\n\t\tfor (i = 0; i < loglevels.length; i++) {\r\n\t\t\tvar method = loglevels[i];\r\n\t\t\tif (!console[method]) {\r\n\t\t\t\tconsole[method] = console.log; // prefer .log over nothing\r\n\t\t\t}\r\n\t\t}\r\n\t\tU.log = function (loglevel) {\r\n\t\t\tif (loglevel > loglevels.length || loglevel <= 0) loglevel = loglevels.length;\r\n\t\t\tvar now = new Date(),\r\n\t\t\t\ttime = (\"0\" + now.getHours()).slice(-2) + \":\" + (\"0\" + now.getMinutes()).slice(-2) + \":\" + (\"0\" + now.getSeconds()).slice(-2) + \":\" + (\"00\" + now.getMilliseconds()).slice(-3),\r\n\t\t\t\tmethod = loglevels[loglevel - 1],\r\n\t\t\t\targs = Array.prototype.splice.call(arguments, 1),\r\n\t\t\t\tfunc = Function.prototype.bind.call(console[method], console);\r\n\t\t\targs.unshift(time);\r\n\t\t\tfunc.apply(console, args);\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * ------------------------------\r\n\t\t * type testing\r\n\t\t * ------------------------------\r\n\t\t */\r\n\r\n\t\tvar _type = U.type = function (v) {\r\n\t\t\treturn Object.prototype.toString.call(v).replace(/^\\[object (.+)\\]$/, \"$1\").toLowerCase();\r\n\t\t};\r\n\t\t_type.String = function (v) {\r\n\t\t\treturn _type(v) === 'string';\r\n\t\t};\r\n\t\t_type.Function = function (v) {\r\n\t\t\treturn _type(v) === 'function';\r\n\t\t};\r\n\t\t_type.Array = function (v) {\r\n\t\t\treturn Array.isArray(v);\r\n\t\t};\r\n\t\t_type.Number = function (v) {\r\n\t\t\treturn !_type.Array(v) && (v - parseFloat(v) + 1) >= 0;\r\n\t\t};\r\n\t\t_type.DomElement = function (o) {\r\n\t\t\treturn (\r\n\t\t\t\ttypeof HTMLElement === \"object\" || typeof HTMLElement === \"function\" ? o instanceof HTMLElement || o instanceof SVGElement : //DOM2\r\n\t\t\t\to && typeof o === \"object\" && o !== null && o.nodeType === 1 && typeof o.nodeName === \"string\"\r\n\t\t\t);\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * ------------------------------\r\n\t\t * DOM Element info\r\n\t\t * ------------------------------\r\n\t\t */\r\n\t\t// always returns a list of matching DOM elements, from a selector, a DOM element or an list of elements or even an array of selectors\r\n\t\tvar _get = U.get = {};\r\n\t\t_get.elements = function (selector) {\r\n\t\t\tvar arr = [];\r\n\t\t\tif (_type.String(selector)) {\r\n\t\t\t\ttry {\r\n\t\t\t\t\tselector = document.querySelectorAll(selector);\r\n\t\t\t\t} catch (e) { // invalid selector\r\n\t\t\t\t\treturn arr;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (_type(selector) === 'nodelist' || _type.Array(selector) || selector instanceof NodeList) {\r\n\t\t\t\tfor (var i = 0, ref = arr.length = selector.length; i < ref; i++) { // list of elements\r\n\t\t\t\t\tvar elem = selector[i];\r\n\t\t\t\t\tarr[i] = _type.DomElement(elem) ? elem : _get.elements(elem); // if not an element, try to resolve recursively\r\n\t\t\t\t}\r\n\t\t\t} else if (_type.DomElement(selector) || selector === document || selector === window) {\r\n\t\t\t\tarr = [selector]; // only the element\r\n\t\t\t}\r\n\t\t\treturn arr;\r\n\t\t};\r\n\t\t// get scroll top value\r\n\t\t_get.scrollTop = function (elem) {\r\n\t\t\treturn (elem && typeof elem.scrollTop === 'number') ? elem.scrollTop : window.pageYOffset || 0;\r\n\t\t};\r\n\t\t// get scroll left value\r\n\t\t_get.scrollLeft = function (elem) {\r\n\t\t\treturn (elem && typeof elem.scrollLeft === 'number') ? elem.scrollLeft : window.pageXOffset || 0;\r\n\t\t};\r\n\t\t// get element height\r\n\t\t_get.width = function (elem, outer, includeMargin) {\r\n\t\t\treturn _dimension('width', elem, outer, includeMargin);\r\n\t\t};\r\n\t\t// get element width\r\n\t\t_get.height = function (elem, outer, includeMargin) {\r\n\t\t\treturn _dimension('height', elem, outer, includeMargin);\r\n\t\t};\r\n\r\n\t\t// get element position (optionally relative to viewport)\r\n\t\t_get.offset = function (elem, relativeToViewport) {\r\n\t\t\tvar offset = {\r\n\t\t\t\ttop: 0,\r\n\t\t\t\tleft: 0\r\n\t\t\t};\r\n\t\t\tif (elem && elem.getBoundingClientRect) { // check if available\r\n\t\t\t\tvar rect = elem.getBoundingClientRect();\r\n\t\t\t\toffset.top = rect.top;\r\n\t\t\t\toffset.left = rect.left;\r\n\t\t\t\tif (!relativeToViewport) { // clientRect is by default relative to viewport...\r\n\t\t\t\t\toffset.top += _get.scrollTop();\r\n\t\t\t\t\toffset.left += _get.scrollLeft();\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn offset;\r\n\t\t};\r\n\r\n\t\t/**\r\n\t\t * ------------------------------\r\n\t\t * DOM Element manipulation\r\n\t\t * ------------------------------\r\n\t\t */\r\n\r\n\t\tU.addClass = function (elem, classname) {\r\n\t\t\tif (classname) {\r\n\t\t\t\tif (elem.classList)\r\n\t\t\t\t\telem.classList.add(classname);\r\n\t\t\t\telse\r\n\t\t\t\t\telem.className += ' ' + classname;\r\n\t\t\t}\r\n\t\t};\r\n\t\tU.removeClass = function (elem, classname) {\r\n\t\t\tif (classname) {\r\n\t\t\t\tif (elem.classList)\r\n\t\t\t\t\telem.classList.remove(classname);\r\n\t\t\t\telse\r\n\t\t\t\t\telem.className = elem.className.replace(new RegExp('(^|\\\\b)' + classname.split(' ').join('|') + '(\\\\b|$)', 'gi'), ' ');\r\n\t\t\t}\r\n\t\t};\r\n\t\t// if options is string -> returns css value\r\n\t\t// if options is array -> returns object with css value pairs\r\n\t\t// if options is object -> set new css values\r\n\t\tU.css = function (elem, options) {\r\n\t\t\tif (_type.String(options)) {\r\n\t\t\t\treturn _getComputedStyle(elem)[_camelCase(options)];\r\n\t\t\t} else if (_type.Array(options)) {\r\n\t\t\t\tvar\r\n\t\t\t\t\tobj = {},\r\n\t\t\t\t\tstyle = _getComputedStyle(elem);\r\n\t\t\t\toptions.forEach(function (option, key) {\r\n\t\t\t\t\tobj[option] = style[_camelCase(option)];\r\n\t\t\t\t});\r\n\t\t\t\treturn obj;\r\n\t\t\t} else {\r\n\t\t\t\tfor (var option in options) {\r\n\t\t\t\t\tvar val = options[option];\r\n\t\t\t\t\tif (val == parseFloat(val)) { // assume pixel for seemingly numerical values\r\n\t\t\t\t\t\tval += 'px';\r\n\t\t\t\t\t}\r\n\t\t\t\t\telem.style[_camelCase(option)] = val;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\treturn U;\r\n\t}(window || {}));\r\n\r\n\r\n\tScrollMagic.Scene.prototype.addIndicators = function () {\r\n\t\tScrollMagic._util.log(1, '(ScrollMagic.Scene) -> ERROR calling addIndicators() due to missing Plugin \\'debug.addIndicators\\'. Please make sure to include plugins/debug.addIndicators.js');\r\n\t\treturn this;\r\n\t}\r\n\tScrollMagic.Scene.prototype.removeIndicators = function () {\r\n\t\tScrollMagic._util.log(1, '(ScrollMagic.Scene) -> ERROR calling removeIndicators() due to missing Plugin \\'debug.addIndicators\\'. Please make sure to include plugins/debug.addIndicators.js');\r\n\t\treturn this;\r\n\t}\r\n\tScrollMagic.Scene.prototype.setTween = function () {\r\n\t\tScrollMagic._util.log(1, '(ScrollMagic.Scene) -> ERROR calling setTween() due to missing Plugin \\'animation.gsap\\'. Please make sure to include plugins/animation.gsap.js');\r\n\t\treturn this;\r\n\t}\r\n\tScrollMagic.Scene.prototype.removeTween = function () {\r\n\t\tScrollMagic._util.log(1, '(ScrollMagic.Scene) -> ERROR calling removeTween() due to missing Plugin \\'animation.gsap\\'. Please make sure to include plugins/animation.gsap.js');\r\n\t\treturn this;\r\n\t}\r\n\tScrollMagic.Scene.prototype.setVelocity = function () {\r\n\t\tScrollMagic._util.log(1, '(ScrollMagic.Scene) -> ERROR calling setVelocity() due to missing Plugin \\'animation.velocity\\'. Please make sure to include plugins/animation.velocity.js');\r\n\t\treturn this;\r\n\t}\r\n\tScrollMagic.Scene.prototype.removeVelocity = function () {\r\n\t\tScrollMagic._util.log(1, '(ScrollMagic.Scene) -> ERROR calling removeVelocity() due to missing Plugin \\'animation.velocity\\'. Please make sure to include plugins/animation.velocity.js');\r\n\t\treturn this;\r\n\t}\r\n\r\n\treturn ScrollMagic;\r\n}));","/**\n * velocity-animate (C) 2014-2017 Julian Shapiro.\n *\n * Licensed under the MIT license. See LICENSE file in the project root for details.\n */\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n  return typeof obj;\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar defineProperty = function (obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n};\n\n/**\r\n * Check if a variable is a boolean.\r\n */\nfunction isBoolean(variable) {\n    return variable === true || variable === false;\n}\n/**\r\n * Check if a variable is a function.\r\n */\nfunction isFunction(variable) {\n    return Object.prototype.toString.call(variable) === \"[object Function]\";\n}\n/**\r\n * Check if a variable is an HTMLElement or SVGElement.\r\n */\nfunction isNode(variable) {\n    return !!(variable && variable.nodeType);\n}\n/**\r\n * Check if a variable is a number.\r\n */\nfunction isNumber(variable) {\n    return typeof variable === \"number\";\n}\n/**\r\n * Check if a variable is a plain object (and not an instance).\r\n */\nfunction isPlainObject(variable) {\n    if (!variable || (typeof variable === \"undefined\" ? \"undefined\" : _typeof(variable)) !== \"object\" || variable.nodeType || Object.prototype.toString.call(variable) !== \"[object Object]\") {\n        return false;\n    }\n    var proto = Object.getPrototypeOf(variable);\n    return !proto || proto.hasOwnProperty(\"constructor\") && proto.constructor === Object;\n}\n/**\r\n * Check if a variable is a string.\r\n */\nfunction isString(variable) {\n    return typeof variable === \"string\";\n}\n/**\r\n * Check if a variable is the result of calling Velocity.\r\n */\nfunction isVelocityResult(variable) {\n    return variable && isNumber(variable.length) && isFunction(variable.velocity);\n}\n/**\r\n * Check if a variable is an array-like wrapped jQuery, Zepto or similar, where\r\n * each indexed value is a Node.\r\n */\nfunction isWrapped(variable) {\n    return variable && variable !== window && isNumber(variable.length) && !isString(variable) && !isFunction(variable) && !isNode(variable) && (variable.length === 0 || isNode(variable[0]));\n}\n/**\r\n * Check is a property is an enumerable member of an object.\r\n */\nfunction propertyIsEnumerable(obj, property) {\n    return Object.prototype.propertyIsEnumerable.call(obj, property);\n}\n\n// Project\n/**\r\n * Add a single className to an Element.\r\n */\nfunction addClass(element, className) {\n    if (element instanceof Element) {\n        if (element.classList) {\n            element.classList.add(className);\n        } else {\n            removeClass(element, className);\n            element.className += (element.className.length ? \" \" : \"\") + className;\n        }\n    }\n}\n/**\r\n * Clone an array, works for array-like too.\r\n */\nfunction cloneArray(arrayLike) {\n    return Array.prototype.slice.call(arrayLike, 0);\n}\n/**\r\n * The <strong><code>defineProperty()</code></strong> function provides a\r\n * shortcut to defining a property that cannot be accidentally iterated across.\r\n */\nfunction defineProperty$1(proto, name, value, readonly) {\n    if (proto) {\n        Object.defineProperty(proto, name, {\n            configurable: !readonly,\n            writable: !readonly,\n            value: value\n        });\n    }\n}\n/**\r\n * When there are multiple locations for a value pass them all in, then get the\r\n * first value that is valid.\r\n */\nfunction getValue() {\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n        args[_key] = arguments[_key];\n    }\n\n    var _iteratorNormalCompletion = true;\n    var _didIteratorError = false;\n    var _iteratorError = undefined;\n\n    try {\n        for (var _iterator = args[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n            var arg = _step.value;\n\n            if (arg !== undefined && arg === arg) {\n                return arg;\n            }\n        }\n    } catch (err) {\n        _didIteratorError = true;\n        _iteratorError = err;\n    } finally {\n        try {\n            if (!_iteratorNormalCompletion && _iterator.return) {\n                _iterator.return();\n            }\n        } finally {\n            if (_didIteratorError) {\n                throw _iteratorError;\n            }\n        }\n    }\n}\n/**\r\n * Shim to get the current milliseconds - on anything except old IE it'll use\r\n * Date.now() and save creating an object. If that doesn't exist then it'll\r\n * create one that gets GC.\r\n */\nvar now = Date.now ? Date.now : function () {\n    return new Date().getTime();\n};\n/**\r\n * Remove a single className from an Element.\r\n */\nfunction removeClass(element, className) {\n    if (element instanceof Element) {\n        if (element.classList) {\n            element.classList.remove(className);\n        } else {\n            // TODO: Need some jsperf tests on performance - can we get rid of the regex and maybe use split / array manipulation?\n            element.className = element.className.replace(new RegExp(\"(^|\\\\s)\" + className + \"(\\\\s|$)\", \"gi\"), \" \");\n        }\n    }\n}\n\n// Project\n// Constants\nvar Actions = {};\n/**\r\n * Used to register an action. This should never be called by users\r\n * directly, instead it should be called via  an action:<br/>\r\n * <code>Velocity(\"registerAction\", \"name\", VelocityActionFn);</code>\r\n */\nfunction registerAction(args, internal) {\n    var name = args[0],\n        callback = args[1];\n    if (!isString(name)) {\n        console.warn(\"VelocityJS: Trying to set 'registerAction' name to an invalid value:\", name);\n    } else if (!isFunction(callback)) {\n        console.warn(\"VelocityJS: Trying to set 'registerAction' callback to an invalid value:\", name, callback);\n    } else if (Actions[name] && !propertyIsEnumerable(Actions, name)) {\n        console.warn(\"VelocityJS: Trying to override internal 'registerAction' callback\", name);\n    } else if (internal === true) {\n        defineProperty$1(Actions, name, callback);\n    } else {\n        Actions[name] = callback;\n    }\n}\nregisterAction([\"registerAction\", registerAction], true);\n\n/**\r\n * Without this it will only un-prefix properties that have a valid \"normal\"\r\n * version.\r\n */\nvar DURATION_FAST = 200;\nvar DURATION_NORMAL = 400;\nvar DURATION_SLOW = 600;\nvar FUZZY_MS_PER_SECOND = 980;\nvar DEFAULT_CACHE = true;\nvar DEFAULT_DELAY = 0;\nvar DEFAULT_DURATION = DURATION_NORMAL;\nvar DEFAULT_EASING = \"swing\";\nvar DEFAULT_FPSLIMIT = 60;\nvar DEFAULT_LOOP = 0;\nvar DEFAULT_PROMISE = true;\nvar DEFAULT_PROMISE_REJECT_EMPTY = true;\nvar DEFAULT_QUEUE = \"\";\nvar DEFAULT_REPEAT = 0;\nvar DEFAULT_SPEED = 1;\nvar DEFAULT_SYNC = true;\nvar CLASSNAME = \"velocity-animating\";\nvar Duration = {\n  fast: DURATION_FAST,\n  normal: DURATION_NORMAL,\n  slow: DURATION_SLOW\n};\n\n// Project\n// Constants\nvar Easings = {};\n/**\r\n * Used to register a easing. This should never be called by users\r\n * directly, instead it should be called via an action:<br/>\r\n * <code>Velocity(\"registerEasing\", \"name\", VelocityEasingFn);</code>\r\n */\nfunction registerEasing(args) {\n    var name = args[0],\n        callback = args[1];\n    if (!isString(name)) {\n        console.warn(\"VelocityJS: Trying to set 'registerEasing' name to an invalid value:\", name);\n    } else if (!isFunction(callback)) {\n        console.warn(\"VelocityJS: Trying to set 'registerEasing' callback to an invalid value:\", name, callback);\n    } else if (Easings[name]) {\n        console.warn(\"VelocityJS: Trying to override 'registerEasing' callback\", name);\n    } else {\n        Easings[name] = callback;\n    }\n}\nregisterAction([\"registerEasing\", registerEasing], true);\n/**\r\n * Linear easing, used for sequence parts that don't have an actual easing\r\n * function.\r\n */\nfunction linearEasing(percentComplete, startValue, endValue, property) {\n    return startValue + percentComplete * (endValue - startValue);\n}\n/**\r\n * Swing is the default for jQuery and Velocity.\r\n */\nfunction swingEasing(percentComplete, startValue, endValue) {\n    return startValue + (0.5 - Math.cos(percentComplete * Math.PI) / 2) * (endValue - startValue);\n}\n/**\r\n * A less exaggerated version of easeInOutElastic.\r\n */\nfunction springEasing(percentComplete, startValue, endValue) {\n    return startValue + (1 - Math.cos(percentComplete * 4.5 * Math.PI) * Math.exp(-percentComplete * 6)) * (endValue - startValue);\n}\nregisterEasing([\"linear\", linearEasing]);\nregisterEasing([\"swing\", swingEasing]);\nregisterEasing([\"spring\", springEasing]);\n\n// Project\n/**\r\n * Fix to a range of <code>0 <= num <= 1</code>.\r\n */\nfunction fixRange(num) {\n    return Math.min(Math.max(num, 0), 1);\n}\nfunction A(aA1, aA2) {\n    return 1 - 3 * aA2 + 3 * aA1;\n}\nfunction B(aA1, aA2) {\n    return 3 * aA2 - 6 * aA1;\n}\nfunction C(aA1) {\n    return 3 * aA1;\n}\nfunction calcBezier(aT, aA1, aA2) {\n    return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;\n}\nfunction getSlope(aT, aA1, aA2) {\n    return 3 * A(aA1, aA2) * aT * aT + 2 * B(aA1, aA2) * aT + C(aA1);\n}\nfunction generateBezier() {\n    var NEWTON_ITERATIONS = 4,\n        NEWTON_MIN_SLOPE = 0.001,\n        SUBDIVISION_PRECISION = 0.0000001,\n        SUBDIVISION_MAX_ITERATIONS = 10,\n        kSplineTableSize = 11,\n        kSampleStepSize = 1 / (kSplineTableSize - 1),\n        float32ArraySupported = \"Float32Array\" in window;\n    /* Must contain four args. */\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n        args[_key] = arguments[_key];\n    }\n\n    if (args.length !== 4) {\n        return;\n    }\n    /* Args must be numbers. */\n    for (var i = 0; i < 4; ++i) {\n        if (typeof args[i] !== \"number\" || isNaN(args[i]) || !isFinite(args[i])) {\n            return;\n        }\n    }\n    /* X values must be in the [0, 1] range. */\n    var mX1 = fixRange(args[0]);\n    var mY1 = args[1];\n    var mX2 = fixRange(args[2]);\n    var mY2 = args[3];\n    var mSampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);\n    function newtonRaphsonIterate(aX, aGuessT) {\n        for (var _i = 0; _i < NEWTON_ITERATIONS; ++_i) {\n            var currentSlope = getSlope(aGuessT, mX1, mX2);\n            if (currentSlope === 0) {\n                return aGuessT;\n            }\n            var currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n            aGuessT -= currentX / currentSlope;\n        }\n        return aGuessT;\n    }\n    function calcSampleValues() {\n        for (var _i2 = 0; _i2 < kSplineTableSize; ++_i2) {\n            mSampleValues[_i2] = calcBezier(_i2 * kSampleStepSize, mX1, mX2);\n        }\n    }\n    function binarySubdivide(aX, aA, aB) {\n        var currentX = void 0,\n            currentT = void 0,\n            i = 0;\n        do {\n            currentT = aA + (aB - aA) / 2;\n            currentX = calcBezier(currentT, mX1, mX2) - aX;\n            if (currentX > 0) {\n                aB = currentT;\n            } else {\n                aA = currentT;\n            }\n        } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);\n        return currentT;\n    }\n    function getTForX(aX) {\n        var lastSample = kSplineTableSize - 1;\n        var intervalStart = 0,\n            currentSample = 1;\n        for (; currentSample !== lastSample && mSampleValues[currentSample] <= aX; ++currentSample) {\n            intervalStart += kSampleStepSize;\n        }\n        --currentSample;\n        var dist = (aX - mSampleValues[currentSample]) / (mSampleValues[currentSample + 1] - mSampleValues[currentSample]),\n            guessForT = intervalStart + dist * kSampleStepSize,\n            initialSlope = getSlope(guessForT, mX1, mX2);\n        if (initialSlope >= NEWTON_MIN_SLOPE) {\n            return newtonRaphsonIterate(aX, guessForT);\n        } else if (initialSlope === 0) {\n            return guessForT;\n        } else {\n            return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize);\n        }\n    }\n    var precomputed = false;\n    function precompute() {\n        precomputed = true;\n        if (mX1 !== mY1 || mX2 !== mY2) {\n            calcSampleValues();\n        }\n    }\n    var str = \"generateBezier(\" + [mX1, mY1, mX2, mY2] + \")\",\n        f = function f(percentComplete, startValue, endValue, property) {\n        if (!precomputed) {\n            precompute();\n        }\n        if (percentComplete === 0) {\n            return startValue;\n        }\n        if (percentComplete === 1) {\n            return endValue;\n        }\n        if (mX1 === mY1 && mX2 === mY2) {\n            return startValue + percentComplete * (endValue - startValue);\n        }\n        return startValue + calcBezier(getTForX(percentComplete), mY1, mY2) * (endValue - startValue);\n    };\n    f.getControlPoints = function () {\n        return [{ x: mX1, y: mY1 }, { x: mX2, y: mY2 }];\n    };\n    f.toString = function () {\n        return str;\n    };\n    return f;\n}\n/* Common easings */\nvar easeIn = generateBezier(0.42, 0, 1, 1),\n    easeOut = generateBezier(0, 0, 0.58, 1),\n    easeInOut = generateBezier(0.42, 0, 0.58, 1);\nregisterEasing([\"ease\", generateBezier(0.25, 0.1, 0.25, 1)]);\nregisterEasing([\"easeIn\", easeIn]);\nregisterEasing([\"ease-in\", easeIn]);\nregisterEasing([\"easeOut\", easeOut]);\nregisterEasing([\"ease-out\", easeOut]);\nregisterEasing([\"easeInOut\", easeInOut]);\nregisterEasing([\"ease-in-out\", easeInOut]);\nregisterEasing([\"easeInSine\", generateBezier(0.47, 0, 0.745, 0.715)]);\nregisterEasing([\"easeOutSine\", generateBezier(0.39, 0.575, 0.565, 1)]);\nregisterEasing([\"easeInOutSine\", generateBezier(0.445, 0.05, 0.55, 0.95)]);\nregisterEasing([\"easeInQuad\", generateBezier(0.55, 0.085, 0.68, 0.53)]);\nregisterEasing([\"easeOutQuad\", generateBezier(0.25, 0.46, 0.45, 0.94)]);\nregisterEasing([\"easeInOutQuad\", generateBezier(0.455, 0.03, 0.515, 0.955)]);\nregisterEasing([\"easeInCubic\", generateBezier(0.55, 0.055, 0.675, 0.19)]);\nregisterEasing([\"easeOutCubic\", generateBezier(0.215, 0.61, 0.355, 1)]);\nregisterEasing([\"easeInOutCubic\", generateBezier(0.645, 0.045, 0.355, 1)]);\nregisterEasing([\"easeInQuart\", generateBezier(0.895, 0.03, 0.685, 0.22)]);\nregisterEasing([\"easeOutQuart\", generateBezier(0.165, 0.84, 0.44, 1)]);\nregisterEasing([\"easeInOutQuart\", generateBezier(0.77, 0, 0.175, 1)]);\nregisterEasing([\"easeInQuint\", generateBezier(0.755, 0.05, 0.855, 0.06)]);\nregisterEasing([\"easeOutQuint\", generateBezier(0.23, 1, 0.32, 1)]);\nregisterEasing([\"easeInOutQuint\", generateBezier(0.86, 0, 0.07, 1)]);\nregisterEasing([\"easeInExpo\", generateBezier(0.95, 0.05, 0.795, 0.035)]);\nregisterEasing([\"easeOutExpo\", generateBezier(0.19, 1, 0.22, 1)]);\nregisterEasing([\"easeInOutExpo\", generateBezier(1, 0, 0, 1)]);\nregisterEasing([\"easeInCirc\", generateBezier(0.6, 0.04, 0.98, 0.335)]);\nregisterEasing([\"easeOutCirc\", generateBezier(0.075, 0.82, 0.165, 1)]);\nregisterEasing([\"easeInOutCirc\", generateBezier(0.785, 0.135, 0.15, 0.86)]);\n\n/* Runge-Kutta spring physics function generator. Adapted from Framer.js, copyright Koen Bok. MIT License: http://en.wikipedia.org/wiki/MIT_License */\n/* Given a tension, friction, and duration, a simulation at 60FPS will first run without a defined duration in order to calculate the full path. A second pass\r\n then adjusts the time delta -- using the relation between actual time and duration -- to calculate the path for the duration-constrained animation. */\nfunction springAccelerationForState(state) {\n    return -state.tension * state.x - state.friction * state.v;\n}\nfunction springEvaluateStateWithDerivative(initialState, dt, derivative) {\n    var state = {\n        x: initialState.x + derivative.dx * dt,\n        v: initialState.v + derivative.dv * dt,\n        tension: initialState.tension,\n        friction: initialState.friction\n    };\n    return {\n        dx: state.v,\n        dv: springAccelerationForState(state)\n    };\n}\nfunction springIntegrateState(state, dt) {\n    var a = {\n        dx: state.v,\n        dv: springAccelerationForState(state)\n    },\n        b = springEvaluateStateWithDerivative(state, dt * 0.5, a),\n        c = springEvaluateStateWithDerivative(state, dt * 0.5, b),\n        d = springEvaluateStateWithDerivative(state, dt, c),\n        dxdt = 1 / 6 * (a.dx + 2 * (b.dx + c.dx) + d.dx),\n        dvdt = 1 / 6 * (a.dv + 2 * (b.dv + c.dv) + d.dv);\n    state.x = state.x + dxdt * dt;\n    state.v = state.v + dvdt * dt;\n    return state;\n}\nfunction generateSpringRK4(tension, friction, duration) {\n    var initState = {\n        x: -1,\n        v: 0,\n        tension: parseFloat(tension) || 500,\n        friction: parseFloat(friction) || 20\n    },\n        path = [0],\n        tolerance = 1 / 10000,\n        DT = 16 / 1000,\n        haveDuration = duration != null; // deliberate \"==\", as undefined == null != 0\n    var timeLapsed = 0,\n        dt = void 0,\n        lastState = void 0;\n    /* Calculate the actual time it takes for this animation to complete with the provided conditions. */\n    if (haveDuration) {\n        /* Run the simulation without a duration. */\n        timeLapsed = generateSpringRK4(initState.tension, initState.friction);\n        /* Compute the adjusted time delta. */\n        dt = timeLapsed / duration * DT;\n    } else {\n        dt = DT;\n    }\n    while (true) {\n        /* Next/step function .*/\n        lastState = springIntegrateState(lastState || initState, dt);\n        /* Store the position. */\n        path.push(1 + lastState.x);\n        timeLapsed += 16;\n        /* If the change threshold is reached, break. */\n        if (!(Math.abs(lastState.x) > tolerance && Math.abs(lastState.v) > tolerance)) {\n            break;\n        }\n    }\n    /* If duration is not defined, return the actual time required for completing this animation. Otherwise, return a closure that holds the\r\n     computed path and returns a snapshot of the position according to a given percentComplete. */\n    return !haveDuration ? timeLapsed : function (percentComplete, startValue, endValue) {\n        if (percentComplete === 0) {\n            return startValue;\n        }\n        if (percentComplete === 1) {\n            return endValue;\n        }\n        return startValue + path[Math.floor(percentComplete * (path.length - 1))] * (endValue - startValue);\n    };\n}\n\n// Constants\nvar cache = {};\nfunction generateStep(steps) {\n    var fn = cache[steps];\n    if (fn) {\n        return fn;\n    }\n    return cache[steps] = function (percentComplete, startValue, endValue) {\n        if (percentComplete === 0) {\n            return startValue;\n        }\n        if (percentComplete === 1) {\n            return endValue;\n        }\n        return startValue + Math.round(percentComplete * steps) * (1 / steps) * (endValue - startValue);\n    };\n}\n\n// Project\n/**\r\n * Parse a duration value and return an ms number. Optionally return a\r\n * default value if the number is not valid.\r\n */\nfunction parseDuration(duration, def) {\n    if (isNumber(duration)) {\n        return duration;\n    }\n    if (isString(duration)) {\n        return Duration[duration.toLowerCase()] || parseFloat(duration.replace(\"ms\", \"\").replace(\"s\", \"000\"));\n    }\n    return def == null ? undefined : parseDuration(def);\n}\n/**\r\n * Validate a <code>cache</code> option.\r\n */\nfunction validateCache(value) {\n    if (isBoolean(value)) {\n        return value;\n    }\n    if (value != null) {\n        console.warn(\"VelocityJS: Trying to set 'cache' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>begin</code> option.\r\n */\nfunction validateBegin(value) {\n    if (isFunction(value)) {\n        return value;\n    }\n    if (value != null) {\n        console.warn(\"VelocityJS: Trying to set 'begin' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>complete</code> option.\r\n */\nfunction validateComplete(value, noError) {\n    if (isFunction(value)) {\n        return value;\n    }\n    if (value != null && !noError) {\n        console.warn(\"VelocityJS: Trying to set 'complete' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>delay</code> option.\r\n */\nfunction validateDelay(value) {\n    var parsed = parseDuration(value);\n    if (!isNaN(parsed)) {\n        return parsed;\n    }\n    if (value != null) {\n        console.error(\"VelocityJS: Trying to set 'delay' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>duration</code> option.\r\n */\nfunction validateDuration(value, noError) {\n    var parsed = parseDuration(value);\n    if (!isNaN(parsed) && parsed >= 0) {\n        return parsed;\n    }\n    if (value != null && !noError) {\n        console.error(\"VelocityJS: Trying to set 'duration' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>easing</code> option.\r\n */\nfunction validateEasing(value, duration, noError) {\n    if (isString(value)) {\n        // Named easing\n        return Easings[value];\n    }\n    if (isFunction(value)) {\n        return value;\n    }\n    // TODO: We should only do these if the correct function exists - don't force loading.\n    if (Array.isArray(value)) {\n        if (value.length === 1) {\n            // Steps\n            return generateStep(value[0]);\n        }\n        if (value.length === 2) {\n            // springRK4 must be passed the animation's duration.\n            // Note: If the springRK4 array contains non-numbers,\n            // generateSpringRK4() returns an easing function generated with\n            // default tension and friction values.\n            return generateSpringRK4(value[0], value[1], duration);\n        }\n        if (value.length === 4) {\n            // Note: If the bezier array contains non-numbers, generateBezier()\n            // returns undefined.\n            return generateBezier.apply(null, value) || false;\n        }\n    }\n    if (value != null && !noError) {\n        console.error(\"VelocityJS: Trying to set 'easing' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>fpsLimit</code> option.\r\n */\nfunction validateFpsLimit(value) {\n    if (value === false) {\n        return 0;\n    } else {\n        var parsed = parseInt(value, 10);\n        if (!isNaN(parsed) && parsed >= 0) {\n            return Math.min(parsed, 60);\n        }\n    }\n    if (value != null) {\n        console.warn(\"VelocityJS: Trying to set 'fpsLimit' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>loop</code> option.\r\n */\nfunction validateLoop(value) {\n    switch (value) {\n        case false:\n            return 0;\n        case true:\n            return true;\n        default:\n            var parsed = parseInt(value, 10);\n            if (!isNaN(parsed) && parsed >= 0) {\n                return parsed;\n            }\n            break;\n    }\n    if (value != null) {\n        console.warn(\"VelocityJS: Trying to set 'loop' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>progress</code> option.\r\n */\nfunction validateProgress(value) {\n    if (isFunction(value)) {\n        return value;\n    }\n    if (value != null) {\n        console.warn(\"VelocityJS: Trying to set 'progress' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>promise</code> option.\r\n */\nfunction validatePromise(value) {\n    if (isBoolean(value)) {\n        return value;\n    }\n    if (value != null) {\n        console.warn(\"VelocityJS: Trying to set 'promise' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>promiseRejectEmpty</code> option.\r\n */\nfunction validatePromiseRejectEmpty(value) {\n    if (isBoolean(value)) {\n        return value;\n    }\n    if (value != null) {\n        console.warn(\"VelocityJS: Trying to set 'promiseRejectEmpty' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>queue</code> option.\r\n */\nfunction validateQueue(value, noError) {\n    if (value === false || isString(value)) {\n        return value;\n    }\n    if (value != null && !noError) {\n        console.warn(\"VelocityJS: Trying to set 'queue' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>repeat</code> option.\r\n */\nfunction validateRepeat(value) {\n    switch (value) {\n        case false:\n            return 0;\n        case true:\n            return true;\n        default:\n            var parsed = parseInt(value, 10);\n            if (!isNaN(parsed) && parsed >= 0) {\n                return parsed;\n            }\n            break;\n    }\n    if (value != null) {\n        console.warn(\"VelocityJS: Trying to set 'repeat' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>speed</code> option.\r\n */\nfunction validateSpeed(value) {\n    if (isNumber(value)) {\n        return value;\n    }\n    if (value != null) {\n        console.error(\"VelocityJS: Trying to set 'speed' to an invalid value:\", value);\n    }\n}\n/**\r\n * Validate a <code>sync</code> option.\r\n */\nfunction validateSync(value) {\n    if (isBoolean(value)) {\n        return value;\n    }\n    if (value != null) {\n        console.error(\"VelocityJS: Trying to set 'sync' to an invalid value:\", value);\n    }\n}\n\n// Project\n// NOTE: Add the variable here, then add the default state in \"reset\" below.\nvar cache$1 = void 0,\n    begin = void 0,\n    complete = void 0,\n    delay = void 0,\n    duration = void 0,\n    easing = void 0,\n    fpsLimit = void 0,\n    loop = void 0,\n    mobileHA = void 0,\n    minFrameTime = void 0,\n    promise = void 0,\n    promiseRejectEmpty = void 0,\n    queue = void 0,\n    repeat = void 0,\n    speed = void 0,\n    sync = void 0;\nvar defaults$1 = function () {\n    function defaults$$1() {\n        classCallCheck(this, defaults$$1);\n    }\n\n    createClass(defaults$$1, null, [{\n        key: \"reset\",\n        value: function reset() {\n            cache$1 = DEFAULT_CACHE;\n            begin = undefined;\n            complete = undefined;\n            delay = DEFAULT_DELAY;\n            duration = DEFAULT_DURATION;\n            easing = validateEasing(DEFAULT_EASING, DEFAULT_DURATION);\n            fpsLimit = DEFAULT_FPSLIMIT;\n            loop = DEFAULT_LOOP;\n            minFrameTime = FUZZY_MS_PER_SECOND / DEFAULT_FPSLIMIT;\n            promise = DEFAULT_PROMISE;\n            promiseRejectEmpty = DEFAULT_PROMISE_REJECT_EMPTY;\n            queue = DEFAULT_QUEUE;\n            repeat = DEFAULT_REPEAT;\n            speed = DEFAULT_SPEED;\n            sync = DEFAULT_SYNC;\n        }\n    }, {\n        key: \"cache\",\n        get: function get$$1() {\n            return cache$1;\n        },\n        set: function set$$1(value) {\n            value = validateCache(value);\n            if (value !== undefined) {\n                cache$1 = value;\n            }\n        }\n    }, {\n        key: \"begin\",\n        get: function get$$1() {\n            return begin;\n        },\n        set: function set$$1(value) {\n            value = validateBegin(value);\n            if (value !== undefined) {\n                begin = value;\n            }\n        }\n    }, {\n        key: \"complete\",\n        get: function get$$1() {\n            return complete;\n        },\n        set: function set$$1(value) {\n            value = validateComplete(value);\n            if (value !== undefined) {\n                complete = value;\n            }\n        }\n    }, {\n        key: \"delay\",\n        get: function get$$1() {\n            return delay;\n        },\n        set: function set$$1(value) {\n            value = validateDelay(value);\n            if (value !== undefined) {\n                delay = value;\n            }\n        }\n    }, {\n        key: \"duration\",\n        get: function get$$1() {\n            return duration;\n        },\n        set: function set$$1(value) {\n            value = validateDuration(value);\n            if (value !== undefined) {\n                duration = value;\n            }\n        }\n    }, {\n        key: \"easing\",\n        get: function get$$1() {\n            return easing;\n        },\n        set: function set$$1(value) {\n            value = validateEasing(value, duration);\n            if (value !== undefined) {\n                easing = value;\n            }\n        }\n    }, {\n        key: \"fpsLimit\",\n        get: function get$$1() {\n            return fpsLimit;\n        },\n        set: function set$$1(value) {\n            value = validateFpsLimit(value);\n            if (value !== undefined) {\n                fpsLimit = value;\n                minFrameTime = FUZZY_MS_PER_SECOND / value;\n            }\n        }\n    }, {\n        key: \"loop\",\n        get: function get$$1() {\n            return loop;\n        },\n        set: function set$$1(value) {\n            value = validateLoop(value);\n            if (value !== undefined) {\n                loop = value;\n            }\n        }\n    }, {\n        key: \"mobileHA\",\n        get: function get$$1() {\n            return mobileHA;\n        },\n        set: function set$$1(value) {\n            if (isBoolean(value)) {\n                mobileHA = value;\n            }\n        }\n    }, {\n        key: \"minFrameTime\",\n        get: function get$$1() {\n            return minFrameTime;\n        }\n    }, {\n        key: \"promise\",\n        get: function get$$1() {\n            return promise;\n        },\n        set: function set$$1(value) {\n            value = validatePromise(value);\n            if (value !== undefined) {\n                promise = value;\n            }\n        }\n    }, {\n        key: \"promiseRejectEmpty\",\n        get: function get$$1() {\n            return promiseRejectEmpty;\n        },\n        set: function set$$1(value) {\n            value = validatePromiseRejectEmpty(value);\n            if (value !== undefined) {\n                promiseRejectEmpty = value;\n            }\n        }\n    }, {\n        key: \"queue\",\n        get: function get$$1() {\n            return queue;\n        },\n        set: function set$$1(value) {\n            value = validateQueue(value);\n            if (value !== undefined) {\n                queue = value;\n            }\n        }\n    }, {\n        key: \"repeat\",\n        get: function get$$1() {\n            return repeat;\n        },\n        set: function set$$1(value) {\n            value = validateRepeat(value);\n            if (value !== undefined) {\n                repeat = value;\n            }\n        }\n    }, {\n        key: \"repeatAgain\",\n        get: function get$$1() {\n            return repeat;\n        }\n    }, {\n        key: \"speed\",\n        get: function get$$1() {\n            return speed;\n        },\n        set: function set$$1(value) {\n            value = validateSpeed(value);\n            if (value !== undefined) {\n                speed = value;\n            }\n        }\n    }, {\n        key: \"sync\",\n        get: function get$$1() {\n            return sync;\n        },\n        set: function set$$1(value) {\n            value = validateSync(value);\n            if (value !== undefined) {\n                sync = value;\n            }\n        }\n    }]);\n    return defaults$$1;\n}();\nObject.freeze(defaults$1);\n// Reset to our default values, currently everything is undefined.\ndefaults$1.reset();\n\n/**\r\n * The highest type index for finding the best normalization for a property.\r\n */\n/**\r\n * Unlike \"actions\", normalizations can always be replaced by users.\r\n */\nvar Normalizations = [];\n/**\r\n * Store a cross-reference to units to be added to specific normalization\r\n * functions if the user supplies a unit-less number.\r\n *\r\n * This is pretty much confined to adding \"px\" to several css properties.\r\n */\nvar NormalizationUnits = {};\n/**\r\n * Any normalisations that should never be cached are listed here.\r\n * Faster than an array - https://jsperf.com/array-includes-and-find-methods-vs-set-has\r\n */\nvar NoCacheNormalizations = new Set();\n/**\r\n * An array of classes used for the per-class normalizations. This\r\n * translates into a bitwise enum for quick cross-reference, and so that\r\n * the element doesn't need multiple <code>instanceof</code> calls every\r\n * frame.\r\n */\nvar constructors = [];\n/**\r\n * A cache of the various constructors we've found and mapping to their real\r\n * name - saves expensive lookups.\r\n */\nvar constructorCache = new Map();\n\n// Project\n// Constants\nvar dataName = \"velocityData\";\n/**\r\n * Get (and create) the internal data store for an element.\r\n */\nfunction Data(element) {\n    // Use a string member so Uglify doesn't mangle it.\n    var data = element[dataName];\n    if (data) {\n        return data;\n    }\n    var window = element.ownerDocument.defaultView;\n    var types = 0;\n    for (var index = 0; index < constructors.length; index++) {\n        var _constructor = constructors[index];\n        if (isString(_constructor)) {\n            if (element instanceof window[_constructor]) {\n                types |= 1 << index; // tslint:disable-line:no-bitwise\n            }\n        } else if (element instanceof _constructor) {\n            types |= 1 << index; // tslint:disable-line:no-bitwise\n        }\n    }\n    // Use an intermediate object so it errors on incorrect data.\n    var newData = {\n        types: types,\n        count: 0,\n        computedStyle: null,\n        cache: {},\n        queueList: {},\n        lastAnimationList: {},\n        lastFinishList: {},\n        window: window\n    };\n    Object.defineProperty(element, dataName, {\n        value: newData\n    });\n    return newData;\n}\n\n// Constants\nvar isClient = window && window === window.window,\n    windowScrollAnchor = isClient && window.pageYOffset !== undefined;\nvar State = {\n    isClient: isClient,\n    isMobile: isClient && /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent),\n    isGingerbread: isClient && /Android 2\\.3\\.[3-7]/i.test(navigator.userAgent),\n    prefixElement: isClient && document.createElement(\"div\"),\n    windowScrollAnchor: windowScrollAnchor,\n    scrollAnchor: windowScrollAnchor ? window : !isClient || document.documentElement || document.body.parentNode || document.body,\n    scrollPropertyLeft: windowScrollAnchor ? \"pageXOffset\" : \"scrollLeft\",\n    scrollPropertyTop: windowScrollAnchor ? \"pageYOffset\" : \"scrollTop\",\n    className: CLASSNAME,\n    isTicking: false,\n    first: undefined,\n    last: undefined,\n    firstNew: undefined\n};\n\n// Project\n/**\r\n * Simple queue management. Un-named queue is directly within the element data,\r\n * named queue is within an object within it.\r\n */\nfunction animate(animation) {\n    var prev = State.last;\n    animation._prev = prev;\n    animation._next = undefined;\n    if (prev) {\n        prev._next = animation;\n    } else {\n        State.first = animation;\n    }\n    State.last = animation;\n    if (!State.firstNew) {\n        State.firstNew = animation;\n    }\n    var element = animation.element,\n        data = Data(element);\n    if (!data.count++) {\n        ////////////////////////\n        // Feature: Classname //\n        ////////////////////////\n        addClass(element, State.className);\n    }\n}\n/**\r\n * Add an item to an animation queue.\r\n */\nfunction queue$1(element, animation, queueName) {\n    var data = Data(element);\n    if (queueName !== false) {\n        // Store the last animation added so we can use it for the\n        // beginning of the next one.\n        data.lastAnimationList[queueName] = animation;\n    }\n    if (queueName === false) {\n        animate(animation);\n    } else {\n        if (!isString(queueName)) {\n            queueName = \"\";\n        }\n        var last = data.queueList[queueName];\n        if (!last) {\n            if (last === null) {\n                data.queueList[queueName] = animation;\n            } else {\n                data.queueList[queueName] = null;\n                animate(animation);\n            }\n        } else {\n            while (last._next) {\n                last = last._next;\n            }\n            last._next = animation;\n            animation._prev = last;\n        }\n    }\n}\n/**\r\n * Start the next animation on this element's queue (named or default).\r\n *\r\n * @returns the next animation that is starting.\r\n */\nfunction dequeue(element, queueName, skip) {\n    if (queueName !== false) {\n        if (!isString(queueName)) {\n            queueName = \"\";\n        }\n        var data = Data(element),\n            animation = data.queueList[queueName];\n        if (animation) {\n            data.queueList[queueName] = animation._next || null;\n            if (!skip) {\n                animate(animation);\n            }\n        } else if (animation === null) {\n            delete data.queueList[queueName];\n        }\n        return animation;\n    }\n}\n/**\r\n * Remove an animation from the active animation list. If it has a queue set\r\n * then remember it as the last animation for that queue, and free the one\r\n * that was previously there. If the animation list is completely empty then\r\n * mark us as finished.\r\n */\nfunction freeAnimationCall(animation) {\n    var next = animation._next,\n        prev = animation._prev,\n        queueName = animation.queue == null ? animation.options.queue : animation.queue;\n    if (State.firstNew === animation) {\n        State.firstNew = next;\n    }\n    if (State.first === animation) {\n        State.first = next;\n    } else if (prev) {\n        prev._next = next;\n    }\n    if (State.last === animation) {\n        State.last = prev;\n    } else if (next) {\n        next._prev = prev;\n    }\n    if (queueName) {\n        var data = Data(animation.element);\n        if (data) {\n            animation._next = animation._prev = undefined;\n        }\n    }\n}\n\nvar SequencesObject = {};\n\n// Project\n/**\r\n * Call the complete method of an animation in a separate function so it can\r\n * benefit from JIT compiling while still having a try/catch block.\r\n */\nfunction callComplete(activeCall) {\n    var callback = activeCall.complete || activeCall.options.complete;\n    if (callback) {\n        try {\n            var elements = activeCall.elements;\n            callback.call(elements, elements, activeCall);\n        } catch (error) {\n            setTimeout(function () {\n                throw error;\n            }, 1);\n        }\n    }\n}\n/**\r\n * Complete an animation. This might involve restarting (for loop or repeat\r\n * options). Once it is finished we also check for any callbacks or Promises\r\n * that need updating.\r\n */\nfunction completeCall(activeCall) {\n    // TODO: Check if it's not been completed already\n    var options = activeCall.options,\n        queue = getValue(activeCall.queue, options.queue),\n        isLoop = getValue(activeCall.loop, options.loop, defaults$1.loop),\n        isRepeat = getValue(activeCall.repeat, options.repeat, defaults$1.repeat),\n        isStopped = activeCall._flags & 8 /* STOPPED */; // tslint:disable-line:no-bitwise\n    if (!isStopped && (isLoop || isRepeat)) {\n        ////////////////////\n        // Option: Loop   //\n        // Option: Repeat //\n        ////////////////////\n        if (isRepeat && isRepeat !== true) {\n            activeCall.repeat = isRepeat - 1;\n        } else if (isLoop && isLoop !== true) {\n            activeCall.loop = isLoop - 1;\n            activeCall.repeat = getValue(activeCall.repeatAgain, options.repeatAgain, defaults$1.repeatAgain);\n        }\n        if (isLoop) {\n            activeCall._flags ^= 64 /* REVERSE */; // tslint:disable-line:no-bitwise\n        }\n        if (queue !== false) {\n            // Can't be called when stopped so no need for an extra check.\n            Data(activeCall.element).lastFinishList[queue] = activeCall.timeStart + getValue(activeCall.duration, options.duration, defaults$1.duration);\n        }\n        activeCall.timeStart = activeCall.ellapsedTime = activeCall.percentComplete = 0;\n        activeCall._flags &= ~4 /* STARTED */; // tslint:disable-line:no-bitwise\n    } else {\n        var element = activeCall.element,\n            data = Data(element);\n        if (! --data.count && !isStopped) {\n            ////////////////////////\n            // Feature: Classname //\n            ////////////////////////\n            removeClass(element, State.className);\n        }\n        //////////////////////\n        // Option: Complete //\n        //////////////////////\n        // If this is the last animation in this list then we can check for\n        // and complete calls or Promises.\n        // TODO: When deleting an element we need to adjust these values.\n        if (options && ++options._completed === options._total) {\n            if (!isStopped && options.complete) {\n                // We don't call the complete if the animation is stopped,\n                // and we clear the key to prevent it being called again.\n                callComplete(activeCall);\n                options.complete = null;\n            }\n            var resolver = options._resolver;\n            if (resolver) {\n                // Fulfil the Promise\n                resolver(activeCall.elements);\n                delete options._resolver;\n            }\n        }\n        ///////////////////\n        // Option: Queue //\n        ///////////////////\n        if (queue !== false) {\n            // We only do clever things with queues...\n            if (!isStopped) {\n                // If we're not stopping an animation, we need to remember\n                // what time it finished so that the next animation in\n                // sequence gets the correct start time.\n                data.lastFinishList[queue] = activeCall.timeStart + getValue(activeCall.duration, options.duration, defaults$1.duration);\n            }\n            // Start the next animation in sequence, or delete the queue if\n            // this was the last one.\n            dequeue(element, queue);\n        }\n        // Cleanup any pointers, and remember the last animation etc.\n        freeAnimationCall(activeCall);\n    }\n}\n\n// Project\n/**\r\n * Used to register a normalization. This should never be called by users\r\n * directly, instead it should be called via an action:<br/>\r\n * <code>Velocity(\"registerNormalization\", \"Element\", \"name\", VelocityNormalizationsFn[, false]);</code>\r\n *\r\n * The second argument is the class of the animatable object. If this is passed\r\n * as a class name (ie, `\"Element\"` -> `window[\"Element\"]`) then this will work\r\n * cross-iframe. If passed as an actual class (ie `Element`) then it will\r\n * attempt to find the class on the window and use that name instead. If it\r\n * can't find it then it will use the class passed, which allows for custom\r\n * animation targets, but will not work cross-iframe boundary.\r\n *\r\n * The fourth argument can be an explicit <code>false</code>, which prevents\r\n * the property from being cached. Please note that this can be dangerous\r\n * for performance!\r\n */\nfunction registerNormalization(args) {\n    var constructor = args[0],\n        name = args[1],\n        callback = args[2];\n    if (isString(constructor) && !(window[constructor] instanceof Object) || !isString(constructor) && !(constructor instanceof Object)) {\n        console.warn(\"VelocityJS: Trying to set 'registerNormalization' constructor to an invalid value:\", constructor);\n    } else if (!isString(name)) {\n        console.warn(\"VelocityJS: Trying to set 'registerNormalization' name to an invalid value:\", name);\n    } else if (!isFunction(callback)) {\n        console.warn(\"VelocityJS: Trying to set 'registerNormalization' callback to an invalid value:\", name, callback);\n    } else {\n        var index = constructors.indexOf(constructor),\n            nextArg = 3;\n        if (index < 0 && !isString(constructor)) {\n            if (constructorCache.has(constructor)) {\n                index = constructors.indexOf(constructorCache.get(constructor));\n            } else {\n                for (var property in window) {\n                    if (window[property] === constructor) {\n                        index = constructors.indexOf(property);\n                        if (index < 0) {\n                            index = constructors.push(property) - 1;\n                            Normalizations[index] = {};\n                            constructorCache.set(constructor, property);\n                        }\n                        break;\n                    }\n                }\n            }\n        }\n        if (index < 0) {\n            index = constructors.push(constructor) - 1;\n            Normalizations[index] = {};\n        }\n        Normalizations[index][name] = callback;\n        if (isString(args[nextArg])) {\n            var unit = args[nextArg++];\n            var units = NormalizationUnits[unit];\n            if (!units) {\n                units = NormalizationUnits[unit] = [];\n            }\n            units.push(callback);\n        }\n        if (args[nextArg] === false) {\n            NoCacheNormalizations.add(name);\n        }\n    }\n}\n/**\r\n * Used to check if a normalisation exists on a specific class.\r\n */\nfunction hasNormalization(args) {\n    var constructor = args[0],\n        name = args[1];\n    var index = constructors.indexOf(constructor);\n    if (index < 0 && !isString(constructor)) {\n        if (constructorCache.has(constructor)) {\n            index = constructors.indexOf(constructorCache.get(constructor));\n        } else {\n            for (var property in window) {\n                if (window[property] === constructor) {\n                    index = constructors.indexOf(property);\n                    break;\n                }\n            }\n        }\n    }\n    return index >= 0 && Normalizations[index].hasOwnProperty(name);\n}\n/**\r\n * Get the unit to add to a unitless number based on the normalization used.\r\n */\nfunction getNormalizationUnit(fn) {\n    for (var unit in NormalizationUnits) {\n        if (NormalizationUnits[unit].includes(fn)) {\n            return unit;\n        }\n    }\n    return \"\";\n}\n/**\r\n * Get the normalization for an element and propertyName combination. This\r\n * value should be cached at asking time, as it may change if the user adds\r\n * more normalizations.\r\n */\nfunction getNormalization(element, propertyName) {\n    var data = Data(element);\n    var fn = void 0;\n    for (var index = constructors.length - 1, types = data.types; !fn && index >= 0; index--) {\n        if (types & 1 << index) {\n            // tslint:disable-line:no-bitwise\n            fn = Normalizations[index][propertyName];\n        }\n    }\n    return fn;\n}\nregisterAction([\"registerNormalization\", registerNormalization]);\nregisterAction([\"hasNormalization\", hasNormalization]);\n\n// Project\n/**\r\n * The singular setPropertyValue, which routes the logic for all\r\n * normalizations.\r\n */\nfunction setPropertyValue(element, propertyName, propertyValue, fn) {\n    var noCache = NoCacheNormalizations.has(propertyName),\n        data = !noCache && Data(element);\n    if (noCache || data && data.cache[propertyName] !== propertyValue) {\n        // By setting it to undefined we force a true \"get\" later\n        if (!noCache) {\n            data.cache[propertyName] = propertyValue || undefined;\n        }\n        fn = fn || getNormalization(element, propertyName);\n        if (fn) {\n            fn(element, propertyValue);\n        }\n        if (Velocity$$1.debug >= 2) {\n            console.info(\"Set \\\"\" + propertyName + \"\\\": \\\"\" + propertyValue + \"\\\"\", element);\n        }\n    }\n}\n\n/**\r\n * Remove nested `calc(0px + *)` or `calc(* + (0px + *))` correctly.\r\n */\nfunction removeNestedCalc(value) {\n    if (value.indexOf(\"calc(\") >= 0) {\n        var tokens = value.split(/([\\(\\)])/);\n        var depth = 0;\n        for (var i = 0; i < tokens.length; i++) {\n            var token = tokens[i];\n            switch (token) {\n                case \"(\":\n                    depth++;\n                    break;\n                case \")\":\n                    depth--;\n                    break;\n                default:\n                    if (depth && token[0] === \"0\") {\n                        tokens[i] = token.replace(/^0[a-z%]+ \\+ /, \"\");\n                    }\n                    break;\n            }\n        }\n        return tokens.join(\"\").replace(/(?:calc)?\\(([0-9\\.]+[a-z%]+)\\)/g, \"$1\");\n    }\n    return value;\n}\n\n/**\r\n * Cache every camelCase match to avoid repeating lookups.\r\n */\nvar cache$2 = {};\n/**\r\n * Camelcase a property name into its JavaScript notation (e.g.\r\n * \"background-color\" ==> \"backgroundColor\"). Camelcasing is used to\r\n * normalize property names between and across calls.\r\n */\nfunction camelCase(property) {\n  var fixed = cache$2[property];\n  if (fixed) {\n    return fixed;\n  }\n  return cache$2[property] = property.replace(/-([a-z])/g, function ($, letter) {\n    return letter.toUpperCase();\n  });\n}\n\n// Constants\nvar rxColor6 = /#([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})/gi,\n    rxColor3 = /#([a-f\\d])([a-f\\d])([a-f\\d])/gi,\n    rxColorName = /(rgba?\\(\\s*)?(\\b[a-z]+\\b)/g,\n    rxRGB = /rgb(a?)\\(([^\\)]+)\\)/gi,\n    rxSpaces = /\\s+/g;\n/**\r\n * This is the list of color names -> rgb values. The object is in here so\r\n * that the actual name conversion can be in a separate file and not\r\n * included for custom builds.\r\n */\nvar ColorNames = {};\n/**\r\n * Convert a hex list to an rgba value. Designed to be used in replace.\r\n */\nfunction makeRGBA(ignore, r, g, b) {\n    return \"rgba(\" + parseInt(r, 16) + \",\" + parseInt(g, 16) + \",\" + parseInt(b, 16) + \",1)\";\n}\n/**\r\n * Replace any css colour name with its rgba() value. It is possible to use\r\n * the name within an \"rgba(blue, 0.4)\" string this way.\r\n */\nfunction fixColors(str) {\n    return str.replace(rxColor6, makeRGBA).replace(rxColor3, function ($0, r, g, b) {\n        return makeRGBA($0, r + r, g + g, b + b);\n    }).replace(rxColorName, function ($0, $1, $2) {\n        if (ColorNames[$2]) {\n            return ($1 ? $1 : \"rgba(\") + ColorNames[$2] + ($1 ? \"\" : \",1)\");\n        }\n        return $0;\n    }).replace(rxRGB, function ($0, $1, $2) {\n        return \"rgba(\" + ($2.replace(rxSpaces, \"\") + ($1 ? \"\" : \",1\")) + \")\";\n    });\n}\n\n// Project\n/**\r\n * Figure out the dimensions for this width / height based on the\r\n * potential borders and whether we care about them.\r\n */\nfunction augmentDimension(element, name, wantInner) {\n    var isBorderBox = getPropertyValue(element, \"boxSizing\").toString().toLowerCase() === \"border-box\";\n    if (isBorderBox === wantInner) {\n        // in box-sizing mode, the CSS width / height accessors already\n        // give the outerWidth / outerHeight.\n        var sides = name === \"width\" ? [\"Left\", \"Right\"] : [\"Top\", \"Bottom\"],\n            fields = [\"padding\" + sides[0], \"padding\" + sides[1], \"border\" + sides[0] + \"Width\", \"border\" + sides[1] + \"Width\"];\n        var augment = 0;\n        var _iteratorNormalCompletion = true;\n        var _didIteratorError = false;\n        var _iteratorError = undefined;\n\n        try {\n            for (var _iterator = fields[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n                var field = _step.value;\n\n                var value = parseFloat(getPropertyValue(element, field));\n                if (!isNaN(value)) {\n                    augment += value;\n                }\n            }\n        } catch (err) {\n            _didIteratorError = true;\n            _iteratorError = err;\n        } finally {\n            try {\n                if (!_iteratorNormalCompletion && _iterator.return) {\n                    _iterator.return();\n                }\n            } finally {\n                if (_didIteratorError) {\n                    throw _iteratorError;\n                }\n            }\n        }\n\n        return wantInner ? -augment : augment;\n    }\n    return 0;\n}\n\n// Project\n/**\r\n * Get the width or height of an element, pulled out as it can be used when the\r\n * in two locations so don't want to repeat it.\r\n */\nfunction getWidthHeight(element, property) {\n    return element.getBoundingClientRect()[property] + augmentDimension(element, property, true) + \"px\";\n}\n// TODO: This is still a complete mess\nfunction computePropertyValue(element, property) {\n    var data = Data(element),\n\n    // If computedStyle is cached, use it. If not then get the correct one\n    // for the element to support cross-iframe boundaries.\n    computedStyle = data.computedStyle ? data.computedStyle : data.window.getComputedStyle(element, null);\n    var computedValue = 0;\n    if (!data.computedStyle) {\n        data.computedStyle = computedStyle;\n    }\n    if (computedStyle[\"display\"] === \"none\") {\n        switch (property) {\n            case \"width\":\n            case \"height\":\n                // Browsers do not return height and width values for elements\n                // that are set to display:\"none\". Thus, we temporarily toggle\n                // display to the element type's default value.\n                setPropertyValue(element, \"display\", \"auto\");\n                computedValue = getWidthHeight(element, property);\n                setPropertyValue(element, \"display\", \"none\");\n                return String(computedValue);\n        }\n    }\n    /* IE and Firefox do not return a value for the generic borderColor -- they only return individual values for each border side's color.\r\n     Also, in all browsers, when border colors aren't all the same, a compound value is returned that Velocity isn't setup to parse.\r\n     So, as a polyfill for querying individual border side colors, we just return the top border's color and animate all borders from that value. */\n    /* TODO: There is a borderColor normalisation in legacy/ - figure out where this is needed... */\n    computedValue = computedStyle[property];\n    /* Fall back to the property's style value (if defined) when computedValue returns nothing,\r\n     which can happen when the element hasn't been painted. */\n    if (!computedValue) {\n        computedValue = element.style[property];\n    }\n    /* For top, right, bottom, and left (TRBL) values that are set to \"auto\" on elements of \"fixed\" or \"absolute\" position,\r\n     defer to jQuery for converting \"auto\" to a numeric value. (For elements with a \"static\" or \"relative\" position, \"auto\" has the same\r\n     effect as being set to 0, so no conversion is necessary.) */\n    /* An example of why numeric conversion is necessary: When an element with \"position:absolute\" has an untouched \"left\"\r\n     property, which reverts to \"auto\", left's value is 0 relative to its parent element, but is often non-zero relative\r\n     to its *containing* (not parent) element, which is the nearest \"position:relative\" ancestor or the viewport (and always the viewport in the case of \"position:fixed\"). */\n    if (computedValue === \"auto\") {\n        switch (property) {\n            case \"width\":\n            case \"height\":\n                computedValue = getWidthHeight(element, property);\n                break;\n            case \"top\":\n            case \"left\":\n\n            case \"right\":\n            case \"bottom\":\n                var position = getPropertyValue(element, \"position\");\n                if (position === \"fixed\" || position === \"absolute\") {\n                    // Note: this has no pixel unit on its returned values,\n                    // we re-add it here to conform with\n                    // computePropertyValue's behavior.\n                    computedValue = element.getBoundingClientRect[property] + \"px\";\n                    break;\n                }\n            // Deliberate fallthrough!\n            default:\n                computedValue = \"0px\";\n                break;\n        }\n    }\n    return computedValue ? String(computedValue) : \"\";\n}\n/**\r\n * Get a property value. This will grab via the cache if it exists, then\r\n * via any normalisations.\r\n */\nfunction getPropertyValue(element, propertyName, fn, skipCache) {\n    var data = Data(element);\n    var propertyValue = void 0;\n    if (NoCacheNormalizations.has(propertyName)) {\n        skipCache = true;\n    }\n    if (!skipCache && data && data.cache[propertyName] != null) {\n        propertyValue = data.cache[propertyName];\n    } else {\n        fn = fn || getNormalization(element, propertyName);\n        if (fn) {\n            propertyValue = fn(element);\n            if (data) {\n                data.cache[propertyName] = propertyValue;\n            }\n        }\n    }\n    if (Velocity$$1.debug >= 2) {\n        console.info(\"Get \\\"\" + propertyName + \"\\\": \\\"\" + propertyValue + \"\\\"\", element);\n    }\n    return propertyValue;\n}\n\n// Project\n// Constants\nvar rxHex = /^#([A-f\\d]{3}){1,2}$/i,\n    commands = {\n    function: function _function(value, element, elements, elementArrayIndex, propertyName, tween) {\n        return value.call(element, elementArrayIndex, elements.length, propertyName);\n    },\n    number: function number(value, element, elements, elementArrayIndex, propertyName, tween) {\n        return String(value) + getNormalizationUnit(tween.fn);\n    },\n    string: function string(value, element, elements, elementArrayIndex, propertyName, tween) {\n        return fixColors(value);\n    },\n    undefined: function undefined(value, element, elements, elementArrayIndex, propertyName, tween) {\n        return fixColors(getPropertyValue(element, propertyName, tween.fn) || \"\");\n    }\n};\n/**\r\n * Expand a VelocityProperty argument into a valid sparse Tween array. This\r\n * pre-allocates the array as it is then the correct size and slightly\r\n * faster to access.\r\n */\nfunction expandProperties(animation, properties) {\n    var tweens = animation.tweens = Object.create(null),\n        elements = animation.elements,\n        element = animation.element,\n        elementArrayIndex = elements.indexOf(element),\n        data = Data(element),\n        queue = getValue(animation.queue, animation.options.queue),\n        duration = getValue(animation.options.duration, defaults$1.duration);\n    for (var property in properties) {\n        if (properties.hasOwnProperty(property)) {\n            var propertyName = camelCase(property),\n                fn = getNormalization(element, propertyName);\n            var valueData = properties[property];\n            if (!fn && propertyName !== \"tween\") {\n                if (Velocity$$1.debug) {\n                    console.log(\"Skipping \\\"\" + property + \"\\\" due to a lack of browser support.\");\n                }\n                continue;\n            }\n            if (valueData == null) {\n                if (Velocity$$1.debug) {\n                    console.log(\"Skipping \\\"\" + property + \"\\\" due to no value supplied.\");\n                }\n                continue;\n            }\n            var tween = tweens[propertyName] = {};\n            var endValue = void 0,\n                startValue = void 0;\n            tween.fn = fn;\n            if (isFunction(valueData)) {\n                // If we have a function as the main argument then resolve\n                // it first, in case it returns an array that needs to be\n                // split.\n                valueData = valueData.call(element, elementArrayIndex, elements.length, elements);\n            }\n            if (Array.isArray(valueData)) {\n                // valueData is an array in the form of\n                // [ endValue, [, easing] [, startValue] ]\n                var arr1 = valueData[1],\n                    arr2 = valueData[2];\n                endValue = valueData[0];\n                if (isString(arr1) && (/^[\\d-]/.test(arr1) || rxHex.test(arr1)) || isFunction(arr1) || isNumber(arr1)) {\n                    startValue = arr1;\n                } else if (isString(arr1) && Easings[arr1] || Array.isArray(arr1)) {\n                    tween.easing = validateEasing(arr1, duration);\n                    startValue = arr2;\n                } else {\n                    startValue = arr1 || arr2;\n                }\n            } else {\n                endValue = valueData;\n            }\n            tween.end = commands[typeof endValue === \"undefined\" ? \"undefined\" : _typeof(endValue)](endValue, element, elements, elementArrayIndex, propertyName, tween);\n            if (startValue != null || queue === false || data.queueList[queue] === undefined) {\n                tween.start = commands[typeof startValue === \"undefined\" ? \"undefined\" : _typeof(startValue)](startValue, element, elements, elementArrayIndex, propertyName, tween);\n                explodeTween(propertyName, tween, duration);\n            }\n        }\n    }\n}\n// TODO: Needs a better match for \"translate3d\" etc - a number must be preceded by some form of break...\nvar rxToken = /((?:[+\\-*/]=)?(?:[+-]?\\d*\\.\\d+|[+-]?\\d+)[a-z%]*|(?:.(?!$|[+-]?\\d|[+\\-*/]=[+-]?\\d))+.|.)/g,\n    rxNumber = /^([+\\-*/]=)?([+-]?\\d*\\.\\d+|[+-]?\\d+)(.*)$/;\n/**\r\n * Find a pattern between multiple strings, return a VelocitySequence with\r\n * the pattern and the tokenised values.\r\n *\r\n * If number then animate.\r\n * If a string then must match.\r\n * If units then convert between them by wrapping in a calc().\r\n * - If already in a calc then nest another layer.\r\n * If in an rgba() then the first three numbers are rounded.\r\n */\nfunction findPattern(parts, propertyName) {\n    var partsLength = parts.length,\n        tokens = [],\n        indexes = [];\n    var numbers = void 0;\n    // First tokenise the strings - these have all values, we will pull\n    // numbers later.\n    for (var part = 0; part < partsLength; part++) {\n        if (isString(parts[part])) {\n            if (parts[part] === \"\") {\n                tokens[part] = [\"\"];\n            } else {\n                tokens[part] = cloneArray(parts[part].match(rxToken));\n            }\n            indexes[part] = 0;\n            // If it matches more than one thing then we've got a number.\n            numbers = numbers || tokens[part].length > 1;\n            //console.log(`tokens:`, parts[part], tokens[part])\n        } else {\n            // We have an incomplete lineup, it will get tried again later...\n            return;\n        }\n    }\n    var sequence = [],\n        pattern = sequence.pattern = [],\n        addString = function addString(text) {\n        if (isString(pattern[pattern.length - 1])) {\n            pattern[pattern.length - 1] += text;\n        } else if (text) {\n            pattern.push(text);\n            for (var _part = 0; _part < partsLength; _part++) {\n                sequence[_part].push(null);\n            }\n        }\n    },\n        returnStringType = function returnStringType() {\n        if (numbers || pattern.length > 1) {\n            //console.error(`Velocity: Trying to pattern match mis-matched strings \"${propertyName}\":`, parts);\n            return;\n        }\n        var isDisplay = propertyName === \"display\",\n            isVisibility = propertyName === \"visibility\";\n        for (var _part2 = 0; _part2 < partsLength; _part2++) {\n            var value = parts[_part2];\n            sequence[_part2][0] = value;\n            // Don't care about duration...\n            sequence[_part2].easing = validateEasing(isDisplay && value === \"none\" || isVisibility && value === \"hidden\" || !isDisplay && !isVisibility ? \"at-end\" : \"at-start\", 400);\n        }\n        pattern[0] = false;\n        return sequence;\n    };\n    var more = true;\n    for (var _part3 = 0; _part3 < partsLength; _part3++) {\n        sequence[_part3] = [];\n    }\n    while (more) {\n        var bits = [],\n            units = [];\n        var text = void 0,\n            isUnitless = false,\n            hasNumbers = false;\n        for (var _part4 = 0; _part4 < partsLength; _part4++) {\n            var index = indexes[_part4]++,\n                token = tokens[_part4][index];\n            if (token) {\n                var num = token.match(rxNumber); // [ignore, change, number, unit]\n                if (num) {\n                    // It's a number, possibly with a += change and unit.\n                    if (text) {\n                        return returnStringType();\n                    }\n                    var digits = parseFloat(num[2]),\n                        unit = num[3],\n                        change = num[1] ? num[1][0] + unit : undefined,\n                        changeOrUnit = change || unit;\n                    if (digits && !units.includes(changeOrUnit)) {\n                        // Will be an empty string at the least.\n                        units.push(changeOrUnit);\n                    }\n                    if (!unit) {\n                        if (digits) {\n                            hasNumbers = true;\n                        } else {\n                            isUnitless = true;\n                        }\n                    }\n                    bits[_part4] = change ? [digits, changeOrUnit, true] : [digits, changeOrUnit];\n                } else if (bits.length) {\n                    return returnStringType();\n                } else {\n                    // It's a string.\n                    if (!text) {\n                        text = token;\n                    } else if (text !== token) {\n                        return returnStringType();\n                    }\n                }\n            } else if (!_part4) {\n                for (; _part4 < partsLength; _part4++) {\n                    var index2 = indexes[_part4]++;\n                    if (tokens[_part4][index2]) {\n                        return returnStringType();\n                    }\n                }\n                // IMPORTANT: This is the exit point.\n                more = false;\n                break;\n            } else {\n                // Different\n                return;\n            }\n        }\n        if (text) {\n            addString(text);\n        } else if (units.length) {\n            if (units.length === 2 && isUnitless && !hasNumbers) {\n                // If we only have two units, and one is empty, and it's only empty on \"0\", then treat us as having one unit\n                units.splice(units[0] ? 1 : 0, 1);\n            }\n            if (units.length === 1) {\n                // All the same units, so append number then unit.\n                var _unit = units[0],\n                    firstLetter = _unit[0];\n                switch (firstLetter) {\n                    case \"+\":\n                    case \"-\":\n                    case \"*\":\n                    case \"/\":\n                        if (propertyName) {\n                            console.error(\"Velocity: The first property must not contain a relative function \\\"\" + propertyName + \"\\\":\", parts);\n                        }\n                        return;\n                }\n                pattern.push(false);\n                for (var _part5 = 0; _part5 < partsLength; _part5++) {\n                    sequence[_part5].push(bits[_part5][0]);\n                }\n                addString(_unit);\n            } else {\n                // Multiple units, so must be inside a calc.\n                addString(\"calc(\");\n                var patternCalc = pattern.length - 1; // Store the beginning of our calc.\n                for (var i = 0; i < units.length; i++) {\n                    var _unit2 = units[i],\n                        _firstLetter = _unit2[0],\n                        isComplex = _firstLetter === \"*\" || _firstLetter === \"/\",\n                        isMaths = isComplex || _firstLetter === \"+\" || _firstLetter === \"-\";\n                    if (isComplex) {\n                        // TODO: Not sure this should be done automatically!\n                        pattern[patternCalc] += \"(\";\n                        addString(\")\");\n                    }\n                    if (i) {\n                        addString(\" \" + (isMaths ? _firstLetter : \"+\") + \" \");\n                    }\n                    pattern.push(false);\n                    for (var _part6 = 0; _part6 < partsLength; _part6++) {\n                        var bit = bits[_part6],\n                            value = bit[1] === _unit2 ? bit[0] : bit.length === 3 ? sequence[_part6 - 1][sequence[_part6 - 1].length - 1] : isComplex ? 1 : 0;\n                        sequence[_part6].push(value);\n                    }\n                    addString(isMaths ? _unit2.substring(1) : _unit2);\n                }\n                addString(\")\");\n            }\n        }\n    }\n    // We've got here, so a valid sequence - now check and fix RGB rounding\n    // and calc() nesting...\n    // TODO: Nested calc(a + calc(b + c)) -> calc(a + (b + c))\n    for (var _i = 0, inRGB = 0; _i < pattern.length; _i++) {\n        var _text = pattern[_i];\n        if (isString(_text)) {\n            if (inRGB && _text.indexOf(\",\") >= 0) {\n                inRGB++;\n            } else if (_text.indexOf(\"rgb\") >= 0) {\n                inRGB = 1;\n            }\n        } else if (inRGB) {\n            if (inRGB < 4) {\n                pattern[_i] = true;\n            } else {\n                inRGB = 0;\n            }\n        }\n    }\n    return sequence;\n}\n/**\r\n * Convert a string-based tween with start and end strings, into a pattern\r\n * based tween with arrays.\r\n */\nfunction explodeTween(propertyName, tween, duration, starting) {\n    var startValue = tween.start,\n        endValue = tween.end;\n    if (!isString(endValue) || !isString(startValue)) {\n        return;\n    }\n    var sequence = findPattern([startValue, endValue], propertyName);\n    if (!sequence && starting) {\n        // This little piece will take a startValue, split out the\n        // various numbers in it, then copy the endValue into the\n        // startValue while replacing the numbers in it to match the\n        // original start numbers as a repeating sequence.\n        // Finally this function will run again with the new\n        // startValue and a now matching pattern.\n        var startNumbers = startValue.match(/\\d\\.?\\d*/g) || [\"0\"],\n            count = startNumbers.length;\n        var index = 0;\n        sequence = findPattern([endValue.replace(/\\d+\\.?\\d*/g, function () {\n            return startNumbers[index++ % count];\n        }), endValue], propertyName);\n    }\n    if (sequence) {\n        if (Velocity$$1.debug) {\n            console.log(\"Velocity: Sequence found:\", sequence);\n        }\n        sequence[0].percent = 0;\n        sequence[1].percent = 1;\n        tween.sequence = sequence;\n        switch (tween.easing) {\n            case Easings[\"at-start\"]:\n            case Easings[\"during\"]:\n            case Easings[\"at-end\"]:\n                sequence[0].easing = sequence[1].easing = tween.easing;\n                break;\n        }\n    }\n}\n/**\r\n * Expand all queued animations that haven't gone yet\r\n *\r\n * This will automatically expand the properties map for any recently added\r\n * animations so that the start and end values are correct.\r\n */\nfunction validateTweens(activeCall) {\n    // This might be called on an already-ready animation\n    if (State.firstNew === activeCall) {\n        State.firstNew = activeCall._next;\n    }\n    // Check if we're actually already ready\n    if (activeCall._flags & 1 /* EXPANDED */) {\n            // tslint:disable-line:no-bitwise\n            return;\n        }\n    var element = activeCall.element,\n        tweens = activeCall.tweens,\n        duration = getValue(activeCall.options.duration, defaults$1.duration);\n    // tslint:disable-next-line:forin\n    for (var propertyName in tweens) {\n        var tween = tweens[propertyName];\n        if (tween.start == null) {\n            // Get the start value as it's not been passed in\n            var startValue = getPropertyValue(activeCall.element, propertyName);\n            if (isString(startValue)) {\n                tween.start = fixColors(startValue);\n                explodeTween(propertyName, tween, duration, true);\n            } else if (!Array.isArray(startValue)) {\n                console.warn(\"bad type\", tween, propertyName, startValue);\n            }\n        }\n        if (Velocity$$1.debug) {\n            console.log(\"tweensContainer \\\"\" + propertyName + \"\\\": \" + JSON.stringify(tween), element);\n        }\n    }\n    activeCall._flags |= 1 /* EXPANDED */; // tslint:disable-line:no-bitwise\n}\n\n// Project\n/**\r\n * Call the begin method of an animation in a separate function so it can\r\n * benefit from JIT compiling while still having a try/catch block.\r\n */\nfunction beginCall(activeCall) {\n    var callback = activeCall.begin || activeCall.options.begin;\n    if (callback) {\n        try {\n            var elements = activeCall.elements;\n            callback.call(elements, elements, activeCall);\n        } catch (error) {\n            setTimeout(function () {\n                throw error;\n            }, 1);\n        }\n    }\n}\n/**\r\n * Call the progress method of an animation in a separate function so it can\r\n * benefit from JIT compiling while still having a try/catch block.\r\n */\nfunction progressCall(activeCall) {\n    var callback = activeCall.progress || activeCall.options.progress;\n    if (callback) {\n        try {\n            var elements = activeCall.elements,\n                percentComplete = activeCall.percentComplete,\n                options = activeCall.options,\n                tweenValue = activeCall.tween;\n            callback.call(elements, elements, percentComplete, Math.max(0, activeCall.timeStart + (activeCall.duration != null ? activeCall.duration : options.duration != null ? options.duration : defaults$1.duration) - lastTick), tweenValue !== undefined ? tweenValue : String(percentComplete * 100), activeCall);\n        } catch (error) {\n            setTimeout(function () {\n                throw error;\n            }, 1);\n        }\n    }\n}\n/**\r\n * Call callbacks, potentially run async with the main animation thread.\r\n */\nfunction asyncCallbacks() {\n    var _iteratorNormalCompletion = true;\n    var _didIteratorError = false;\n    var _iteratorError = undefined;\n\n    try {\n        for (var _iterator = progressed[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n            var activeCall = _step.value;\n\n            progressCall(activeCall);\n        }\n    } catch (err) {\n        _didIteratorError = true;\n        _iteratorError = err;\n    } finally {\n        try {\n            if (!_iteratorNormalCompletion && _iterator.return) {\n                _iterator.return();\n            }\n        } finally {\n            if (_didIteratorError) {\n                throw _iteratorError;\n            }\n        }\n    }\n\n    progressed.clear();\n    var _iteratorNormalCompletion2 = true;\n    var _didIteratorError2 = false;\n    var _iteratorError2 = undefined;\n\n    try {\n        for (var _iterator2 = completed[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n            var _activeCall = _step2.value;\n\n            completeCall(_activeCall);\n        }\n    } catch (err) {\n        _didIteratorError2 = true;\n        _iteratorError2 = err;\n    } finally {\n        try {\n            if (!_iteratorNormalCompletion2 && _iterator2.return) {\n                _iterator2.return();\n            }\n        } finally {\n            if (_didIteratorError2) {\n                throw _iteratorError2;\n            }\n        }\n    }\n\n    completed.clear();\n}\n/**************\r\n Timing\r\n **************/\nvar FRAME_TIME = 1000 / 60,\n\n/**\r\n * Animations with a Complete callback.\r\n */\ncompleted = new Set(),\n\n/**\r\n * Animations with a Progress callback.\r\n */\nprogressed = new Set(),\n\n/**\r\n * Shim for window.performance in case it doesn't exist\r\n */\nperformance = function () {\n    var perf = window.performance || {};\n    if (typeof perf.now !== \"function\") {\n        var nowOffset = perf.timing && perf.timing.navigationStart ? perf.timing.navigationStart : now();\n        perf.now = function () {\n            return now() - nowOffset;\n        };\n    }\n    return perf;\n}(),\n\n/**\r\n * Proxy function for when rAF is not available.\r\n *\r\n * This should hopefully never be used as the browsers often throttle\r\n * this to less than one frame per second in the background, making it\r\n * completely unusable.\r\n */\nrAFProxy = function rAFProxy(callback) {\n    return setTimeout(callback, Math.max(0, FRAME_TIME - (performance.now() - lastTick)));\n},\n\n/**\r\n * Either requestAnimationFrame, or a shim for it.\r\n */\nrAFShim = window.requestAnimationFrame || rAFProxy;\n/**\r\n * Set if we are currently inside a tick() to prevent double-calling.\r\n */\nvar ticking = void 0,\n\n/**\r\n * A background WebWorker that sends us framerate messages when we're in\r\n * the background. Without this we cannot maintain frame accuracy.\r\n */\nworker = void 0;\n/**\r\n * The time that the last animation frame ran at. Set from tick(), and used\r\n * for missing rAF (ie, when not in focus etc).\r\n */\nvar lastTick = 0;\n/**\r\n * WebWorker background function.\r\n *\r\n * When we're in the background this will send us a msg every tick, when in\r\n * the foreground it won't.\r\n *\r\n * When running in the background the browser reduces allowed CPU etc, so\r\n * we raun at 30fps instead of 60fps.\r\n */\nfunction workerFn() {\n    var _this = this;\n\n    var interval = void 0;\n    this.onmessage = function (e) {\n        switch (e.data) {\n            case true:\n                if (!interval) {\n                    interval = setInterval(function () {\n                        _this.postMessage(true);\n                    }, 1000 / 30);\n                }\n                break;\n            case false:\n                if (interval) {\n                    clearInterval(interval);\n                    interval = 0;\n                }\n                break;\n            default:\n                _this.postMessage(e.data);\n                break;\n        }\n    };\n}\ntry {\n    // Create the worker - this might not be supported, hence the try/catch.\n    worker = new Worker(URL.createObjectURL(new Blob([\"(\" + workerFn + \")()\"])));\n    // Whenever the worker sends a message we tick()\n    worker.onmessage = function (e) {\n        if (e.data === true) {\n            tick();\n        } else {\n            asyncCallbacks();\n        }\n    };\n    // And watch for going to the background to start the WebWorker running.\n    if (!State.isMobile && document.hidden !== undefined) {\n        document.addEventListener(\"visibilitychange\", function () {\n            worker.postMessage(State.isTicking && document.hidden);\n        });\n    }\n} catch (e) {}\n/*\r\n * WebWorkers are not supported in this format. This can happen in IE10\r\n * where it can't create one from a blob this way. We fallback, but make\r\n * no guarantees towards accuracy in this case.\r\n */\n\n/**\r\n * Called on every tick, preferably through rAF. This is reponsible for\r\n * initialising any new animations, then starting any that need starting.\r\n * Finally it will expand any tweens and set the properties relating to\r\n * them. If there are any callbacks relating to the animations then they\r\n * will attempt to call at the end (with the exception of \"begin\").\r\n */\nfunction tick(timestamp) {\n    if (ticking) {\n        // Should never happen - but if we've swapped back from hidden to\n        // visibile then we want to make sure\n        return;\n    }\n    ticking = true;\n    /* An empty timestamp argument indicates that this is the first tick occurence since ticking was turned on.\r\n     We leverage this metadata to fully ignore the first tick pass since RAF's initial pass is fired whenever\r\n     the browser's next tick sync time occurs, which results in the first elements subjected to Velocity\r\n     calls being animated out of sync with any elements animated immediately thereafter. In short, we ignore\r\n     the first RAF tick pass so that elements being immediately consecutively animated -- instead of simultaneously animated\r\n     by the same Velocity call -- are properly batched into the same initial RAF tick and consequently remain in sync thereafter. */\n    if (timestamp !== false) {\n        var timeCurrent = performance.now(),\n            deltaTime = lastTick ? timeCurrent - lastTick : FRAME_TIME,\n            defaultSpeed = defaults$1.speed,\n            defaultEasing = defaults$1.easing,\n            defaultDuration = defaults$1.duration;\n        var activeCall = void 0,\n            nextCall = void 0;\n        if (deltaTime >= defaults$1.minFrameTime || !lastTick) {\n            lastTick = timeCurrent;\n            /********************\r\n             Call Iteration\r\n             ********************/\n            // Expand any tweens that might need it.\n            while (State.firstNew) {\n                validateTweens(State.firstNew);\n            }\n            // Iterate through each active call.\n            for (activeCall = State.first; activeCall && activeCall !== State.firstNew; activeCall = activeCall._next) {\n                var element = activeCall.element,\n                    data = Data(element);\n                // Check to see if this element has been deleted midway\n                // through the animation. If it's gone then end this\n                // animation.\n                if (!element.parentNode || !data) {\n                    // TODO: Remove safely - decrease count, delete data, remove from arrays\n                    freeAnimationCall(activeCall);\n                    continue;\n                }\n                // Don't bother getting until we can use these.\n                var options = activeCall.options,\n                    flags = activeCall._flags;\n                var timeStart = activeCall.timeStart;\n                // If this is the first time that this call has been\n                // processed by tick() then we assign timeStart now so that\n                // it's value is as close to the real animation start time\n                // as possible.\n                if (!timeStart) {\n                    var queue = activeCall.queue != null ? activeCall.queue : options.queue;\n                    timeStart = timeCurrent - deltaTime;\n                    if (queue !== false) {\n                        timeStart = Math.max(timeStart, data.lastFinishList[queue] || 0);\n                    }\n                    activeCall.timeStart = timeStart;\n                }\n                // If this animation is paused then skip processing unless\n                // it has been set to resume.\n                if (flags & 16 /* PAUSED */) {\n                        // tslint:disable-line:no-bitwise\n                        // Update the time start to accomodate the paused\n                        // completion amount.\n                        activeCall.timeStart += deltaTime;\n                        continue;\n                    }\n                // Check if this animation is ready - if it's synced then it\n                // needs to wait for all other animations in the sync\n                if (!(flags & 2 /* READY */)) {\n                    // tslint:disable-line:no-bitwise\n                    activeCall._flags |= 2 /* READY */; // tslint:disable-line:no-bitwise\n                    options._ready++;\n                }\n            }\n            // Need to split the loop, as ready sync animations must all get\n            // the same start time.\n            for (activeCall = State.first; activeCall && activeCall !== State.firstNew; activeCall = nextCall) {\n                var _flags = activeCall._flags;\n                nextCall = activeCall._next;\n                if (!(_flags & 2 /* READY */) || _flags & 16 /* PAUSED */) {\n                    // tslint:disable-line:no-bitwise\n                    continue;\n                }\n                var _options = activeCall.options;\n                if (_flags & 32 /* SYNC */ && _options._ready < _options._total) {\n                    // tslint:disable-line:no-bitwise\n                    activeCall.timeStart += deltaTime;\n                    continue;\n                }\n                var speed = activeCall.speed != null ? activeCall.speed : _options.speed != null ? _options.speed : defaultSpeed;\n                var _timeStart = activeCall.timeStart;\n                // Don't bother getting until we can use these.\n                if (!(_flags & 4 /* STARTED */)) {\n                    // tslint:disable-line:no-bitwise\n                    var delay = activeCall.delay != null ? activeCall.delay : _options.delay;\n                    // Make sure anything we've delayed doesn't start\n                    // animating yet, there might still be an active delay\n                    // after something has been un-paused\n                    if (delay) {\n                        if (_timeStart + delay / speed > timeCurrent) {\n                            continue;\n                        }\n                        activeCall.timeStart = _timeStart += delay / (delay > 0 ? speed : 1);\n                    }\n                    activeCall._flags |= 4 /* STARTED */; // tslint:disable-line:no-bitwise\n                    // The begin callback is fired once per call, not once\n                    // per element, and is passed the full raw DOM element\n                    // set as both its context and its first argument.\n                    if (_options._started++ === 0) {\n                        _options._first = activeCall;\n                        if (_options.begin) {\n                            // Pass to an external fn with a try/catch block for optimisation\n                            beginCall(activeCall);\n                            // Only called once, even if reversed or repeated\n                            _options.begin = undefined;\n                        }\n                    }\n                }\n                if (speed !== 1) {\n                    // On the first frame we may have a shorter delta\n                    // const delta = Math.min(deltaTime, timeCurrent - timeStart);\n                    activeCall.timeStart = _timeStart += Math.min(deltaTime, timeCurrent - _timeStart) * (1 - speed);\n                }\n                var activeEasing = activeCall.easing != null ? activeCall.easing : _options.easing != null ? _options.easing : defaultEasing,\n                    millisecondsEllapsed = activeCall.ellapsedTime = timeCurrent - _timeStart,\n                    duration = activeCall.duration != null ? activeCall.duration : _options.duration != null ? _options.duration : defaultDuration,\n                    percentComplete = activeCall.percentComplete = Velocity$$1.mock ? 1 : Math.min(millisecondsEllapsed / duration, 1),\n                    tweens = activeCall.tweens,\n                    reverse = _flags & 64 /* REVERSE */; // tslint:disable-line:no-bitwise\n                if (activeCall.progress || _options._first === activeCall && _options.progress) {\n                    progressed.add(activeCall);\n                }\n                if (percentComplete === 1) {\n                    completed.add(activeCall);\n                }\n                // tslint:disable-next-line:forin\n                for (var property in tweens) {\n                    // For every element, iterate through each property.\n                    var tween = tweens[property],\n                        sequence = tween.sequence,\n                        pattern = sequence.pattern;\n                    var currentValue = \"\",\n                        i = 0;\n                    if (pattern) {\n                        var easingComplete = (tween.easing || activeEasing)(percentComplete, 0, 1, property);\n                        var best = 0;\n                        for (var j = 0; j < sequence.length - 1; j++) {\n                            if (sequence[j].percent < easingComplete) {\n                                best = j;\n                            }\n                        }\n                        var tweenFrom = sequence[best],\n                            tweenTo = sequence[best + 1] || tweenFrom,\n                            rawPercent = (percentComplete - tweenFrom.percent) / (tweenTo.percent - tweenFrom.percent),\n                            tweenPercent = reverse ? 1 - rawPercent : rawPercent,\n                            easing = tweenTo.easing || activeEasing || linearEasing;\n                        for (; i < pattern.length; i++) {\n                            var startValue = tweenFrom[i];\n                            if (startValue == null) {\n                                currentValue += pattern[i];\n                            } else {\n                                var endValue = tweenTo[i];\n                                if (startValue === endValue) {\n                                    currentValue += startValue;\n                                } else {\n                                    // All easings must deal with numbers except for our internal ones.\n                                    var result = easing(tweenPercent, startValue, endValue, property);\n                                    currentValue += pattern[i] !== true ? result : Math.round(result);\n                                }\n                            }\n                        }\n                        if (property !== \"tween\") {\n                            if (percentComplete === 1) {\n                                currentValue = removeNestedCalc(currentValue);\n                            }\n                            // TODO: To solve an IE<=8 positioning bug, the unit type must be dropped when setting a property value of 0 - add normalisations to legacy\n                            setPropertyValue(activeCall.element, property, currentValue, tween.fn);\n                        } else {\n                            // Skip the fake 'tween' property as that is only\n                            // passed into the progress callback.\n                            activeCall.tween = currentValue;\n                        }\n                    } else {\n                        console.warn(\"VelocityJS: Missing pattern:\", property, JSON.stringify(tween[property]));\n                        delete tweens[property];\n                    }\n                }\n            }\n            if (progressed.size || completed.size) {\n                if (!document.hidden) {\n                    asyncCallbacks();\n                } else if (worker) {\n                    worker.postMessage(\"\");\n                } else {\n                    setTimeout(asyncCallbacks, 1);\n                }\n            }\n        }\n    }\n    if (State.first) {\n        State.isTicking = true;\n        if (!document.hidden) {\n            rAFShim(tick);\n        } else if (!worker) {\n            rAFProxy(tick);\n        } else if (timestamp === false) {\n            // Make sure we turn on the messages.\n            worker.postMessage(true);\n        }\n    } else {\n        State.isTicking = false;\n        lastTick = 0;\n        if (document.hidden && worker) {\n            // Make sure we turn off the messages.\n            worker.postMessage(false);\n        }\n    }\n    ticking = false;\n}\n\n// Project\n/**\r\n * Check if an animation should be finished, and if so we set the tweens to\r\n * the final value for it, then call complete.\r\n */\nfunction checkAnimationShouldBeFinished(animation, queueName, defaultQueue) {\n    validateTweens(animation);\n    if (queueName === undefined || queueName === getValue(animation.queue, animation.options.queue, defaultQueue)) {\n        if (!(animation._flags & 4 /* STARTED */)) {\n            // tslint:disable-line:no-bitwise\n            // Copied from tick.ts - ensure that the animation is completely\n            // valid and run begin() before complete().\n            var options = animation.options;\n            // The begin callback is fired once per call, not once per\n            // element, and is passed the full raw DOM element set as both\n            // its context and its first argument.\n            if (options._started++ === 0) {\n                options._first = animation;\n                if (options.begin) {\n                    // Pass to an external fn with a try/catch block for optimisation\n                    beginCall(animation);\n                    // Only called once, even if reversed or repeated\n                    options.begin = undefined;\n                }\n            }\n            animation._flags |= 4 /* STARTED */; // tslint:disable-line:no-bitwise\n        }\n        // tslint:disable-next-line:forin\n        for (var property in animation.tweens) {\n            var tween = animation.tweens[property],\n                sequence = tween.sequence,\n                pattern = sequence.pattern;\n            var currentValue = \"\",\n                i = 0;\n            if (pattern) {\n                var endValues = sequence[sequence.length - 1];\n                for (; i < pattern.length; i++) {\n                    var endValue = endValues[i];\n                    currentValue += endValue == null ? pattern[i] : endValue;\n                }\n            }\n            setPropertyValue(animation.element, property, currentValue, tween.fn);\n        }\n        completeCall(animation);\n    }\n}\n/**\r\n * When the finish action is triggered, the elements' currently active call is\r\n * immediately finished. When an element is finished, the next item in its\r\n * animation queue is immediately triggered. If passed via a chained call\r\n * then this will only target the animations in that call, and not the\r\n * elements linked to it.\r\n *\r\n * A queue name may be passed in to specify that only animations on the\r\n * named queue are finished. The default queue is named \"\". In addition the\r\n * value of `false` is allowed for the queue name.\r\n *\r\n * An final argument may be passed in to clear an element's remaining queued\r\n * calls. This may only be the value `true`.\r\n */\nfunction finish(args, elements, promiseHandler) {\n    var queueName = validateQueue(args[0], true),\n        defaultQueue = defaults$1.queue,\n        finishAll = args[queueName === undefined ? 0 : 1] === true;\n    if (isVelocityResult(elements) && elements.velocity.animations) {\n        var _iteratorNormalCompletion = true;\n        var _didIteratorError = false;\n        var _iteratorError = undefined;\n\n        try {\n            for (var _iterator = elements.velocity.animations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n                var animation = _step.value;\n\n                checkAnimationShouldBeFinished(animation, queueName, defaultQueue);\n            }\n        } catch (err) {\n            _didIteratorError = true;\n            _iteratorError = err;\n        } finally {\n            try {\n                if (!_iteratorNormalCompletion && _iterator.return) {\n                    _iterator.return();\n                }\n            } finally {\n                if (_didIteratorError) {\n                    throw _iteratorError;\n                }\n            }\n        }\n    } else {\n        while (State.firstNew) {\n            validateTweens(State.firstNew);\n        }\n        for (var activeCall = State.first, nextCall; activeCall && (finishAll || activeCall !== State.firstNew); activeCall = nextCall || State.firstNew) {\n            nextCall = activeCall._next;\n            if (!elements || elements.includes(activeCall.element)) {\n                checkAnimationShouldBeFinished(activeCall, queueName, defaultQueue);\n            }\n        }\n    }\n    if (promiseHandler) {\n        if (isVelocityResult(elements) && elements.velocity.animations && elements.then) {\n            elements.then(promiseHandler._resolver);\n        } else {\n            promiseHandler._resolver(elements);\n        }\n    }\n}\nregisterAction([\"finish\", finish], true);\n\n/**\r\n * Used to map getters for the various AnimationFlags.\r\n */\nvar animationFlags = {\n    isExpanded: 1 /* EXPANDED */\n    , isReady: 2 /* READY */\n    , isStarted: 4 /* STARTED */\n    , isStopped: 8 /* STOPPED */\n    , isPaused: 16 /* PAUSED */\n    , isSync: 32 /* SYNC */\n    , isReverse: 64 /* REVERSE */\n};\n/**\r\n * Get or set an option or running AnimationCall data value. If there is no\r\n * value passed then it will get, otherwise we will set.\r\n *\r\n * NOTE: When using \"get\" this will not touch the Promise as it is never\r\n * returned to the user.\r\n */\nfunction option(args, elements, promiseHandler, action) {\n    var key = args[0],\n        queue = action.indexOf(\".\") >= 0 ? action.replace(/^.*\\./, \"\") : undefined,\n        queueName = queue === \"false\" ? false : validateQueue(queue, true);\n    var animations = void 0,\n        value = args[1];\n    if (!key) {\n        console.warn(\"VelocityJS: Cannot access a non-existant key!\");\n        return null;\n    }\n    // If we're chaining the return value from Velocity then we are only\n    // interested in the values related to that call\n    if (isVelocityResult(elements) && elements.velocity.animations) {\n        animations = elements.velocity.animations;\n    } else {\n        animations = [];\n        for (var activeCall = State.first; activeCall; activeCall = activeCall._next) {\n            if (elements.indexOf(activeCall.element) >= 0 && getValue(activeCall.queue, activeCall.options.queue) === queueName) {\n                animations.push(activeCall);\n            }\n        }\n        // If we're dealing with multiple elements that are pointing at a\n        // single running animation, then instead treat them as a single\n        // animation.\n        if (elements.length > 1 && animations.length > 1) {\n            var i = 1,\n                options = animations[0].options;\n            while (i < animations.length) {\n                if (animations[i++].options !== options) {\n                    options = null;\n                    break;\n                }\n            }\n            // TODO: this needs to check that they're actually a sync:true animation to merge the results, otherwise the individual values may be different\n            if (options) {\n                animations = [animations[0]];\n            }\n        }\n    }\n    // GET\n    if (value === undefined) {\n        var result = [],\n            flag = animationFlags[key];\n        var _iteratorNormalCompletion = true;\n        var _didIteratorError = false;\n        var _iteratorError = undefined;\n\n        try {\n            for (var _iterator = animations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n                var animation = _step.value;\n\n                if (flag === undefined) {\n                    // A normal key to get.\n                    result.push(getValue(animation[key], animation.options[key]));\n                } else {\n                    // A flag that we're checking against.\n                    result.push((animation._flags & flag) === 0); // tslint:disable-line:no-bitwise\n                }\n            }\n        } catch (err) {\n            _didIteratorError = true;\n            _iteratorError = err;\n        } finally {\n            try {\n                if (!_iteratorNormalCompletion && _iterator.return) {\n                    _iterator.return();\n                }\n            } finally {\n                if (_didIteratorError) {\n                    throw _iteratorError;\n                }\n            }\n        }\n\n        if (elements.length === 1 && animations.length === 1) {\n            // If only a single animation is found and we're only targetting a\n            // single element, then return the value directly\n            return result[0];\n        }\n        return result;\n    }\n    // SET\n    var isPercentComplete = void 0;\n    switch (key) {\n        case \"cache\":\n            value = validateCache(value);\n            break;\n        case \"begin\":\n            value = validateBegin(value);\n            break;\n        case \"complete\":\n            value = validateComplete(value);\n            break;\n        case \"delay\":\n            value = validateDelay(value);\n            break;\n        case \"duration\":\n            value = validateDuration(value);\n            break;\n        case \"fpsLimit\":\n            value = validateFpsLimit(value);\n            break;\n        case \"loop\":\n            value = validateLoop(value);\n            break;\n        case \"percentComplete\":\n            isPercentComplete = true;\n            value = parseFloat(value);\n            break;\n        case \"repeat\":\n        case \"repeatAgain\":\n            value = validateRepeat(value);\n            break;\n        default:\n            if (key[0] !== \"_\") {\n                var num = parseFloat(value);\n                if (value === String(num)) {\n                    value = num;\n                }\n                break;\n            }\n        // deliberate fallthrough\n        case \"queue\":\n        case \"promise\":\n        case \"promiseRejectEmpty\":\n        case \"easing\":\n        case \"started\":\n            console.warn(\"VelocityJS: Trying to set a read-only key:\", key);\n            return;\n    }\n    if (value === undefined || value !== value) {\n        console.warn(\"VelocityJS: Trying to set an invalid value:\" + key + \"=\" + value + \" (\" + args[1] + \")\");\n        return null;\n    }\n    var _iteratorNormalCompletion2 = true;\n    var _didIteratorError2 = false;\n    var _iteratorError2 = undefined;\n\n    try {\n        for (var _iterator2 = animations[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n            var _animation = _step2.value;\n\n            if (isPercentComplete) {\n                _animation.timeStart = lastTick - getValue(_animation.duration, _animation.options.duration, defaults$1.duration) * value;\n            } else {\n                _animation[key] = value;\n            }\n        }\n    } catch (err) {\n        _didIteratorError2 = true;\n        _iteratorError2 = err;\n    } finally {\n        try {\n            if (!_iteratorNormalCompletion2 && _iterator2.return) {\n                _iterator2.return();\n            }\n        } finally {\n            if (_didIteratorError2) {\n                throw _iteratorError2;\n            }\n        }\n    }\n\n    if (promiseHandler) {\n        if (isVelocityResult(elements) && elements.velocity.animations && elements.then) {\n            elements.then(promiseHandler._resolver);\n        } else {\n            promiseHandler._resolver(elements);\n        }\n    }\n}\nregisterAction([\"option\", option], true);\n\n// Project\n/**\r\n * Check if an animation should be paused / resumed.\r\n */\nfunction checkAnimation(animation, queueName, defaultQueue, isPaused) {\n    if (queueName === undefined || queueName === getValue(animation.queue, animation.options.queue, defaultQueue)) {\n        if (isPaused) {\n            animation._flags |= 16 /* PAUSED */; // tslint:disable-line:no-bitwise\n        } else {\n            animation._flags &= ~16 /* PAUSED */; // tslint:disable-line:no-bitwise\n        }\n    }\n}\n/**\r\n * Pause and Resume are call-wide (not on a per element basis). Thus, calling pause or resume on a\r\n * single element will cause any calls that contain tweens for that element to be paused/resumed\r\n * as well.\r\n */\nfunction pauseResume(args, elements, promiseHandler, action) {\n    var isPaused = action.indexOf(\"pause\") === 0,\n        queue = action.indexOf(\".\") >= 0 ? action.replace(/^.*\\./, \"\") : undefined,\n        queueName = queue === \"false\" ? false : validateQueue(args[0]),\n        defaultQueue = defaults$1.queue;\n    if (isVelocityResult(elements) && elements.velocity.animations) {\n        var _iteratorNormalCompletion = true;\n        var _didIteratorError = false;\n        var _iteratorError = undefined;\n\n        try {\n            for (var _iterator = elements.velocity.animations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n                var animation = _step.value;\n\n                checkAnimation(animation, queueName, defaultQueue, isPaused);\n            }\n        } catch (err) {\n            _didIteratorError = true;\n            _iteratorError = err;\n        } finally {\n            try {\n                if (!_iteratorNormalCompletion && _iterator.return) {\n                    _iterator.return();\n                }\n            } finally {\n                if (_didIteratorError) {\n                    throw _iteratorError;\n                }\n            }\n        }\n    } else {\n        var activeCall = State.first;\n        while (activeCall) {\n            if (!elements || elements.includes(activeCall.element)) {\n                checkAnimation(activeCall, queueName, defaultQueue, isPaused);\n            }\n            activeCall = activeCall._next;\n        }\n    }\n    if (promiseHandler) {\n        if (isVelocityResult(elements) && elements.velocity.animations && elements.then) {\n            elements.then(promiseHandler._resolver);\n        } else {\n            promiseHandler._resolver(elements);\n        }\n    }\n}\nregisterAction([\"pause\", pauseResume], true);\nregisterAction([\"resume\", pauseResume], true);\n\n// Project\n/**\r\n * Get or set a style of Nomralised property value on one or more elements.\r\n * If there is no value passed then it will get, otherwise we will set.\r\n *\r\n * NOTE: When using \"get\" this will not touch the Promise as it is never\r\n * returned to the user.\r\n *\r\n * This can fail to set, and will reject the Promise if it does so.\r\n *\r\n * Velocity(elements, \"style\", \"property\", \"value\") => elements;\r\n * Velocity(elements, \"style\", {\"property\": \"value\", ...}) => elements;\r\n * Velocity(element, \"style\", \"property\") => \"value\";\r\n * Velocity(elements, \"style\", \"property\") => [\"value\", ...];\r\n */\nfunction propertyAction(args, elements, promiseHandler, action) {\n    var property = args[0],\n        value = args[1];\n    if (!property) {\n        console.warn(\"VelocityJS: Cannot access a non-existant property!\");\n        return null;\n    }\n    // GET\n    if (value === undefined && !isPlainObject(property)) {\n        if (Array.isArray(property)) {\n            if (elements.length === 1) {\n                var result = {};\n                var _iteratorNormalCompletion = true;\n                var _didIteratorError = false;\n                var _iteratorError = undefined;\n\n                try {\n                    for (var _iterator = property[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n                        var prop = _step.value;\n\n                        result[prop] = fixColors(getPropertyValue(elements[0], prop));\n                    }\n                } catch (err) {\n                    _didIteratorError = true;\n                    _iteratorError = err;\n                } finally {\n                    try {\n                        if (!_iteratorNormalCompletion && _iterator.return) {\n                            _iterator.return();\n                        }\n                    } finally {\n                        if (_didIteratorError) {\n                            throw _iteratorError;\n                        }\n                    }\n                }\n\n                return result;\n            } else {\n                var _result = [];\n                var _iteratorNormalCompletion2 = true;\n                var _didIteratorError2 = false;\n                var _iteratorError2 = undefined;\n\n                try {\n                    for (var _iterator2 = elements[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n                        var element = _step2.value;\n\n                        var res = {};\n                        var _iteratorNormalCompletion3 = true;\n                        var _didIteratorError3 = false;\n                        var _iteratorError3 = undefined;\n\n                        try {\n                            for (var _iterator3 = property[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {\n                                var _prop = _step3.value;\n\n                                res[_prop] = fixColors(getPropertyValue(element, _prop));\n                            }\n                        } catch (err) {\n                            _didIteratorError3 = true;\n                            _iteratorError3 = err;\n                        } finally {\n                            try {\n                                if (!_iteratorNormalCompletion3 && _iterator3.return) {\n                                    _iterator3.return();\n                                }\n                            } finally {\n                                if (_didIteratorError3) {\n                                    throw _iteratorError3;\n                                }\n                            }\n                        }\n\n                        _result.push(res);\n                    }\n                } catch (err) {\n                    _didIteratorError2 = true;\n                    _iteratorError2 = err;\n                } finally {\n                    try {\n                        if (!_iteratorNormalCompletion2 && _iterator2.return) {\n                            _iterator2.return();\n                        }\n                    } finally {\n                        if (_didIteratorError2) {\n                            throw _iteratorError2;\n                        }\n                    }\n                }\n\n                return _result;\n            }\n        } else {\n            // If only a single animation is found and we're only targetting a\n            // single element, then return the value directly\n            if (elements.length === 1) {\n                return fixColors(getPropertyValue(elements[0], property));\n            }\n            var _result2 = [];\n            var _iteratorNormalCompletion4 = true;\n            var _didIteratorError4 = false;\n            var _iteratorError4 = undefined;\n\n            try {\n                for (var _iterator4 = elements[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {\n                    var _element = _step4.value;\n\n                    _result2.push(fixColors(getPropertyValue(_element, property)));\n                }\n            } catch (err) {\n                _didIteratorError4 = true;\n                _iteratorError4 = err;\n            } finally {\n                try {\n                    if (!_iteratorNormalCompletion4 && _iterator4.return) {\n                        _iterator4.return();\n                    }\n                } finally {\n                    if (_didIteratorError4) {\n                        throw _iteratorError4;\n                    }\n                }\n            }\n\n            return _result2;\n        }\n    }\n    // SET\n    var error = [];\n    if (isPlainObject(property)) {\n        for (var propertyName in property) {\n            if (property.hasOwnProperty(propertyName)) {\n                var _iteratorNormalCompletion5 = true;\n                var _didIteratorError5 = false;\n                var _iteratorError5 = undefined;\n\n                try {\n                    for (var _iterator5 = elements[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {\n                        var _element2 = _step5.value;\n\n                        var propertyValue = property[propertyName];\n                        if (isString(propertyValue) || isNumber(propertyValue)) {\n                            setPropertyValue(_element2, propertyName, property[propertyName]);\n                        } else {\n                            error.push(\"Cannot set a property \\\"\" + propertyName + \"\\\" to an unknown type: \" + (typeof propertyValue === \"undefined\" ? \"undefined\" : _typeof(propertyValue)));\n                            console.warn(\"VelocityJS: Cannot set a property \\\"\" + propertyName + \"\\\" to an unknown type:\", propertyValue);\n                        }\n                    }\n                } catch (err) {\n                    _didIteratorError5 = true;\n                    _iteratorError5 = err;\n                } finally {\n                    try {\n                        if (!_iteratorNormalCompletion5 && _iterator5.return) {\n                            _iterator5.return();\n                        }\n                    } finally {\n                        if (_didIteratorError5) {\n                            throw _iteratorError5;\n                        }\n                    }\n                }\n            }\n        }\n    } else if (isString(value) || isNumber(value)) {\n        var _iteratorNormalCompletion6 = true;\n        var _didIteratorError6 = false;\n        var _iteratorError6 = undefined;\n\n        try {\n            for (var _iterator6 = elements[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {\n                var _element3 = _step6.value;\n\n                setPropertyValue(_element3, property, String(value));\n            }\n        } catch (err) {\n            _didIteratorError6 = true;\n            _iteratorError6 = err;\n        } finally {\n            try {\n                if (!_iteratorNormalCompletion6 && _iterator6.return) {\n                    _iterator6.return();\n                }\n            } finally {\n                if (_didIteratorError6) {\n                    throw _iteratorError6;\n                }\n            }\n        }\n    } else {\n        error.push(\"Cannot set a property \\\"\" + property + \"\\\" to an unknown type: \" + (typeof value === \"undefined\" ? \"undefined\" : _typeof(value)));\n        console.warn(\"VelocityJS: Cannot set a property \\\"\" + property + \"\\\" to an unknown type:\", value);\n    }\n    if (promiseHandler) {\n        if (error.length) {\n            promiseHandler._rejecter(error.join(\", \"));\n        } else if (isVelocityResult(elements) && elements.velocity.animations && elements.then) {\n            elements.then(promiseHandler._resolver);\n        } else {\n            promiseHandler._resolver(elements);\n        }\n    }\n}\nregisterAction([\"property\", propertyAction], true);\n\n// Project\nregisterAction([\"reverse\", function (args, elements, promiseHandler, action) {\n        // NOTE: Code needs to split out before here - but this is needed to prevent it being overridden\n        throw new SyntaxError(\"VelocityJS: The 'reverse' action is built in and private.\");\n}], true);\n\n// Project\n/**\r\n * Check if an animation should be stopped, and if so then set the STOPPED\r\n * flag on it, then call complete.\r\n */\nfunction checkAnimationShouldBeStopped(animation, queueName, defaultQueue) {\n    validateTweens(animation);\n    if (queueName === undefined || queueName === getValue(animation.queue, animation.options.queue, defaultQueue)) {\n        animation._flags |= 8 /* STOPPED */; // tslint:disable-line:no-bitwise\n        completeCall(animation);\n    }\n}\n/**\r\n * When the stop action is triggered, the elements' currently active call is\r\n * immediately stopped. When an element is stopped, the next item in its\r\n * animation queue is immediately triggered. If passed via a chained call\r\n * then this will only target the animations in that call, and not the\r\n * elements linked to it.\r\n *\r\n * A queue name may be passed in to specify that only animations on the\r\n * named queue are stopped. The default queue is named \"\". In addition the\r\n * value of `false` is allowed for the queue name.\r\n *\r\n * An final argument may be passed in to clear an element's remaining queued\r\n * calls. This may only be the value `true`.\r\n *\r\n * Note: The stop command runs prior to Velocity's Queueing phase since its\r\n * behavior is intended to take effect *immediately*, regardless of the\r\n * element's current queue state.\r\n */\nfunction stop(args, elements, promiseHandler, action) {\n    var queueName = validateQueue(args[0], true),\n        defaultQueue = defaults$1.queue,\n        finishAll = args[queueName === undefined ? 0 : 1] === true;\n    if (isVelocityResult(elements) && elements.velocity.animations) {\n        var _iteratorNormalCompletion = true;\n        var _didIteratorError = false;\n        var _iteratorError = undefined;\n\n        try {\n            for (var _iterator = elements.velocity.animations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n                var animation = _step.value;\n\n                checkAnimationShouldBeStopped(animation, queueName, defaultQueue);\n            }\n        } catch (err) {\n            _didIteratorError = true;\n            _iteratorError = err;\n        } finally {\n            try {\n                if (!_iteratorNormalCompletion && _iterator.return) {\n                    _iterator.return();\n                }\n            } finally {\n                if (_didIteratorError) {\n                    throw _iteratorError;\n                }\n            }\n        }\n    } else {\n        while (State.firstNew) {\n            validateTweens(State.firstNew);\n        }\n        for (var activeCall = State.first, nextCall; activeCall && (finishAll || activeCall !== State.firstNew); activeCall = nextCall || State.firstNew) {\n            nextCall = activeCall._next;\n            if (!elements || elements.includes(activeCall.element)) {\n                checkAnimationShouldBeStopped(activeCall, queueName, defaultQueue);\n            }\n        }\n    }\n    if (promiseHandler) {\n        if (isVelocityResult(elements) && elements.velocity.animations && elements.then) {\n            elements.then(promiseHandler._resolver);\n        } else {\n            promiseHandler._resolver(elements);\n        }\n    }\n}\nregisterAction([\"stop\", stop], true);\n\n// Project\nregisterAction([\"style\", propertyAction], true);\n\n// Project\n/**\r\n *\r\n */\nfunction tweenAction(args, elements, promiseHandler, action) {\n    var requireForcefeeding = void 0;\n    if (!elements) {\n        if (!args.length) {\n            console.info(\"Velocity(<element>, \\\"tween\\\", percentComplete, property, end | [end, <easing>, <start>], <easing>) => value\\nVelocity(<element>, \\\"tween\\\", percentComplete, {property: end | [end, <easing>, <start>], ...}, <easing>) => {property: value, ...}\");\n            return null;\n        }\n        elements = [document.body];\n        requireForcefeeding = true;\n    } else if (elements.length !== 1) {\n        // TODO: Allow more than a single element to return an array of results\n        throw new Error(\"VelocityJS: Cannot tween more than one element!\");\n    }\n    var percentComplete = args[0],\n        fakeAnimation = {\n        elements: elements,\n        element: elements[0],\n        queue: false,\n        options: {\n            duration: 1000\n        },\n        tweens: null\n    },\n        result = {};\n    var properties = args[1],\n        singleResult = void 0,\n        maybeSequence = void 0,\n        easing = args[2],\n        count = 0;\n    if (isString(args[1])) {\n        if (SequencesObject && SequencesObject[args[1]]) {\n            maybeSequence = SequencesObject[args[1]];\n            properties = {};\n            easing = args[2];\n        } else {\n            singleResult = true;\n            properties = defineProperty({}, args[1], args[2]);\n            easing = args[3];\n        }\n    } else if (Array.isArray(args[1])) {\n        singleResult = true;\n        properties = {\n            tween: args[1]\n        };\n        easing = args[2];\n    }\n    if (!isNumber(percentComplete) || percentComplete < 0 || percentComplete > 1) {\n        throw new Error(\"VelocityJS: Must tween a percentage from 0 to 1!\");\n    }\n    if (!isPlainObject(properties)) {\n        throw new Error(\"VelocityJS: Cannot tween an invalid property!\");\n    }\n    if (requireForcefeeding) {\n        for (var property in properties) {\n            if (properties.hasOwnProperty(property) && (!Array.isArray(properties[property]) || properties[property].length < 2)) {\n                throw new Error(\"VelocityJS: When not supplying an element you must force-feed values: \" + property);\n            }\n        }\n    }\n    var activeEasing = validateEasing(getValue(easing, defaults$1.easing), DEFAULT_DURATION);\n    if (maybeSequence) {\n        expandSequence(fakeAnimation, maybeSequence);\n    } else {\n        expandProperties(fakeAnimation, properties);\n    }\n    // tslint:disable-next-line:forin\n    for (var _property in fakeAnimation.tweens) {\n        // For every element, iterate through each property.\n        var propertyTween = fakeAnimation.tweens[_property],\n            sequence = propertyTween.sequence,\n            pattern = sequence.pattern;\n        var currentValue = \"\",\n            i = 0;\n        count++;\n        if (pattern) {\n            var easingComplete = (propertyTween.easing || activeEasing)(percentComplete, 0, 1, _property);\n            var best = 0;\n            for (var j = 0; j < sequence.length - 1; j++) {\n                if (sequence[j].percent < easingComplete) {\n                    best = j;\n                }\n            }\n            var tweenFrom = sequence[best],\n                tweenTo = sequence[best + 1] || tweenFrom,\n                tweenPercent = (percentComplete - tweenFrom.percent) / (tweenTo.percent - tweenFrom.percent),\n                tweenEasing = tweenTo.easing || linearEasing;\n            for (; i < pattern.length; i++) {\n                var startValue = tweenFrom[i];\n                if (startValue == null) {\n                    currentValue += pattern[i];\n                } else {\n                    var endValue = tweenTo[i];\n                    if (startValue === endValue) {\n                        currentValue += startValue;\n                    } else {\n                        // All easings must deal with numbers except for our internal ones.\n                        var value = tweenEasing(tweenPercent, startValue, endValue, _property);\n                        currentValue += pattern[i] === true ? Math.round(value) : value;\n                    }\n                }\n            }\n            result[_property] = currentValue;\n        }\n    }\n    if (singleResult && count === 1) {\n        for (var _property2 in result) {\n            if (result.hasOwnProperty(_property2)) {\n                return result[_property2];\n            }\n        }\n    }\n    return result;\n}\nregisterAction([\"tween\", tweenAction], true);\n\n// Project\n/**\r\n * Converting from hex as it makes for a smaller file.\r\n */\nvar colorValues = {\n    aliceblue: 0xF0F8FF,\n    antiquewhite: 0xFAEBD7,\n    aqua: 0x00FFFF,\n    aquamarine: 0x7FFFD4,\n    azure: 0xF0FFFF,\n    beige: 0xF5F5DC,\n    bisque: 0xFFE4C4,\n    black: 0x000000,\n    blanchedalmond: 0xFFEBCD,\n    blue: 0x0000FF,\n    blueviolet: 0x8A2BE2,\n    brown: 0xA52A2A,\n    burlywood: 0xDEB887,\n    cadetblue: 0x5F9EA0,\n    chartreuse: 0x7FFF00,\n    chocolate: 0xD2691E,\n    coral: 0xFF7F50,\n    cornflowerblue: 0x6495ED,\n    cornsilk: 0xFFF8DC,\n    crimson: 0xDC143C,\n    cyan: 0x00FFFF,\n    darkblue: 0x00008B,\n    darkcyan: 0x008B8B,\n    darkgoldenrod: 0xB8860B,\n    darkgray: 0xA9A9A9,\n    darkgrey: 0xA9A9A9,\n    darkgreen: 0x006400,\n    darkkhaki: 0xBDB76B,\n    darkmagenta: 0x8B008B,\n    darkolivegreen: 0x556B2F,\n    darkorange: 0xFF8C00,\n    darkorchid: 0x9932CC,\n    darkred: 0x8B0000,\n    darksalmon: 0xE9967A,\n    darkseagreen: 0x8FBC8F,\n    darkslateblue: 0x483D8B,\n    darkslategray: 0x2F4F4F,\n    darkslategrey: 0x2F4F4F,\n    darkturquoise: 0x00CED1,\n    darkviolet: 0x9400D3,\n    deeppink: 0xFF1493,\n    deepskyblue: 0x00BFFF,\n    dimgray: 0x696969,\n    dimgrey: 0x696969,\n    dodgerblue: 0x1E90FF,\n    firebrick: 0xB22222,\n    floralwhite: 0xFFFAF0,\n    forestgreen: 0x228B22,\n    fuchsia: 0xFF00FF,\n    gainsboro: 0xDCDCDC,\n    ghostwhite: 0xF8F8FF,\n    gold: 0xFFD700,\n    goldenrod: 0xDAA520,\n    gray: 0x808080,\n    grey: 0x808080,\n    green: 0x008000,\n    greenyellow: 0xADFF2F,\n    honeydew: 0xF0FFF0,\n    hotpink: 0xFF69B4,\n    indianred: 0xCD5C5C,\n    indigo: 0x4B0082,\n    ivory: 0xFFFFF0,\n    khaki: 0xF0E68C,\n    lavender: 0xE6E6FA,\n    lavenderblush: 0xFFF0F5,\n    lawngreen: 0x7CFC00,\n    lemonchiffon: 0xFFFACD,\n    lightblue: 0xADD8E6,\n    lightcoral: 0xF08080,\n    lightcyan: 0xE0FFFF,\n    lightgoldenrodyellow: 0xFAFAD2,\n    lightgray: 0xD3D3D3,\n    lightgrey: 0xD3D3D3,\n    lightgreen: 0x90EE90,\n    lightpink: 0xFFB6C1,\n    lightsalmon: 0xFFA07A,\n    lightseagreen: 0x20B2AA,\n    lightskyblue: 0x87CEFA,\n    lightslategray: 0x778899,\n    lightslategrey: 0x778899,\n    lightsteelblue: 0xB0C4DE,\n    lightyellow: 0xFFFFE0,\n    lime: 0x00FF00,\n    limegreen: 0x32CD32,\n    linen: 0xFAF0E6,\n    magenta: 0xFF00FF,\n    maroon: 0x800000,\n    mediumaquamarine: 0x66CDAA,\n    mediumblue: 0x0000CD,\n    mediumorchid: 0xBA55D3,\n    mediumpurple: 0x9370DB,\n    mediumseagreen: 0x3CB371,\n    mediumslateblue: 0x7B68EE,\n    mediumspringgreen: 0x00FA9A,\n    mediumturquoise: 0x48D1CC,\n    mediumvioletred: 0xC71585,\n    midnightblue: 0x191970,\n    mintcream: 0xF5FFFA,\n    mistyrose: 0xFFE4E1,\n    moccasin: 0xFFE4B5,\n    navajowhite: 0xFFDEAD,\n    navy: 0x000080,\n    oldlace: 0xFDF5E6,\n    olive: 0x808000,\n    olivedrab: 0x6B8E23,\n    orange: 0xFFA500,\n    orangered: 0xFF4500,\n    orchid: 0xDA70D6,\n    palegoldenrod: 0xEEE8AA,\n    palegreen: 0x98FB98,\n    paleturquoise: 0xAFEEEE,\n    palevioletred: 0xDB7093,\n    papayawhip: 0xFFEFD5,\n    peachpuff: 0xFFDAB9,\n    peru: 0xCD853F,\n    pink: 0xFFC0CB,\n    plum: 0xDDA0DD,\n    powderblue: 0xB0E0E6,\n    purple: 0x800080,\n    rebeccapurple: 0x663399,\n    red: 0xFF0000,\n    rosybrown: 0xBC8F8F,\n    royalblue: 0x4169E1,\n    saddlebrown: 0x8B4513,\n    salmon: 0xFA8072,\n    sandybrown: 0xF4A460,\n    seagreen: 0x2E8B57,\n    seashell: 0xFFF5EE,\n    sienna: 0xA0522D,\n    silver: 0xC0C0C0,\n    skyblue: 0x87CEEB,\n    slateblue: 0x6A5ACD,\n    slategray: 0x708090,\n    slategrey: 0x708090,\n    snow: 0xFFFAFA,\n    springgreen: 0x00FF7F,\n    steelblue: 0x4682B4,\n    tan: 0xD2B48C,\n    teal: 0x008080,\n    thistle: 0xD8BFD8,\n    tomato: 0xFF6347,\n    turquoise: 0x40E0D0,\n    violet: 0xEE82EE,\n    wheat: 0xF5DEB3,\n    white: 0xFFFFFF,\n    whitesmoke: 0xF5F5F5,\n    yellow: 0xFFFF00,\n    yellowgreen: 0x9ACD32\n};\nfor (var name in colorValues) {\n    if (colorValues.hasOwnProperty(name)) {\n        var color = colorValues[name];\n        ColorNames[name] = Math.floor(color / 65536) + \",\" + Math.floor(color / 256 % 256) + \",\" + color % 256;\n    }\n}\n\n// Project\nfunction registerBackIn(name, amount) {\n    registerEasing([name, function (percentComplete, startValue, endValue) {\n        if (percentComplete === 0) {\n            return startValue;\n        }\n        if (percentComplete === 1) {\n            return endValue;\n        }\n        return Math.pow(percentComplete, 2) * ((amount + 1) * percentComplete - amount) * (endValue - startValue);\n    }]);\n}\nfunction registerBackOut(name, amount) {\n    registerEasing([name, function (percentComplete, startValue, endValue) {\n        if (percentComplete === 0) {\n            return startValue;\n        }\n        if (percentComplete === 1) {\n            return endValue;\n        }\n        return (Math.pow(--percentComplete, 2) * ((amount + 1) * percentComplete + amount) + 1) * (endValue - startValue);\n    }]);\n}\nfunction registerBackInOut(name, amount) {\n    amount *= 1.525;\n    registerEasing([name, function (percentComplete, startValue, endValue) {\n        if (percentComplete === 0) {\n            return startValue;\n        }\n        if (percentComplete === 1) {\n            return endValue;\n        }\n        percentComplete *= 2;\n        return (percentComplete < 1 ? Math.pow(percentComplete, 2) * ((amount + 1) * percentComplete - amount) : Math.pow(percentComplete - 2, 2) * ((amount + 1) * (percentComplete - 2) + amount) + 2) * 0.5 * (endValue - startValue);\n    }]);\n}\nregisterBackIn(\"easeInBack\", 1.7);\nregisterBackOut(\"easeOutBack\", 1.7);\nregisterBackInOut(\"easeInOutBack\", 1.7);\n// TODO: Expose these as actions to register custom easings?\n\n// Project\nfunction easeOutBouncePercent(percentComplete) {\n    if (percentComplete < 1 / 2.75) {\n        return 7.5625 * percentComplete * percentComplete;\n    }\n    if (percentComplete < 2 / 2.75) {\n        return 7.5625 * (percentComplete -= 1.5 / 2.75) * percentComplete + 0.75;\n    }\n    if (percentComplete < 2.5 / 2.75) {\n        return 7.5625 * (percentComplete -= 2.25 / 2.75) * percentComplete + 0.9375;\n    }\n    return 7.5625 * (percentComplete -= 2.625 / 2.75) * percentComplete + 0.984375;\n}\nfunction easeInBouncePercent(percentComplete) {\n    return 1 - easeOutBouncePercent(1 - percentComplete);\n}\nfunction easeInBounce(percentComplete, startValue, endValue) {\n    if (percentComplete === 0) {\n        return startValue;\n    }\n    if (percentComplete === 1) {\n        return endValue;\n    }\n    return easeInBouncePercent(percentComplete) * (endValue - startValue);\n}\nfunction easeOutBounce(percentComplete, startValue, endValue) {\n    if (percentComplete === 0) {\n        return startValue;\n    }\n    if (percentComplete === 1) {\n        return endValue;\n    }\n    return easeOutBouncePercent(percentComplete) * (endValue - startValue);\n}\nfunction easeInOutBounce(percentComplete, startValue, endValue) {\n    if (percentComplete === 0) {\n        return startValue;\n    }\n    if (percentComplete === 1) {\n        return endValue;\n    }\n    return (percentComplete < 0.5 ? easeInBouncePercent(percentComplete * 2) * 0.5 : easeOutBouncePercent(percentComplete * 2 - 1) * 0.5 + 0.5) * (endValue - startValue);\n}\nregisterEasing([\"easeInBounce\", easeInBounce]);\nregisterEasing([\"easeOutBounce\", easeOutBounce]);\nregisterEasing([\"easeInOutBounce\", easeInOutBounce]);\n\n// Project\n// Constants\nvar PI2 = Math.PI * 2;\nfunction registerElasticIn(name, amplitude, period) {\n    registerEasing([name, function (percentComplete, startValue, endValue) {\n        if (percentComplete === 0) {\n            return startValue;\n        }\n        if (percentComplete === 1) {\n            return endValue;\n        }\n        return -(amplitude * Math.pow(2, 10 * (percentComplete -= 1)) * Math.sin((percentComplete - period / PI2 * Math.asin(1 / amplitude)) * PI2 / period)) * (endValue - startValue);\n    }]);\n}\nfunction registerElasticOut(name, amplitude, period) {\n    registerEasing([name, function (percentComplete, startValue, endValue) {\n        if (percentComplete === 0) {\n            return startValue;\n        }\n        if (percentComplete === 1) {\n            return endValue;\n        }\n        return (amplitude * Math.pow(2, -10 * percentComplete) * Math.sin((percentComplete - period / PI2 * Math.asin(1 / amplitude)) * PI2 / period) + 1) * (endValue - startValue);\n    }]);\n}\nfunction registerElasticInOut(name, amplitude, period) {\n    registerEasing([name, function (percentComplete, startValue, endValue) {\n        if (percentComplete === 0) {\n            return startValue;\n        }\n        if (percentComplete === 1) {\n            return endValue;\n        }\n        var s = period / PI2 * Math.asin(1 / amplitude);\n        percentComplete = percentComplete * 2 - 1;\n        return (percentComplete < 0 ? -0.5 * (amplitude * Math.pow(2, 10 * percentComplete) * Math.sin((percentComplete - s) * PI2 / period)) : amplitude * Math.pow(2, -10 * percentComplete) * Math.sin((percentComplete - s) * PI2 / period) * 0.5 + 1) * (endValue - startValue);\n    }]);\n}\nregisterElasticIn(\"easeInElastic\", 1, 0.3);\nregisterElasticOut(\"easeOutElastic\", 1, 0.3);\nregisterElasticInOut(\"easeInOutElastic\", 1, 0.3 * 1.5);\n// TODO: Expose these as actions to register custom easings?\n\n// Project\n/**\r\n * Easing function that sets to the specified value immediately after the\r\n * animation starts.\r\n */\nfunction atStart(percentComplete, startValue, endValue) {\n  return percentComplete === 0 ? startValue : endValue;\n}\n/**\r\n * Easing function that sets to the specified value while the animation is\r\n * running.\r\n */\nfunction during(percentComplete, startValue, endValue) {\n  return percentComplete === 0 || percentComplete === 1 ? startValue : endValue;\n}\n/**\r\n * Easing function that sets to the specified value when the animation ends.\r\n */\nfunction atEnd(percentComplete, startValue, endValue) {\n  return percentComplete === 1 ? endValue : startValue;\n}\nregisterEasing([\"at-start\", atStart]);\nregisterEasing([\"during\", during]);\nregisterEasing([\"at-end\", atEnd]);\n\n// Project\n/**\r\n * Get/set the inner/outer dimension.\r\n */\nfunction getDimension(name, wantInner) {\n    return function (element, propertyValue) {\n        if (propertyValue === undefined) {\n            return augmentDimension(element, name, wantInner) + \"px\";\n        }\n        setPropertyValue(element, name, parseFloat(propertyValue) - augmentDimension(element, name, wantInner) + \"px\");\n    };\n}\nregisterNormalization([\"Element\", \"innerWidth\", getDimension(\"width\", true)]);\nregisterNormalization([\"Element\", \"innerHeight\", getDimension(\"height\", true)]);\nregisterNormalization([\"Element\", \"outerWidth\", getDimension(\"width\", false)]);\nregisterNormalization([\"Element\", \"outerHeight\", getDimension(\"height\", false)]);\n\n// Project\n// Constants\nvar inlineRx = /^(b|big|i|small|tt|abbr|acronym|cite|code|dfn|em|kbd|strong|samp|let|a|bdo|br|img|map|object|q|script|span|sub|sup|button|input|label|select|textarea)$/i,\n    listItemRx = /^(li)$/i,\n    tableRowRx = /^(tr)$/i,\n    tableRx = /^(table)$/i,\n    tableRowGroupRx = /^(tbody)$/i;\nfunction display(element, propertyValue) {\n    var style = element.style;\n    if (propertyValue === undefined) {\n        return computePropertyValue(element, \"display\");\n    }\n    if (propertyValue === \"auto\") {\n        var nodeName = element && element.nodeName,\n            data = Data(element);\n        if (inlineRx.test(nodeName)) {\n            propertyValue = \"inline\";\n        } else if (listItemRx.test(nodeName)) {\n            propertyValue = \"list-item\";\n        } else if (tableRowRx.test(nodeName)) {\n            propertyValue = \"table-row\";\n        } else if (tableRx.test(nodeName)) {\n            propertyValue = \"table\";\n        } else if (tableRowGroupRx.test(nodeName)) {\n            propertyValue = \"table-row-group\";\n        } else {\n            // Default to \"block\" when no match is found.\n            propertyValue = \"block\";\n        }\n        // IMPORTANT: We need to do this as getPropertyValue bypasses the\n        // Normalisation when it exists in the cache.\n        data.cache[\"display\"] = propertyValue;\n    }\n    style.display = propertyValue;\n}\nregisterNormalization([\"Element\", \"display\", display]);\n\n// Project\nfunction clientWidth(element, propertyValue) {\n    if (propertyValue == null) {\n        return element.clientWidth + \"px\";\n    }\n}\nfunction scrollWidth(element, propertyValue) {\n    if (propertyValue == null) {\n        return element.scrollWidth + \"px\";\n    }\n}\nfunction clientHeight(element, propertyValue) {\n    if (propertyValue == null) {\n        return element.clientHeight + \"px\";\n    }\n}\nfunction scrollHeight(element, propertyValue) {\n    if (propertyValue == null) {\n        return element.scrollHeight + \"px\";\n    }\n}\nfunction scroll(direction, end) {\n    return function (element, propertyValue) {\n        if (propertyValue == null) {\n            // Make sure we have these values cached.\n            getPropertyValue(element, \"client\" + direction, null, true);\n            getPropertyValue(element, \"scroll\" + direction, null, true);\n            return element[\"scroll\" + end] + \"px\";\n        }\n        var value = parseFloat(propertyValue),\n            unit = propertyValue.replace(String(value), \"\");\n        switch (unit) {\n            case \"\":\n            case \"px\":\n                element[\"scroll\" + end] = value;\n                break;\n            case \"%\":\n                var client = parseFloat(getPropertyValue(element, \"client\" + direction)),\n                    scrollValue = parseFloat(getPropertyValue(element, \"scroll\" + direction));\n                element[\"scroll\" + end] = Math.max(0, scrollValue - client) * value / 100;\n                break;\n        }\n    };\n}\nregisterNormalization([\"HTMLElement\", \"scroll\", scroll(\"Height\", \"Top\"), false]);\nregisterNormalization([\"HTMLElement\", \"scrollTop\", scroll(\"Height\", \"Top\"), false]);\nregisterNormalization([\"HTMLElement\", \"scrollLeft\", scroll(\"Width\", \"Left\"), false]);\nregisterNormalization([\"HTMLElement\", \"scrollWidth\", scrollWidth]);\nregisterNormalization([\"HTMLElement\", \"clientWidth\", clientWidth]);\nregisterNormalization([\"HTMLElement\", \"scrollHeight\", scrollHeight]);\nregisterNormalization([\"HTMLElement\", \"clientHeight\", clientHeight]);\n\n// Project\n/**\r\n * An RegExp pattern for the following list of css words using\r\n * http://kemio.com.ar/tools/lst-trie-re.php to generate:\r\n *\r\n * blockSize\r\n * borderBottomLeftRadius\r\n * borderBottomRightRadius\r\n * borderBottomWidth\r\n * borderImageOutset\r\n * borderImageWidth\r\n * borderLeftWidth\r\n * borderRadius\r\n * borderRightWidth\r\n * borderSpacing\r\n * borderTopLeftRadius\r\n * borderTopRightRadius\r\n * borderTopWidth\r\n * borderWidth\r\n * bottom\r\n * columnGap\r\n * columnRuleWidth\r\n * columnWidth\r\n * flexBasis\r\n * fontSize\r\n * gridColumnGap\r\n * gridGap\r\n * gridRowGap\r\n * height\r\n * inlineSize\r\n * left\r\n * letterSpacing\r\n * margin\r\n * marginBottom\r\n * marginLeft\r\n * marginRight\r\n * marginTop\r\n * maxBlockSize\r\n * maxHeight\r\n * maxInlineSize\r\n * maxWidth\r\n * minBlockSize\r\n * minHeight\r\n * minInlineSize\r\n * minWidth\r\n * objectPosition\r\n * outlineOffset\r\n * outlineWidth\r\n * padding\r\n * paddingBottom\r\n * paddingLeft\r\n * paddingRight\r\n * paddingTop\r\n * perspective\r\n * right\r\n * shapeMargin\r\n * strokeDashoffset\r\n * strokeWidth\r\n * textIndent\r\n * top\r\n * transformOrigin\r\n * width\r\n * wordSpacing\r\n */\n// tslint:disable-next-line:max-line-length\nvar rxAddPx = /^(b(lockSize|o(rder(Bottom(LeftRadius|RightRadius|Width)|Image(Outset|Width)|LeftWidth|R(adius|ightWidth)|Spacing|Top(LeftRadius|RightRadius|Width)|Width)|ttom))|column(Gap|RuleWidth|Width)|f(lexBasis|ontSize)|grid(ColumnGap|Gap|RowGap)|height|inlineSize|le(ft|tterSpacing)|m(a(rgin(Bottom|Left|Right|Top)|x(BlockSize|Height|InlineSize|Width))|in(BlockSize|Height|InlineSize|Width))|o(bjectPosition|utline(Offset|Width))|p(adding(Bottom|Left|Right|Top)|erspective)|right|s(hapeMargin|troke(Dashoffset|Width))|t(extIndent|op|ransformOrigin)|w(idth|ordSpacing))$/;\n/**\r\n * Return a Normalisation that can be used to set / get a prefixed style\r\n * property.\r\n */\nfunction getSetPrefixed(propertyName, unprefixed) {\n    return function (element, propertyValue) {\n        if (propertyValue === undefined) {\n            return computePropertyValue(element, propertyName) || computePropertyValue(element, unprefixed);\n        }\n        element.style[propertyName] = element.style[unprefixed] = propertyValue;\n    };\n}\n/**\r\n * Return a Normalisation that can be used to set / get a style property.\r\n */\nfunction getSetStyle(propertyName) {\n    return function (element, propertyValue) {\n        if (propertyValue === undefined) {\n            return computePropertyValue(element, propertyName);\n        }\n        element.style[propertyName] = propertyValue;\n    };\n}\n/**\r\n * Vendor prefixes. Chrome / Safari, Firefox, IE / Edge, Opera.\r\n */\nvar rxVendors = /^(webkit|moz|ms|o)[A-Z]/,\n    prefixElement = State.prefixElement;\nif (prefixElement) {\n    for (var propertyName in prefixElement.style) {\n        if (rxVendors.test(propertyName)) {\n            var unprefixed = propertyName.replace(/^[a-z]+([A-Z])/, function ($, letter) {\n                return letter.toLowerCase();\n            });\n            {\n                var addUnit = rxAddPx.test(unprefixed) ? \"px\" : undefined;\n                registerNormalization([\"Element\", unprefixed, getSetPrefixed(propertyName, unprefixed), addUnit]);\n            }\n        } else if (!hasNormalization([\"Element\", propertyName])) {\n            var _addUnit = rxAddPx.test(propertyName) ? \"px\" : undefined;\n            registerNormalization([\"Element\", propertyName, getSetStyle(propertyName), _addUnit]);\n        }\n    }\n}\n\n// Project\n/**\r\n * Get/set an attribute.\r\n */\nfunction getAttribute(name) {\n    return function (element, propertyValue) {\n        if (propertyValue === undefined) {\n            return element.getAttribute(name);\n        }\n        element.setAttribute(name, propertyValue);\n    };\n}\nvar base = document.createElement(\"div\"),\n    rxSubtype = /^SVG(.*)Element$/,\n    rxElement = /Element$/;\nObject.getOwnPropertyNames(window).forEach(function (property) {\n    var subtype = rxSubtype.exec(property);\n    if (subtype && subtype[1] !== \"SVG\") {\n        // Don't do SVGSVGElement.\n        try {\n            var element = subtype[1] ? document.createElementNS(\"http://www.w3.org/2000/svg\", (subtype[1] || \"svg\").toLowerCase()) : document.createElement(\"svg\");\n            // tslint:disable-next-line:forin\n            for (var attribute in element) {\n                // Although this isn't a tween without prototypes, we do\n                // want to get hold of all attributes and not just own ones.\n                var value = element[attribute];\n                if (isString(attribute) && !(attribute[0] === \"o\" && attribute[1] === \"n\") && attribute !== attribute.toUpperCase() && !rxElement.test(attribute) && !(attribute in base) && !isFunction(value)) {\n                    // TODO: Should this all be set on the generic SVGElement, it would save space and time, but not as powerful\n                    registerNormalization([property, attribute, getAttribute(attribute)]);\n                }\n            }\n        } catch (e) {\n            console.error(\"VelocityJS: Error when trying to identify SVG attributes on \" + property + \".\", e);\n        }\n    }\n});\n\n// Project\n/**\r\n * Get/set the width or height.\r\n */\nfunction getDimension$1(name) {\n    return function (element, propertyValue) {\n        if (propertyValue === undefined) {\n            // Firefox throws an error if .getBBox() is called on an SVG that isn't attached to the DOM.\n            try {\n                return element.getBBox()[name] + \"px\";\n            } catch (e) {\n                return \"0px\";\n            }\n        }\n        element.setAttribute(name, propertyValue);\n    };\n}\nregisterNormalization([\"SVGElement\", \"width\", getDimension$1(\"width\")]);\nregisterNormalization([\"SVGElement\", \"height\", getDimension$1(\"height\")]);\n\n// Project\n/**\r\n * A fake normalization used to allow the \"tween\" property easy access.\r\n */\nfunction getSetTween(element, propertyValue) {\n    if (propertyValue === undefined) {\n        return \"\";\n    }\n}\nregisterNormalization([\"Element\", \"tween\", getSetTween]);\n\n// Automatically generated\nvar VERSION = \"2.0.6\";\n\n// Project\nvar Velocity$$1 = Velocity$1;\n/**\r\n * These parts of Velocity absolutely must be included, even if they're unused!\r\n */\nvar VelocityStatic;\n(function (VelocityStatic) {\n    /**\r\n     * Actions cannot be replaced if they are internal (hasOwnProperty is false\r\n     * but they still exist). Otherwise they can be replaced by users.\r\n     *\r\n     * All external method calls should be using actions rather than sub-calls\r\n     * of Velocity itself.\r\n     */\n    VelocityStatic.Actions = Actions;\n    /**\r\n     * Our known easing functions.\r\n     */\n    VelocityStatic.Easings = Easings;\n    /**\r\n     * The currently registered sequences.\r\n     */\n    VelocityStatic.Sequences = SequencesObject;\n    /**\r\n     * Current internal state of Velocity.\r\n     */\n    VelocityStatic.State = State; // tslint:disable-line:no-shadowed-variable\n    /**\r\n     * Velocity option defaults, which can be overriden by the user.\r\n     */\n    VelocityStatic.defaults = defaults$1;\n    /**\r\n     * Used to patch any object to allow Velocity chaining. In order to chain an\r\n     * object must either be treatable as an array - with a <code>.length</code>\r\n     * property, and each member a Node, or a Node directly.\r\n     *\r\n     * By default Velocity will try to patch <code>window</code>,\r\n     * <code>jQuery</code>, <code>Zepto</code>, and several classes that return\r\n     * Nodes or lists of Nodes.\r\n     */\n    VelocityStatic.patch = patch;\n    /**\r\n     * Set to true, 1 or 2 (most verbose) to output debug info to console.\r\n     */\n    VelocityStatic.debug = false;\n    /**\r\n     * In mock mode, all animations are forced to complete immediately upon the\r\n     * next rAF tick. If there are further animations queued then they will each\r\n     * take one single frame in turn. Loops and repeats will be disabled while\r\n     * <code>mock = true</code>.\r\n     */\n    VelocityStatic.mock = false;\n    /**\r\n     * Save our version number somewhere visible.\r\n     */\n    VelocityStatic.version = VERSION;\n    /**\r\n     * Added as a fallback for \"import {Velocity} from 'velocity-animate';\".\r\n     */\n    VelocityStatic.Velocity = Velocity$1; // tslint:disable-line:no-shadowed-variable\n})(VelocityStatic || (VelocityStatic = {}));\n/* IE detection. Gist: https://gist.github.com/julianshapiro/9098609 */\nvar IE = function () {\n    if (document.documentMode) {\n        return document.documentMode;\n    } else {\n        for (var i = 7; i > 4; i--) {\n            var div = document.createElement(\"div\");\n            div.innerHTML = \"<!\" + \"--\" + \"[if IE \" + i + \"]><span></span><![endif]-->\";\n            if (div.getElementsByTagName(\"span\").length) {\n                div = null;\n                return i;\n            }\n        }\n    }\n    return undefined;\n}();\n/******************\r\n Unsupported\r\n ******************/\nif (IE <= 8) {\n    throw new Error(\"VelocityJS cannot run on Internet Explorer 8 or earlier\");\n}\n/******************\r\n Frameworks\r\n ******************/\nif (window) {\n    /*\r\n     * Both jQuery and Zepto allow their $.fn object to be extended to allow\r\n     * wrapped elements to be subjected to plugin calls. If either framework is\r\n     * loaded, register a \"velocity\" extension pointing to Velocity's core\r\n     * animate() method. Velocity also registers itself onto a global container\r\n     * (window.jQuery || window.Zepto || window) so that certain features are\r\n     * accessible beyond just a per-element scope. Accordingly, Velocity can\r\n     * both act on wrapped DOM elements and stand alone for targeting raw DOM\r\n     * elements.\r\n     */\n    var jQuery = window.jQuery,\n        Zepto = window.Zepto;\n    patch(window, true);\n    patch(Element && Element.prototype);\n    patch(NodeList && NodeList.prototype);\n    patch(HTMLCollection && HTMLCollection.prototype);\n    patch(jQuery, true);\n    patch(jQuery && jQuery.fn);\n    patch(Zepto, true);\n    patch(Zepto && Zepto.fn);\n}\n// Make sure that the values within Velocity are read-only and upatchable.\n\nvar _loop = function _loop(property) {\n    if (VelocityStatic.hasOwnProperty(property)) {\n        switch (typeof property === \"undefined\" ? \"undefined\" : _typeof(property)) {\n            case \"number\":\n            case \"boolean\":\n                defineProperty$1(Velocity$$1, property, {\n                    get: function get$$1() {\n                        return VelocityStatic[property];\n                    },\n                    set: function set$$1(value) {\n                        VelocityStatic[property] = value;\n                    }\n                }, true);\n                break;\n            default:\n                defineProperty$1(Velocity$$1, property, VelocityStatic[property], true);\n                break;\n        }\n    }\n};\n\nfor (var property in VelocityStatic) {\n    _loop(property);\n}\nObject.freeze(Velocity$$1);\n\n// Project\nvar rxPercents = /(\\d*\\.\\d+|\\d+\\.?|from|to)/g;\nfunction expandSequence(animation, sequence) {\n    var tweens = animation.tweens = Object.create(null),\n        element = animation.element;\n    for (var propertyName in sequence.tweens) {\n        if (sequence.tweens.hasOwnProperty(propertyName)) {\n            var fn = getNormalization(element, propertyName);\n            if (!fn && propertyName !== \"tween\") {\n                if (Velocity$$1.debug) {\n                    console.log(\"Skipping [\" + propertyName + \"] due to a lack of browser support.\");\n                }\n                continue;\n            }\n            tweens[propertyName] = {\n                fn: fn,\n                sequence: sequence.tweens[propertyName]\n            };\n        }\n    }\n}\n/**\r\n * Used to register a sequence. This should never be called by users\r\n * directly, instead it should be called via an action:<br/>\r\n * <code>Velocity(\"registerSequence\", \"\"name\", VelocitySequence);</code>\r\n */\nfunction registerSequence(args) {\n    if (isPlainObject(args[0])) {\n        for (var name in args[0]) {\n            if (args[0].hasOwnProperty(name)) {\n                registerSequence([name, args[0][name]]);\n            }\n        }\n    } else if (isString(args[0])) {\n        var _name = args[0],\n            sequence = args[1];\n        if (!isString(_name)) {\n            console.warn(\"VelocityJS: Trying to set 'registerSequence' name to an invalid value:\", _name);\n        } else if (!isPlainObject(sequence)) {\n            console.warn(\"VelocityJS: Trying to set 'registerSequence' sequence to an invalid value:\", _name, sequence);\n        } else {\n            if (SequencesObject[_name]) {\n                console.warn(\"VelocityJS: Replacing named sequence:\", _name);\n            }\n            var percents = {},\n                steps = new Array(100),\n                properties = [],\n                sequenceList = SequencesObject[_name] = {},\n                duration = validateDuration(sequence.duration);\n            sequenceList.tweens = {};\n            if (isNumber(duration)) {\n                sequenceList.duration = duration;\n            }\n            for (var part in sequence) {\n                if (sequence.hasOwnProperty(part)) {\n                    var keys = String(part).match(rxPercents);\n                    if (keys) {\n                        var _iteratorNormalCompletion = true;\n                        var _didIteratorError = false;\n                        var _iteratorError = undefined;\n\n                        try {\n                            for (var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n                                var key = _step.value;\n\n                                var percent = key === \"from\" ? 0 : key === \"to\" ? 100 : parseFloat(key);\n                                if (percent < 0 || percent > 100) {\n                                    console.warn(\"VelocityJS: Trying to use an invalid value as a percentage (0 <= n <= 100):\", _name, percent);\n                                } else if (isNaN(percent)) {\n                                    console.warn(\"VelocityJS: Trying to use an invalid number as a percentage:\", _name, part, key);\n                                } else {\n                                    if (!percents[String(percent)]) {\n                                        percents[String(percent)] = [];\n                                    }\n                                    percents[String(percent)].push(part);\n                                    for (var property in sequence[part]) {\n                                        if (!properties.includes(property)) {\n                                            properties.push(property);\n                                        }\n                                    }\n                                }\n                            }\n                        } catch (err) {\n                            _didIteratorError = true;\n                            _iteratorError = err;\n                        } finally {\n                            try {\n                                if (!_iteratorNormalCompletion && _iterator.return) {\n                                    _iterator.return();\n                                }\n                            } finally {\n                                if (_didIteratorError) {\n                                    throw _iteratorError;\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n            var orderedPercents = Object.keys(percents).sort(function (a, b) {\n                var a1 = parseFloat(a),\n                    b1 = parseFloat(b);\n                return a1 > b1 ? 1 : a1 < b1 ? -1 : 0;\n            });\n            orderedPercents.forEach(function (key) {\n                steps.push.apply(percents[key]);\n            });\n            var _iteratorNormalCompletion2 = true;\n            var _didIteratorError2 = false;\n            var _iteratorError2 = undefined;\n\n            try {\n                for (var _iterator2 = properties[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n                    var _property = _step2.value;\n\n                    var parts = [],\n                        propertyName = camelCase(_property);\n                    var _iteratorNormalCompletion3 = true;\n                    var _didIteratorError3 = false;\n                    var _iteratorError3 = undefined;\n\n                    try {\n                        for (var _iterator3 = orderedPercents[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {\n                            var _key = _step3.value;\n                            var _iteratorNormalCompletion6 = true;\n                            var _didIteratorError6 = false;\n                            var _iteratorError6 = undefined;\n\n                            try {\n                                for (var _iterator6 = percents[_key][Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {\n                                    var _value = _step6.value;\n\n                                    var stepProperties = sequence[_value];\n                                    if (stepProperties[propertyName]) {\n                                        parts.push(isString(stepProperties[propertyName]) ? stepProperties[propertyName] : stepProperties[propertyName][0]);\n                                    }\n                                }\n                            } catch (err) {\n                                _didIteratorError6 = true;\n                                _iteratorError6 = err;\n                            } finally {\n                                try {\n                                    if (!_iteratorNormalCompletion6 && _iterator6.return) {\n                                        _iterator6.return();\n                                    }\n                                } finally {\n                                    if (_didIteratorError6) {\n                                        throw _iteratorError6;\n                                    }\n                                }\n                            }\n                        }\n                    } catch (err) {\n                        _didIteratorError3 = true;\n                        _iteratorError3 = err;\n                    } finally {\n                        try {\n                            if (!_iteratorNormalCompletion3 && _iterator3.return) {\n                                _iterator3.return();\n                            }\n                        } finally {\n                            if (_didIteratorError3) {\n                                throw _iteratorError3;\n                            }\n                        }\n                    }\n\n                    if (parts.length) {\n                        var realSequence = findPattern(parts, propertyName);\n                        var index = 0;\n                        if (realSequence) {\n                            var _iteratorNormalCompletion4 = true;\n                            var _didIteratorError4 = false;\n                            var _iteratorError4 = undefined;\n\n                            try {\n                                for (var _iterator4 = orderedPercents[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {\n                                    var _key2 = _step4.value;\n                                    var _iteratorNormalCompletion5 = true;\n                                    var _didIteratorError5 = false;\n                                    var _iteratorError5 = undefined;\n\n                                    try {\n                                        for (var _iterator5 = percents[_key2][Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {\n                                            var value = _step5.value;\n\n                                            var originalProperty = sequence[value][propertyName];\n                                            if (originalProperty) {\n                                                if (Array.isArray(originalProperty) && originalProperty.length > 1 && (isString(originalProperty[1]) || Array.isArray(originalProperty[1]))) {\n                                                    realSequence[index].easing = validateEasing(originalProperty[1], sequenceList.duration || DEFAULT_DURATION);\n                                                }\n                                                realSequence[index++].percent = parseFloat(_key2) / 100;\n                                            }\n                                        }\n                                    } catch (err) {\n                                        _didIteratorError5 = true;\n                                        _iteratorError5 = err;\n                                    } finally {\n                                        try {\n                                            if (!_iteratorNormalCompletion5 && _iterator5.return) {\n                                                _iterator5.return();\n                                            }\n                                        } finally {\n                                            if (_didIteratorError5) {\n                                                throw _iteratorError5;\n                                            }\n                                        }\n                                    }\n                                }\n                            } catch (err) {\n                                _didIteratorError4 = true;\n                                _iteratorError4 = err;\n                            } finally {\n                                try {\n                                    if (!_iteratorNormalCompletion4 && _iterator4.return) {\n                                        _iterator4.return();\n                                    }\n                                } finally {\n                                    if (_didIteratorError4) {\n                                        throw _iteratorError4;\n                                    }\n                                }\n                            }\n\n                            sequenceList.tweens[propertyName] = realSequence;\n                        }\n                    }\n                }\n            } catch (err) {\n                _didIteratorError2 = true;\n                _iteratorError2 = err;\n            } finally {\n                try {\n                    if (!_iteratorNormalCompletion2 && _iterator2.return) {\n                        _iterator2.return();\n                    }\n                } finally {\n                    if (_didIteratorError2) {\n                        throw _iteratorError2;\n                    }\n                }\n            }\n        }\n    }\n}\nregisterAction([\"registerSequence\", registerSequence], true);\n\n// Project\nvar globalPromise = void 0;\ntry {\n    globalPromise = Promise;\n} catch ( /**/_a) {/**/}\nvar noPromiseOption = \", if that is deliberate then pass `promiseRejectEmpty:false` as an option\";\n/**\r\n * Patch a VelocityResult with a Promise.\r\n */\nfunction patchPromise(promiseObject, result) {\n    defineProperty$1(result, \"promise\", promiseObject);\n    defineProperty$1(result, \"then\", promiseObject.then.bind(promiseObject));\n    defineProperty$1(result, \"catch\", promiseObject.catch.bind(promiseObject));\n    if (promiseObject.finally) {\n        // Semi-standard\n        defineProperty$1(result, \"finally\", promiseObject.finally.bind(promiseObject));\n    }\n}\n/* tslint:enable:max-line-length */\nfunction Velocity$1() {\n    var\n    /**\r\n     * A shortcut to the default options.\r\n     */\n    defaults$$1 = defaults$1,\n\n    /**\r\n     * Cache of the first argument - this is used often enough to be saved.\r\n     */\n    args0 = arguments.length <= 0 ? undefined : arguments[0],\n\n    /**\r\n     * To allow for expressive CoffeeScript code, Velocity supports an\r\n     * alternative syntax in which \"elements\" (or \"e\"), \"properties\" (or\r\n     * \"p\"), and \"options\" (or \"o\") objects are defined on a container\r\n     * object that's passed in as Velocity's sole argument.\r\n     *\r\n     * Note: Some browsers automatically populate arguments with a\r\n     * \"properties\" object. We detect it by checking for its default\r\n     * \"names\" property.\r\n     */\n    // TODO: Confirm which browsers - if <=IE8 the we can drop completely\n    syntacticSugar = isPlainObject(args0) && (args0.p || isPlainObject(args0.properties) && !args0.properties.names || isString(args0.properties));\n    var\n    /**\r\n     *  When Velocity is called via the utility function (Velocity()),\r\n     * elements are explicitly passed in as the first parameter. Thus,\r\n     * argument positioning varies.\r\n     */\n    argumentIndex = 0,\n\n    /**\r\n     * The list of elements, extended with Promise and Velocity.\r\n     */\n    elements = void 0,\n\n    /**\r\n     * The properties being animated. This can be a string, in which case it\r\n     * is either a function for these elements, or it is a \"named\" animation\r\n     * sequence to use instead. Named sequences start with either \"callout.\"\r\n     * or \"transition.\". When used as a callout the values will be reset\r\n     * after finishing. When used as a transtition then there is no special\r\n     * handling after finishing.\r\n     */\n    propertiesMap = void 0,\n\n    /**\r\n     * Options supplied, this will be mapped and validated into\r\n     * <code>options</code>.\r\n     */\n    optionsMap = void 0,\n\n    /**\r\n     * If called via a chain then this contains the <b>last</b> calls\r\n     * animations. If this does not have a value then any access to the\r\n     * element's animations needs to be to the currently-running ones.\r\n     */\n    animations = void 0,\n\n    /**\r\n     * The promise that is returned.\r\n     */\n    promise = void 0,\n\n    // Used when the animation is finished\n    resolver = void 0,\n\n    // Used when there was an issue with one or more of the Velocity arguments\n    rejecter = void 0;\n    //console.log(`Velocity`, args)\n    // First get the elements, and the animations connected to the last call if\n    // this is chained.\n    // TODO: Clean this up a bit\n    // TODO: Throw error if the chain is called with elements as the first argument. isVelocityResult(this) && ( (isNode(arg0) || isWrapped(arg0)) && arg0 == this)\n    if (isNode(this)) {\n        // This is from a chain such as document.getElementById(\"\").velocity(...)\n        elements = [this];\n    } else if (isWrapped(this)) {\n        // This might be a chain from something else, but if chained from a\n        // previous Velocity() call then grab the animations it's related to.\n        elements = cloneArray(this);\n        if (isVelocityResult(this)) {\n            animations = this.velocity.animations;\n        }\n    } else if (syntacticSugar) {\n        elements = cloneArray(args0.elements || args0.e);\n        argumentIndex++;\n    } else if (isNode(args0)) {\n        elements = cloneArray([args0]);\n        argumentIndex++;\n    } else if (isWrapped(args0)) {\n        elements = cloneArray(args0);\n        argumentIndex++;\n    }\n    // Allow elements to be chained.\n    if (elements) {\n        defineProperty$1(elements, \"velocity\", Velocity$1.bind(elements));\n        if (animations) {\n            defineProperty$1(elements.velocity, \"animations\", animations);\n        }\n    }\n    // Next get the propertiesMap and options.\n    if (syntacticSugar) {\n        propertiesMap = getValue(args0.properties, args0.p);\n    } else {\n        var _ref;\n\n        // TODO: Should be possible to call Velocity(\"pauseAll\") - currently not possible\n        propertiesMap = (_ref = argumentIndex++, arguments.length <= _ref ? undefined : arguments[_ref]);\n    }\n    // Get any options map passed in as arguments first, expand any direct\n    // options if possible.\n    var isReverse = propertiesMap === \"reverse\",\n        isAction = !isReverse && isString(propertiesMap),\n        maybeSequence = isAction && SequencesObject[propertiesMap],\n        opts = syntacticSugar ? getValue(args0.options, args0.o) : arguments.length <= argumentIndex ? undefined : arguments[argumentIndex];\n    if (isPlainObject(opts)) {\n        optionsMap = opts;\n    }\n    // Create the promise if supported and wanted.\n    if (globalPromise && getValue(optionsMap && optionsMap.promise, defaults$$1.promise)) {\n        promise = new globalPromise(function (resolve, reject) {\n            rejecter = reject;\n            // IMPORTANT:\n            // If a resolver tries to run on a Promise then it will wait until\n            // that Promise resolves - but in this case we're running on our own\n            // Promise, so need to make sure it's not seen as one. Removing\n            // these values for the duration of the resolve.\n            // Due to being an async call, they should be back to \"normal\"\n            // before the <code>.then()</code> function gets called.\n            resolver = function resolver(result) {\n                if (isVelocityResult(result) && result.promise) {\n                    delete result.then;\n                    delete result.catch;\n                    delete result.finally;\n                    resolve(result);\n                    patchPromise(result.promise, result);\n                } else {\n                    resolve(result);\n                }\n            };\n        });\n        if (elements) {\n            patchPromise(promise, elements);\n        }\n    }\n    if (promise) {\n        var optionPromiseRejectEmpty = optionsMap && optionsMap.promiseRejectEmpty,\n            promiseRejectEmpty = getValue(optionPromiseRejectEmpty, defaults$$1.promiseRejectEmpty);\n        if (!elements && !isAction) {\n            if (promiseRejectEmpty) {\n                rejecter(\"Velocity: No elements supplied\" + (isBoolean(optionPromiseRejectEmpty) ? \"\" : noPromiseOption) + \". Aborting.\");\n            } else {\n                resolver();\n            }\n        } else if (!propertiesMap) {\n            if (promiseRejectEmpty) {\n                rejecter(\"Velocity: No properties supplied\" + (isBoolean(optionPromiseRejectEmpty) ? \"\" : noPromiseOption) + \". Aborting.\");\n            } else {\n                resolver();\n            }\n        }\n    }\n    if (!elements && !isAction || !propertiesMap) {\n        return promise;\n    }\n    // NOTE: Can't use isAction here due to type inference - there are callbacks\n    // between so the type isn't considered safe.\n    if (isAction) {\n        var actionArgs = [],\n            promiseHandler = promise && {\n            _promise: promise,\n            _resolver: resolver,\n            _rejecter: rejecter\n        };\n        while (argumentIndex < arguments.length) {\n            var _ref2;\n\n            actionArgs.push((_ref2 = argumentIndex++, arguments.length <= _ref2 ? undefined : arguments[_ref2]));\n        }\n        // Velocity's behavior is categorized into \"actions\". If a string is\n        // passed in instead of a propertiesMap then that will call a function\n        // to do something special to the animation linked.\n        // There is one special case - \"reverse\" - which is handled differently,\n        // by being stored on the animation and then expanded when the animation\n        // starts.\n        var action = propertiesMap.replace(/\\..*$/, \"\"),\n            callback = Actions[action];\n        if (callback) {\n            var result = callback(actionArgs, elements, promiseHandler, propertiesMap);\n            if (result !== undefined) {\n                return result;\n            }\n            return elements || promise;\n        } else if (!maybeSequence) {\n            console.error(\"VelocityJS: First argument (\" + propertiesMap + \") was not a property map, a known action, or a registered redirect. Aborting.\");\n            return;\n        }\n    }\n    var hasValidDuration = void 0;\n    if (isPlainObject(propertiesMap) || isReverse || maybeSequence) {\n        /**\r\n         * The options for this set of animations.\r\n         */\n        var options = {};\n        var isSync = defaults$$1.sync;\n        // Private options first - set as non-enumerable, and starting with an\n        // underscore so we can filter them out.\n        if (promise) {\n            defineProperty$1(options, \"_promise\", promise);\n            defineProperty$1(options, \"_rejecter\", rejecter);\n            defineProperty$1(options, \"_resolver\", resolver);\n        }\n        defineProperty$1(options, \"_ready\", 0);\n        defineProperty$1(options, \"_started\", 0);\n        defineProperty$1(options, \"_completed\", 0);\n        defineProperty$1(options, \"_total\", 0);\n        // Now check the optionsMap\n        if (isPlainObject(optionsMap)) {\n            var validDuration = validateDuration(optionsMap.duration);\n            hasValidDuration = validDuration !== undefined;\n            options.duration = getValue(validDuration, defaults$$1.duration);\n            options.delay = getValue(validateDelay(optionsMap.delay), defaults$$1.delay);\n            // Need the extra fallback here in case it supplies an invalid\n            // easing that we need to overrride with the default.\n            options.easing = validateEasing(getValue(optionsMap.easing, defaults$$1.easing), options.duration) || validateEasing(defaults$$1.easing, options.duration);\n            options.loop = getValue(validateLoop(optionsMap.loop), defaults$$1.loop);\n            options.repeat = options.repeatAgain = getValue(validateRepeat(optionsMap.repeat), defaults$$1.repeat);\n            if (optionsMap.speed != null) {\n                options.speed = getValue(validateSpeed(optionsMap.speed), 1);\n            }\n            if (isBoolean(optionsMap.promise)) {\n                options.promise = optionsMap.promise;\n            }\n            options.queue = getValue(validateQueue(optionsMap.queue), defaults$$1.queue);\n            if (optionsMap.mobileHA && !State.isGingerbread) {\n                /* When set to true, and if this is a mobile device, mobileHA automatically enables hardware acceleration (via a null transform hack)\r\n                 on animating elements. HA is removed from the element at the completion of its animation. */\n                /* Note: Android Gingerbread doesn't support HA. If a null transform hack (mobileHA) is in fact set, it will prevent other tranform subproperties from taking effect. */\n                /* Note: You can read more about the use of mobileHA in Velocity's documentation: velocity-animate/#mobileHA. */\n                options.mobileHA = true;\n            }\n            if (optionsMap.drag === true) {\n                options.drag = true;\n            }\n            if (isNumber(optionsMap.stagger) || isFunction(optionsMap.stagger)) {\n                options.stagger = optionsMap.stagger;\n            }\n            if (!isReverse) {\n                if (optionsMap[\"display\"] != null) {\n                    propertiesMap.display = optionsMap[\"display\"];\n                    console.error(\"Deprecated \\\"options.display\\\" used, this is now a property:\", optionsMap[\"display\"]);\n                }\n                if (optionsMap[\"visibility\"] != null) {\n                    propertiesMap.visibility = optionsMap[\"visibility\"];\n                    console.error(\"Deprecated \\\"options.visibility\\\" used, this is now a property:\", optionsMap[\"visibility\"]);\n                }\n            }\n            // TODO: Allow functional options for different options per element\n            var optionsBegin = validateBegin(optionsMap.begin),\n                optionsComplete = validateComplete(optionsMap.complete),\n                optionsProgress = validateProgress(optionsMap.progress),\n                optionsSync = validateSync(optionsMap.sync);\n            if (optionsBegin != null) {\n                options.begin = optionsBegin;\n            }\n            if (optionsComplete != null) {\n                options.complete = optionsComplete;\n            }\n            if (optionsProgress != null) {\n                options.progress = optionsProgress;\n            }\n            if (optionsSync != null) {\n                isSync = optionsSync;\n            }\n        } else if (!syntacticSugar) {\n            // Expand any direct options if possible.\n            var offset = 0;\n            options.duration = validateDuration(arguments.length <= argumentIndex ? undefined : arguments[argumentIndex], true);\n            if (options.duration === undefined) {\n                options.duration = defaults$$1.duration;\n            } else {\n                hasValidDuration = true;\n                offset++;\n            }\n            if (!isFunction(arguments.length <= argumentIndex + offset ? undefined : arguments[argumentIndex + offset])) {\n                // Despite coming before Complete, we can't pass a fn easing\n                var easing = validateEasing(arguments.length <= argumentIndex + offset ? undefined : arguments[argumentIndex + offset], getValue(options && validateDuration(options.duration), defaults$$1.duration), true);\n                if (easing !== undefined) {\n                    offset++;\n                    options.easing = easing;\n                }\n            }\n            var complete = validateComplete(arguments.length <= argumentIndex + offset ? undefined : arguments[argumentIndex + offset], true);\n            if (complete !== undefined) {\n                options.complete = complete;\n            }\n            options.delay = defaults$$1.delay;\n            options.loop = defaults$$1.loop;\n            options.repeat = options.repeatAgain = defaults$$1.repeat;\n        }\n        if (isReverse && options.queue === false) {\n            throw new Error(\"VelocityJS: Cannot reverse a queue:false animation.\");\n        }\n        if (!hasValidDuration && maybeSequence && maybeSequence.duration) {\n            options.duration = maybeSequence.duration;\n        }\n        // When a set of elements is targeted by a Velocity call, the set is\n        // broken up and each element has the current Velocity call individually\n        // queued onto it. In this way, each element's existing queue is\n        // respected; some elements may already be animating and accordingly\n        // should not have this current Velocity call triggered immediately\n        // unless the sync:true option is used.\n        var rootAnimation = {\n            options: options,\n            elements: elements,\n            _prev: undefined,\n            _next: undefined,\n            _flags: isSync ? 32 /* SYNC */ : 0,\n            percentComplete: 0,\n            ellapsedTime: 0,\n            timeStart: 0\n        };\n        animations = [];\n        for (var index = 0; index < elements.length; index++) {\n            var element = elements[index];\n            var flags = 0;\n            if (isNode(element)) {\n                // TODO: This needs to check for valid animation targets, not just Elements\n                if (isReverse) {\n                    var lastAnimation = Data(element).lastAnimationList[options.queue];\n                    propertiesMap = lastAnimation && lastAnimation.tweens;\n                    if (!propertiesMap) {\n                        console.error(\"VelocityJS: Attempting to reverse an animation on an element with no previous animation:\", element);\n                        continue;\n                    }\n                    flags |= 64 /* REVERSE */ & ~(lastAnimation._flags & 64 /* REVERSE */); // tslint:disable-line:no-bitwise\n                }\n                var animation = Object.assign({}, rootAnimation, { element: element, _flags: rootAnimation._flags | flags });\n                options._total++;\n                animations.push(animation);\n                if (options.stagger) {\n                    if (isFunction(options.stagger)) {\n                        var num = optionCallback(options.stagger, element, index, elements.length, elements, \"stagger\");\n                        if (isNumber(num)) {\n                            animation.delay = options.delay + num;\n                        }\n                    } else {\n                        animation.delay = options.delay + options.stagger * index;\n                    }\n                }\n                if (options.drag) {\n                    animation.duration = options.duration - options.duration * Math.max(1 - (index + 1) / elements.length, 0.75);\n                }\n                if (maybeSequence) {\n                    expandSequence(animation, maybeSequence);\n                } else if (isReverse) {\n                    // In this case we're using the previous animation, so\n                    // it will be expanded correctly when that one runs.\n                    animation.tweens = propertiesMap;\n                } else {\n                    animation.tweens = Object.create(null);\n                    expandProperties(animation, propertiesMap);\n                }\n                queue$1(element, animation, options.queue);\n            }\n        }\n        if (State.isTicking === false) {\n            // If the animation tick isn't running, start it. (Velocity shuts it\n            // off when there are no active calls to process.)\n            tick(false);\n        }\n        if (animations) {\n            defineProperty$1(elements.velocity, \"animations\", animations);\n        }\n    }\n    /***************\r\n     Chaining\r\n     ***************/\n    /* Return the elements back to the call chain, with wrapped elements taking precedence in case Velocity was called via the $.fn. extension. */\n    return elements || promise;\n}\n/**\r\n * Call an option callback in a try/catch block and report an error if needed.\r\n */\nfunction optionCallback(fn, element, index, length, elements, option) {\n    try {\n        return fn.call(element, index, length, elements, option);\n    } catch (e) {\n        console.error(\"VelocityJS: Exception when calling '\" + option + \"' callback:\", e);\n    }\n}\n\n// Project\n/**\r\n * Used to patch any object to allow Velocity chaining. In order to chain an\r\n * object must either be treatable as an array - with a <code>.length</code>\r\n * property, and each member a Node, or a Node directly.\r\n *\r\n * By default Velocity will try to patch <code>window</code>,\r\n * <code>jQuery</code>, <code>Zepto</code>, and several classes that return\r\n * Nodes or lists of Nodes.\r\n */\nfunction patch(proto, global) {\n    try {\n        defineProperty$1(proto, (global ? \"V\" : \"v\") + \"elocity\", Velocity$1);\n    } catch (e) {\n        console.warn(\"VelocityJS: Error when trying to add prototype.\", e);\n    }\n}\n\n// Project\nvar Velocity$2 = Velocity$1;\n/**\r\n * These parts of Velocity absolutely must be included, even if they're unused!\r\n */\nvar VelocityStatic$1;\n(function (VelocityStatic) {\n    /**\r\n     * Actions cannot be replaced if they are internal (hasOwnProperty is false\r\n     * but they still exist). Otherwise they can be replaced by users.\r\n     *\r\n     * All external method calls should be using actions rather than sub-calls\r\n     * of Velocity itself.\r\n     */\n    VelocityStatic.Actions = Actions;\n    /**\r\n     * Our known easing functions.\r\n     */\n    VelocityStatic.Easings = Easings;\n    /**\r\n     * The currently registered sequences.\r\n     */\n    VelocityStatic.Sequences = SequencesObject;\n    /**\r\n     * Current internal state of Velocity.\r\n     */\n    VelocityStatic.State = State; // tslint:disable-line:no-shadowed-variable\n    /**\r\n     * Velocity option defaults, which can be overriden by the user.\r\n     */\n    VelocityStatic.defaults = defaults$1;\n    /**\r\n     * Used to patch any object to allow Velocity chaining. In order to chain an\r\n     * object must either be treatable as an array - with a <code>.length</code>\r\n     * property, and each member a Node, or a Node directly.\r\n     *\r\n     * By default Velocity will try to patch <code>window</code>,\r\n     * <code>jQuery</code>, <code>Zepto</code>, and several classes that return\r\n     * Nodes or lists of Nodes.\r\n     */\n    VelocityStatic.patch = patch;\n    /**\r\n     * Set to true, 1 or 2 (most verbose) to output debug info to console.\r\n     */\n    VelocityStatic.debug = false;\n    /**\r\n     * In mock mode, all animations are forced to complete immediately upon the\r\n     * next rAF tick. If there are further animations queued then they will each\r\n     * take one single frame in turn. Loops and repeats will be disabled while\r\n     * <code>mock = true</code>.\r\n     */\n    VelocityStatic.mock = false;\n    /**\r\n     * Save our version number somewhere visible.\r\n     */\n    VelocityStatic.version = VERSION;\n    /**\r\n     * Added as a fallback for \"import {Velocity} from 'velocity-animate';\".\r\n     */\n    VelocityStatic.Velocity = Velocity$1; // tslint:disable-line:no-shadowed-variable\n})(VelocityStatic$1 || (VelocityStatic$1 = {}));\n/* IE detection. Gist: https://gist.github.com/julianshapiro/9098609 */\nvar IE$1 = function () {\n    if (document.documentMode) {\n        return document.documentMode;\n    } else {\n        for (var i = 7; i > 4; i--) {\n            var div = document.createElement(\"div\");\n            div.innerHTML = \"<!\" + \"--\" + \"[if IE \" + i + \"]><span></span><![endif]-->\";\n            if (div.getElementsByTagName(\"span\").length) {\n                div = null;\n                return i;\n            }\n        }\n    }\n    return undefined;\n}();\n/******************\r\n Unsupported\r\n ******************/\nif (IE$1 <= 8) {\n    throw new Error(\"VelocityJS cannot run on Internet Explorer 8 or earlier\");\n}\n/******************\r\n Frameworks\r\n ******************/\nif (window) {\n    /*\r\n     * Both jQuery and Zepto allow their $.fn object to be extended to allow\r\n     * wrapped elements to be subjected to plugin calls. If either framework is\r\n     * loaded, register a \"velocity\" extension pointing to Velocity's core\r\n     * animate() method. Velocity also registers itself onto a global container\r\n     * (window.jQuery || window.Zepto || window) so that certain features are\r\n     * accessible beyond just a per-element scope. Accordingly, Velocity can\r\n     * both act on wrapped DOM elements and stand alone for targeting raw DOM\r\n     * elements.\r\n     */\n    var jQuery$1 = window.jQuery,\n        Zepto$1 = window.Zepto;\n    patch(window, true);\n    patch(Element && Element.prototype);\n    patch(NodeList && NodeList.prototype);\n    patch(HTMLCollection && HTMLCollection.prototype);\n    patch(jQuery$1, true);\n    patch(jQuery$1 && jQuery$1.fn);\n    patch(Zepto$1, true);\n    patch(Zepto$1 && Zepto$1.fn);\n}\n// Make sure that the values within Velocity are read-only and upatchable.\n\nvar _loop$1 = function _loop(property) {\n    if (VelocityStatic$1.hasOwnProperty(property)) {\n        switch (typeof property === \"undefined\" ? \"undefined\" : _typeof(property)) {\n            case \"number\":\n            case \"boolean\":\n                defineProperty$1(Velocity$2, property, {\n                    get: function get$$1() {\n                        return VelocityStatic$1[property];\n                    },\n                    set: function set$$1(value) {\n                        VelocityStatic$1[property] = value;\n                    }\n                }, true);\n                break;\n            default:\n                defineProperty$1(Velocity$2, property, VelocityStatic$1[property], true);\n                break;\n        }\n    }\n};\n\nfor (var property$1 in VelocityStatic$1) {\n    _loop$1(property$1);\n}\nObject.freeze(Velocity$2);\n\nexport default Velocity$2;\n//# sourceMappingURL=velocity.es5.js.map\n","module.exports = require('./dist/theater.js')\n","(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n\ttypeof define === 'function' && define.amd ? define(factory) :\n\t(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Shuffle = factory());\n})(this, (function () { 'use strict';\n\n\tfunction getDefaultExportFromCjs (x) {\n\t\treturn x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;\n\t}\n\n\tvar tinyEmitter = {exports: {}};\n\n\tvar hasRequiredTinyEmitter;\n\n\tfunction requireTinyEmitter () {\n\t\tif (hasRequiredTinyEmitter) return tinyEmitter.exports;\n\t\thasRequiredTinyEmitter = 1;\n\t\tfunction E () {\n\t\t  // Keep this empty so it's easier to inherit from\n\t\t  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)\n\t\t}\n\n\t\tE.prototype = {\n\t\t  on: function (name, callback, ctx) {\n\t\t    var e = this.e || (this.e = {});\n\n\t\t    (e[name] || (e[name] = [])).push({\n\t\t      fn: callback,\n\t\t      ctx: ctx\n\t\t    });\n\n\t\t    return this;\n\t\t  },\n\n\t\t  once: function (name, callback, ctx) {\n\t\t    var self = this;\n\t\t    function listener () {\n\t\t      self.off(name, listener);\n\t\t      callback.apply(ctx, arguments);\n\t\t    }\n\t\t    listener._ = callback;\n\t\t    return this.on(name, listener, ctx);\n\t\t  },\n\n\t\t  emit: function (name) {\n\t\t    var data = [].slice.call(arguments, 1);\n\t\t    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();\n\t\t    var i = 0;\n\t\t    var len = evtArr.length;\n\n\t\t    for (i; i < len; i++) {\n\t\t      evtArr[i].fn.apply(evtArr[i].ctx, data);\n\t\t    }\n\n\t\t    return this;\n\t\t  },\n\n\t\t  off: function (name, callback) {\n\t\t    var e = this.e || (this.e = {});\n\t\t    var evts = e[name];\n\t\t    var liveEvents = [];\n\n\t\t    if (evts && callback) {\n\t\t      for (var i = 0, len = evts.length; i < len; i++) {\n\t\t        if (evts[i].fn !== callback && evts[i].fn._ !== callback)\n\t\t          liveEvents.push(evts[i]);\n\t\t      }\n\t\t    }\n\n\t\t    // Remove event from queue to prevent memory leak\n\t\t    // Suggested by https://github.com/lazd\n\t\t    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910\n\n\t\t    (liveEvents.length)\n\t\t      ? e[name] = liveEvents\n\t\t      : delete e[name];\n\n\t\t    return this;\n\t\t  }\n\t\t};\n\n\t\ttinyEmitter.exports = E;\n\t\ttinyEmitter.exports.TinyEmitter = E;\n\t\treturn tinyEmitter.exports;\n\t}\n\n\tvar tinyEmitterExports = requireTinyEmitter();\n\tvar TinyEmitter = /*@__PURE__*/getDefaultExportFromCjs(tinyEmitterExports);\n\n\tvar arrayParallel;\n\tvar hasRequiredArrayParallel;\n\n\tfunction requireArrayParallel () {\n\t\tif (hasRequiredArrayParallel) return arrayParallel;\n\t\thasRequiredArrayParallel = 1;\n\t\tarrayParallel = function parallel(fns, context, callback) {\n\t\t  if (!callback) {\n\t\t    if (typeof context === 'function') {\n\t\t      callback = context;\n\t\t      context = null;\n\t\t    } else {\n\t\t      callback = noop;\n\t\t    }\n\t\t  }\n\n\t\t  var pending = fns && fns.length;\n\t\t  if (!pending) return callback(null, []);\n\n\t\t  var finished = false;\n\t\t  var results = new Array(pending);\n\n\t\t  fns.forEach(context ? function (fn, i) {\n\t\t    fn.call(context, maybeDone(i));\n\t\t  } : function (fn, i) {\n\t\t    fn(maybeDone(i));\n\t\t  });\n\n\t\t  function maybeDone(i) {\n\t\t    return function (err, result) {\n\t\t      if (finished) return;\n\n\t\t      if (err) {\n\t\t        callback(err, results);\n\t\t        finished = true;\n\t\t        return\n\t\t      }\n\n\t\t      results[i] = result;\n\n\t\t      if (!--pending) callback(null, results);\n\t\t    }\n\t\t  }\n\t\t};\n\n\t\tfunction noop() {}\n\t\treturn arrayParallel;\n\t}\n\n\tvar arrayParallelExports = requireArrayParallel();\n\tvar parallel = /*@__PURE__*/getDefaultExportFromCjs(arrayParallelExports);\n\n\t/**\n\t * Always returns a numeric value, given a value. Logic from jQuery's `isNumeric`.\n\t * @param {*} value Possibly numeric value.\n\t * @return {number} `value` or zero if `value` isn't numeric.\n\t */\n\tfunction getNumber(value) {\n\t  return parseFloat(value) || 0;\n\t}\n\n\tclass Point {\n\t  /**\n\t   * Represents a coordinate pair.\n\t   * @param {number} [x=0] X.\n\t   * @param {number} [y=0] Y.\n\t   */\n\t  constructor(x, y) {\n\t    this.x = getNumber(x);\n\t    this.y = getNumber(y);\n\t  }\n\n\t  /**\n\t   * Whether two points are equal.\n\t   * @param {Point} a Point A.\n\t   * @param {Point} b Point B.\n\t   * @return {boolean}\n\t   */\n\t  static equals(a, b) {\n\t    return a.x === b.x && a.y === b.y;\n\t  }\n\t}\n\n\tclass Rect {\n\t  /**\n\t   * Class for representing rectangular regions.\n\t   * https://github.com/google/closure-library/blob/master/closure/goog/math/rect.js\n\t   * @param {number} x Left.\n\t   * @param {number} y Top.\n\t   * @param {number} w Width.\n\t   * @param {number} h Height.\n\t   * @param {number} id Identifier\n\t   * @constructor\n\t   */\n\t  constructor(x, y, w, h, id) {\n\t    this.id = id;\n\n\t    /** @type {number} */\n\t    this.left = x;\n\n\t    /** @type {number} */\n\t    this.top = y;\n\n\t    /** @type {number} */\n\t    this.width = w;\n\n\t    /** @type {number} */\n\t    this.height = h;\n\t  }\n\n\t  /**\n\t   * Returns whether two rectangles intersect.\n\t   * @param {Rect} a A Rectangle.\n\t   * @param {Rect} b A Rectangle.\n\t   * @return {boolean} Whether a and b intersect.\n\t   */\n\t  static intersects(a, b) {\n\t    return a.left < b.left + b.width && b.left < a.left + a.width && a.top < b.top + b.height && b.top < a.top + a.height;\n\t  }\n\t}\n\n\tvar Classes = {\n\t  BASE: 'shuffle',\n\t  SHUFFLE_ITEM: 'shuffle-item',\n\t  VISIBLE: 'shuffle-item--visible',\n\t  HIDDEN: 'shuffle-item--hidden'\n\t};\n\n\tlet id$1 = 0;\n\tclass ShuffleItem {\n\t  constructor(element, isRTL) {\n\t    id$1 += 1;\n\t    this.id = id$1;\n\t    this.element = element;\n\n\t    /**\n\t     * Set correct direction of item\n\t     */\n\t    this.isRTL = isRTL;\n\n\t    /**\n\t     * Used to separate items for layout and shrink.\n\t     */\n\t    this.isVisible = true;\n\n\t    /**\n\t     * Used to determine if a transition will happen. By the time the _layout\n\t     * and _shrink methods get the ShuffleItem instances, the `isVisible` value\n\t     * has already been changed by the separation methods, so this property is\n\t     * needed to know if the item was visible/hidden before the shrink/layout.\n\t     */\n\t    this.isHidden = false;\n\t  }\n\t  show() {\n\t    this.isVisible = true;\n\t    this.element.classList.remove(Classes.HIDDEN);\n\t    this.element.classList.add(Classes.VISIBLE);\n\t    this.element.removeAttribute('aria-hidden');\n\t  }\n\t  hide() {\n\t    this.isVisible = false;\n\t    this.element.classList.remove(Classes.VISIBLE);\n\t    this.element.classList.add(Classes.HIDDEN);\n\t    this.element.setAttribute('aria-hidden', true);\n\t  }\n\t  init() {\n\t    this.addClasses([Classes.SHUFFLE_ITEM, Classes.VISIBLE]);\n\t    this.applyCss(ShuffleItem.Css.INITIAL);\n\t    this.applyCss(this.isRTL ? ShuffleItem.Css.DIRECTION.rtl : ShuffleItem.Css.DIRECTION.ltr);\n\t    this.scale = ShuffleItem.Scale.VISIBLE;\n\t    this.point = new Point();\n\t  }\n\t  addClasses(classes) {\n\t    classes.forEach(className => {\n\t      this.element.classList.add(className);\n\t    });\n\t  }\n\t  removeClasses(classes) {\n\t    classes.forEach(className => {\n\t      this.element.classList.remove(className);\n\t    });\n\t  }\n\t  applyCss(obj) {\n\t    Object.keys(obj).forEach(key => {\n\t      this.element.style[key] = obj[key];\n\t    });\n\t  }\n\t  dispose() {\n\t    this.removeClasses([Classes.HIDDEN, Classes.VISIBLE, Classes.SHUFFLE_ITEM]);\n\t    this.element.removeAttribute('style');\n\t    this.element = null;\n\t  }\n\t}\n\tShuffleItem.Css = {\n\t  INITIAL: {\n\t    position: 'absolute',\n\t    top: 0,\n\t    visibility: 'visible',\n\t    willChange: 'transform'\n\t  },\n\t  DIRECTION: {\n\t    ltr: {\n\t      left: 0\n\t    },\n\t    rtl: {\n\t      right: 0\n\t    }\n\t  },\n\t  VISIBLE: {\n\t    before: {\n\t      opacity: 1,\n\t      visibility: 'visible'\n\t    },\n\t    after: {\n\t      transitionDelay: ''\n\t    }\n\t  },\n\t  HIDDEN: {\n\t    before: {\n\t      opacity: 0\n\t    },\n\t    after: {\n\t      visibility: 'hidden',\n\t      transitionDelay: ''\n\t    }\n\t  }\n\t};\n\tShuffleItem.Scale = {\n\t  VISIBLE: 1,\n\t  HIDDEN: 0.001\n\t};\n\n\tlet value = null;\n\tvar testComputedSize = () => {\n\t  if (value !== null) {\n\t    return value;\n\t  }\n\t  const element = document.body || document.documentElement;\n\t  const e = document.createElement('div');\n\t  e.style.cssText = 'width:10px;padding:2px;box-sizing:border-box;';\n\t  element.appendChild(e);\n\t  const {\n\t    width\n\t  } = window.getComputedStyle(e, null);\n\t  // Fix for issue #314\n\t  value = Math.round(getNumber(width)) === 10;\n\t  element.removeChild(e);\n\t  return value;\n\t};\n\n\t/**\n\t * Retrieve the computed style for an element, parsed as a float.\n\t * @param {Element} element Element to get style for.\n\t * @param {string} style Style property.\n\t * @param {CSSStyleDeclaration} [styles] Optionally include clean styles to\n\t *     use instead of asking for them again.\n\t * @return {number} The parsed computed value or zero if that fails because IE\n\t *     will return 'auto' when the element doesn't have margins instead of\n\t *     the computed style.\n\t */\n\tfunction getNumberStyle(element, style, styles = window.getComputedStyle(element, null)) {\n\t  let value = getNumber(styles[style]);\n\n\t  // Support IE<=11 and W3C spec.\n\t  if (!testComputedSize() && style === 'width') {\n\t    value += getNumber(styles.paddingLeft) + getNumber(styles.paddingRight) + getNumber(styles.borderLeftWidth) + getNumber(styles.borderRightWidth);\n\t  } else if (!testComputedSize() && style === 'height') {\n\t    value += getNumber(styles.paddingTop) + getNumber(styles.paddingBottom) + getNumber(styles.borderTopWidth) + getNumber(styles.borderBottomWidth);\n\t  }\n\t  return value;\n\t}\n\n\t/**\n\t * Fisher-Yates shuffle.\n\t * http://stackoverflow.com/a/962890/373422\n\t * https://bost.ocks.org/mike/shuffle/\n\t * @param {Array} array Array to shuffle.\n\t * @return {Array} Randomly sorted array.\n\t */\n\tfunction randomize(array) {\n\t  let n = array.length;\n\t  while (n) {\n\t    n -= 1;\n\t    const i = Math.floor(Math.random() * (n + 1));\n\t    const temp = array[i];\n\t    array[i] = array[n];\n\t    array[n] = temp;\n\t  }\n\t  return array;\n\t}\n\tconst defaults = {\n\t  // Use array.reverse() to reverse the results\n\t  reverse: false,\n\t  // Sorting function\n\t  by: null,\n\t  // Custom sort function\n\t  compare: null,\n\t  // If true, this will skip the sorting and return a randomized order in the array\n\t  randomize: false,\n\t  // Determines which property of each item in the array is passed to the\n\t  // sorting method.\n\t  key: 'element'\n\t};\n\n\t/**\n\t * You can return `undefined` from the `by` function to revert to DOM order.\n\t * @param {Array<T>} arr Array to sort.\n\t * @param {SortOptions} options Sorting options.\n\t * @return {Array<T>}\n\t */\n\tfunction sorter(arr, options) {\n\t  const opts = {\n\t    ...defaults,\n\t    ...options\n\t  };\n\t  const original = Array.from(arr);\n\t  let revert = false;\n\t  if (!arr.length) {\n\t    return [];\n\t  }\n\t  if (opts.randomize) {\n\t    return randomize(arr);\n\t  }\n\n\t  // Sort the elements by the opts.by function.\n\t  // If we don't have opts.by, default to DOM order\n\t  if (typeof opts.by === 'function') {\n\t    arr.sort((a, b) => {\n\t      // Exit early if we already know we want to revert\n\t      if (revert) {\n\t        return 0;\n\t      }\n\t      const valA = opts.by(a[opts.key]);\n\t      const valB = opts.by(b[opts.key]);\n\n\t      // If both values are undefined, use the DOM order\n\t      if (valA === undefined && valB === undefined) {\n\t        revert = true;\n\t        return 0;\n\t      }\n\t      if (valA < valB || valA === 'sortFirst' || valB === 'sortLast') {\n\t        return -1;\n\t      }\n\t      if (valA > valB || valA === 'sortLast' || valB === 'sortFirst') {\n\t        return 1;\n\t      }\n\t      return 0;\n\t    });\n\t  } else if (typeof opts.compare === 'function') {\n\t    arr.sort(opts.compare);\n\t  }\n\n\t  // Revert to the original array if necessary\n\t  if (revert) {\n\t    return original;\n\t  }\n\t  if (opts.reverse) {\n\t    arr.reverse();\n\t  }\n\t  return arr;\n\t}\n\n\tconst transitions = {};\n\tconst eventName = 'transitionend';\n\tlet count = 0;\n\tfunction uniqueId() {\n\t  count += 1;\n\t  return eventName + count;\n\t}\n\tfunction cancelTransitionEnd(id) {\n\t  if (transitions[id]) {\n\t    transitions[id].element.removeEventListener(eventName, transitions[id].listener);\n\t    transitions[id] = null;\n\t    return true;\n\t  }\n\t  return false;\n\t}\n\tfunction onTransitionEnd(element, callback) {\n\t  const id = uniqueId();\n\t  const listener = evt => {\n\t    if (evt.currentTarget === evt.target) {\n\t      cancelTransitionEnd(id);\n\t      callback(evt);\n\t    }\n\t  };\n\t  element.addEventListener(eventName, listener);\n\t  transitions[id] = {\n\t    element,\n\t    listener\n\t  };\n\t  return id;\n\t}\n\n\tfunction arrayMax(array) {\n\t  return Math.max(...array);\n\t}\n\n\tfunction arrayMin(array) {\n\t  return Math.min(...array);\n\t}\n\n\t/**\n\t * Determine the number of columns an items spans.\n\t * @param {number} itemWidth Width of the item.\n\t * @param {number} columnWidth Width of the column (includes gutter).\n\t * @param {number} columns Total number of columns\n\t * @param {number} threshold A buffer value for the size of the column to fit.\n\t * @return {number}\n\t */\n\tfunction getColumnSpan(itemWidth, columnWidth, columns, threshold) {\n\t  let columnSpan = itemWidth / columnWidth;\n\n\t  // If the difference between the rounded column span number and the\n\t  // calculated column span number is really small, round the number to\n\t  // make it fit.\n\t  if (Math.abs(Math.round(columnSpan) - columnSpan) < threshold) {\n\t    // e.g. columnSpan = 4.0089945390298745\n\t    columnSpan = Math.round(columnSpan);\n\t  }\n\n\t  // Ensure the column span is not more than the amount of columns in the whole layout.\n\t  return Math.min(Math.ceil(columnSpan), columns);\n\t}\n\n\t/**\n\t * Retrieves the column set to use for placement.\n\t * @param {number} columnSpan The number of columns this current item spans.\n\t * @param {number} columns The total columns in the grid.\n\t * @return {Array.<number>} An array of numbers representing the column set.\n\t */\n\tfunction getAvailablePositions(positions, columnSpan, columns) {\n\t  // The item spans only one column.\n\t  if (columnSpan === 1) {\n\t    return positions;\n\t  }\n\n\t  // The item spans more than one column, figure out how many different\n\t  // places it could fit horizontally.\n\t  // The group count is the number of places within the positions this block\n\t  // could fit, ignoring the current positions of items.\n\t  // Imagine a 2 column brick as the second item in a 4 column grid with\n\t  // 10px height each. Find the places it would fit:\n\t  // [20, 10, 10, 0]\n\t  //  |   |   |\n\t  //  *   *   *\n\t  //\n\t  // Then take the places which fit and get the bigger of the two:\n\t  // max([20, 10]), max([10, 10]), max([10, 0]) = [20, 10, 10]\n\t  //\n\t  // Next, find the first smallest number (the short column).\n\t  // [20, 10, 10]\n\t  //      |\n\t  //      *\n\t  //\n\t  // And that's where it should be placed!\n\t  //\n\t  // Another example where the second column's item extends past the first:\n\t  // [10, 20, 10, 0] => [20, 20, 10] => 10\n\t  const available = [];\n\n\t  // For how many possible positions for this item there are.\n\t  for (let i = 0; i <= columns - columnSpan; i++) {\n\t    // Find the bigger value for each place it could fit.\n\t    available.push(arrayMax(positions.slice(i, i + columnSpan)));\n\t  }\n\t  return available;\n\t}\n\n\t/**\n\t * Find index of short column, the first from the left where this item will go.\n\t *\n\t * @param {Array.<number>} positions The array to search for the smallest number.\n\t * @param {number} buffer Optional buffer which is very useful when the height\n\t *     is a percentage of the width.\n\t * @return {number} Index of the short column.\n\t */\n\tfunction getShortColumn(positions, buffer) {\n\t  const minPosition = arrayMin(positions);\n\t  for (let i = 0, len = positions.length; i < len; i++) {\n\t    if (positions[i] >= minPosition - buffer && positions[i] <= minPosition + buffer) {\n\t      return i;\n\t    }\n\t  }\n\t  return 0;\n\t}\n\n\t/**\n\t * Determine the location of the next item, based on its size.\n\t * @param {Object} itemSize Object with width and height.\n\t * @param {Array.<number>} positions Positions of the other current items.\n\t * @param {number} gridSize The column width or row height.\n\t * @param {number} total The total number of columns or rows.\n\t * @param {number} threshold Buffer value for the column to fit.\n\t * @param {number} buffer Vertical buffer for the height of items.\n\t * @return {Point}\n\t */\n\tfunction getItemPosition({\n\t  itemSize,\n\t  positions,\n\t  gridSize,\n\t  total,\n\t  threshold,\n\t  buffer\n\t}) {\n\t  const span = getColumnSpan(itemSize.width, gridSize, total, threshold);\n\t  const setY = getAvailablePositions(positions, span, total);\n\t  const shortColumnIndex = getShortColumn(setY, buffer);\n\n\t  // Position the item\n\t  const point = new Point(gridSize * shortColumnIndex, setY[shortColumnIndex]);\n\n\t  // Update the columns array with the new values for each column.\n\t  // e.g. before the update the columns could be [250, 0, 0, 0] for an item\n\t  // which spans 2 columns. After it would be [250, itemHeight, itemHeight, 0].\n\t  const setHeight = setY[shortColumnIndex] + itemSize.height;\n\t  for (let i = 0; i < span; i++) {\n\t    positions[shortColumnIndex + i] = setHeight;\n\t  }\n\t  return point;\n\t}\n\n\t/**\n\t * This method attempts to center items. This method could potentially be slow\n\t * with a large number of items because it must place items, then check every\n\t * previous item to ensure there is no overlap.\n\t * @param {Array.<Rect>} itemRects Item data objects.\n\t * @param {number} containerWidth Width of the containing element.\n\t * @return {Array.<Point>}\n\t */\n\tfunction getCenteredPositions(itemRects, containerWidth) {\n\t  const rowMap = {};\n\n\t  // Populate rows by their offset because items could jump between rows like:\n\t  // a   c\n\t  //  bbb\n\t  itemRects.forEach(itemRect => {\n\t    if (rowMap[itemRect.top]) {\n\t      // Push the point to the last row array.\n\t      rowMap[itemRect.top].push(itemRect);\n\t    } else {\n\t      // Start of a new row.\n\t      rowMap[itemRect.top] = [itemRect];\n\t    }\n\t  });\n\n\t  // For each row, find the end of the last item, then calculate\n\t  // the remaining space by dividing it by 2. Then add that\n\t  // offset to the x position of each point.\n\t  let rects = [];\n\t  const rows = [];\n\t  const centeredRows = [];\n\t  Object.keys(rowMap).forEach(key => {\n\t    const itemRects = rowMap[key];\n\t    rows.push(itemRects);\n\t    const lastItem = itemRects[itemRects.length - 1];\n\t    const end = lastItem.left + lastItem.width;\n\t    const offset = Math.round((containerWidth - end) / 2);\n\t    let finalRects = itemRects;\n\t    let canMove = false;\n\t    if (offset > 0) {\n\t      const newRects = [];\n\t      canMove = itemRects.every(r => {\n\t        const newRect = new Rect(r.left + offset, r.top, r.width, r.height, r.id);\n\n\t        // Check all current rects to make sure none overlap.\n\t        const noOverlap = !rects.some(r => Rect.intersects(newRect, r));\n\t        newRects.push(newRect);\n\t        return noOverlap;\n\t      });\n\n\t      // If none of the rectangles overlapped, the whole group can be centered.\n\t      if (canMove) {\n\t        finalRects = newRects;\n\t      }\n\t    }\n\n\t    // If the items are not going to be offset, ensure that the original\n\t    // placement for this row will not overlap previous rows (row-spanning\n\t    // elements could be in the way).\n\t    if (!canMove) {\n\t      let intersectingRect;\n\t      const hasOverlap = itemRects.some(itemRect => rects.some(r => {\n\t        const intersects = Rect.intersects(itemRect, r);\n\t        if (intersects) {\n\t          intersectingRect = r;\n\t        }\n\t        return intersects;\n\t      }));\n\n\t      // If there is any overlap, replace the overlapping row with the original.\n\t      if (hasOverlap) {\n\t        const rowIndex = centeredRows.findIndex(items => items.includes(intersectingRect));\n\t        centeredRows.splice(rowIndex, 1, rows[rowIndex]);\n\t      }\n\t    }\n\t    rects = rects.concat(finalRects);\n\t    centeredRows.push(finalRects);\n\t  });\n\n\t  // Reduce array of arrays to a single array of points.\n\t  // https://stackoverflow.com/a/10865042/373422\n\t  // Then reset sort back to how the items were passed to this method.\n\t  // Remove the wrapper object with index, map to a Point.\n\t  return centeredRows.flat().sort((a, b) => a.id - b.id).map(itemRect => new Point(itemRect.left, itemRect.top));\n\t}\n\n\t/**\n\t * Hyphenates a javascript style string to a css one. For example:\n\t * MozBoxSizing -> -moz-box-sizing.\n\t * @param {string} str The string to hyphenate.\n\t * @return {string} The hyphenated string.\n\t */\n\tfunction hyphenate(str) {\n\t  return str.replace(/([A-Z])/g, (str, m1) => `-${m1.toLowerCase()}`);\n\t}\n\n\tfunction arrayUnique(x) {\n\t  return Array.from(new Set(x));\n\t}\n\n\t// Used for unique instance variables\n\tlet id = 0;\n\tclass Shuffle extends TinyEmitter {\n\t  /**\n\t   * Categorize, sort, and filter a responsive grid of items.\n\t   *\n\t   * @param {Element} element An element which is the parent container for the grid items.\n\t   * @param {Object} [options=Shuffle.options] Options object.\n\t   * @constructor\n\t   */\n\t  constructor(element, options = {}) {\n\t    super();\n\t    this.options = {\n\t      ...Shuffle.options,\n\t      ...options\n\t    };\n\t    this.lastSort = {};\n\t    this.group = Shuffle.ALL_ITEMS;\n\t    this.lastFilter = Shuffle.ALL_ITEMS;\n\t    this.isEnabled = true;\n\t    this.isDestroyed = false;\n\t    this.isInitialized = false;\n\t    this._transitions = [];\n\t    this.isTransitioning = false;\n\t    this._queue = [];\n\t    const el = this._getElementOption(element);\n\t    if (!el) {\n\t      throw new TypeError('Shuffle needs to be initialized with an element.');\n\t    }\n\t    this.element = el;\n\t    this.id = `shuffle_${id}`;\n\t    id += 1;\n\t    this._init();\n\t    this.isInitialized = true;\n\t  }\n\t  _init() {\n\t    this.items = this._getItems();\n\t    this.sortedItems = this.items;\n\t    this.options.sizer = this._getElementOption(this.options.sizer);\n\n\t    // Add class and invalidate styles\n\t    this.element.classList.add(Shuffle.Classes.BASE);\n\n\t    // Set initial css for each item\n\t    this._initItems(this.items);\n\n\t    // If the page has not already emitted the `load` event, call layout on load.\n\t    // This avoids layout issues caused by images and fonts loading after the\n\t    // instance has been initialized.\n\t    if (document.readyState !== 'complete') {\n\t      const layout = this.layout.bind(this);\n\t      window.addEventListener('load', function onLoad() {\n\t        window.removeEventListener('load', onLoad);\n\t        layout();\n\t      });\n\t    }\n\n\t    // Get container css all in one request. Causes reflow\n\t    const containerCss = window.getComputedStyle(this.element, null);\n\t    const containerWidth = Shuffle.getSize(this.element).width;\n\n\t    // Add styles to the container if it doesn't have them.\n\t    this._validateStyles(containerCss);\n\n\t    // We already got the container's width above, no need to cause another\n\t    // reflow getting it again... Calculate the number of columns there will be\n\t    this._setColumns(containerWidth);\n\n\t    // Kick off!\n\t    this.filter(this.options.group, this.options.initialSort);\n\n\t    // Bind resize events\n\t    this._rafId = null;\n\t    // This is true for all supported browsers, but just to be safe, avoid throwing\n\t    // an error if ResizeObserver is not present. You can manually add a window resize\n\t    // event and call `update()` if ResizeObserver is missing, or use Shuffle v5.\n\t    if ('ResizeObserver' in window) {\n\t      this._resizeObserver = new ResizeObserver(this._handleResizeCallback.bind(this));\n\t      this._resizeObserver.observe(this.element);\n\t    }\n\n\t    // The shuffle items haven't had transitions set on them yet so the user\n\t    // doesn't see the first layout. Set them now that the first layout is done.\n\t    // First, however, a synchronous layout must be caused for the previous\n\t    // styles to be applied without transitions.\n\t    this.element.offsetWidth; // eslint-disable-line no-unused-expressions\n\t    this.setItemTransitions(this.items);\n\t    this.element.style.transition = `height ${this.options.speed}ms ${this.options.easing}`;\n\t  }\n\n\t  /**\n\t   * Retrieve an element from an option.\n\t   * @param {string|jQuery|Element} option The option to check.\n\t   * @return {?Element} The plain element or null.\n\t   * @private\n\t   */\n\t  _getElementOption(option) {\n\t    // If column width is a string, treat is as a selector and search for the\n\t    // sizer element within the outermost container\n\t    if (typeof option === 'string') {\n\t      return this.element.querySelector(option);\n\t    }\n\n\t    // Check for an element\n\t    if (option && option.nodeType && option.nodeType === 1) {\n\t      return option;\n\t    }\n\n\t    // Check for jQuery object\n\t    if (option && option.jquery) {\n\t      return option[0];\n\t    }\n\t    return null;\n\t  }\n\n\t  /**\n\t   * Ensures the shuffle container has the css styles it needs applied to it.\n\t   * @param {Object} styles Key value pairs for position and overflow.\n\t   * @private\n\t   */\n\t  _validateStyles(styles) {\n\t    // Position cannot be static.\n\t    if (styles.position === 'static') {\n\t      this.element.style.position = 'relative';\n\t    }\n\n\t    // Overflow has to be hidden.\n\t    if (styles.overflow !== 'hidden') {\n\t      this.element.style.overflow = 'hidden';\n\t    }\n\t  }\n\n\t  /**\n\t   * Filter the elements by a category.\n\t   * @param {string|string[]|function(Element):boolean} [category] Category to\n\t   *     filter by. If it's given, the last category will be used to filter the items.\n\t   * @param {Array} [collection] Optionally filter a collection. Defaults to\n\t   *     all the items.\n\t   * @return {{visible: ShuffleItem[], hidden: ShuffleItem[]}}\n\t   * @private\n\t   */\n\t  _filter(category = this.lastFilter, collection = this.items) {\n\t    const set = this._getFilteredSets(category, collection);\n\n\t    // Individually add/remove hidden/visible classes\n\t    this._toggleFilterClasses(set);\n\n\t    // Save the last filter in case elements are appended.\n\t    this.lastFilter = category;\n\n\t    // This is saved mainly because providing a filter function (like searching)\n\t    // will overwrite the `lastFilter` property every time its called.\n\t    if (typeof category === 'string') {\n\t      this.group = category;\n\t    }\n\t    return set;\n\t  }\n\n\t  /**\n\t   * Returns an object containing the visible and hidden elements.\n\t   * @param {string|string[]|function(Element):boolean} category Category or function to filter by.\n\t   * @param {ShuffleItem[]} items A collection of items to filter.\n\t   * @return {{visible: ShuffleItem[], hidden: ShuffleItem[]}}\n\t   * @private\n\t   */\n\t  _getFilteredSets(category, items) {\n\t    let visible = [];\n\t    const hidden = [];\n\n\t    // category === 'all', add visible class to everything\n\t    if (category === Shuffle.ALL_ITEMS) {\n\t      visible = items;\n\n\t      // Loop through each item and use provided function to determine\n\t      // whether to hide it or not.\n\t    } else {\n\t      items.forEach(item => {\n\t        if (this._doesPassFilter(category, item.element)) {\n\t          visible.push(item);\n\t        } else {\n\t          hidden.push(item);\n\t        }\n\t      });\n\t    }\n\t    return {\n\t      visible,\n\t      hidden\n\t    };\n\t  }\n\n\t  /**\n\t   * Test an item to see if it passes a category.\n\t   * @param {string|string[]|function():boolean} category Category or function to filter by.\n\t   * @param {Element} element An element to test.\n\t   * @return {boolean} Whether it passes the category/filter.\n\t   * @private\n\t   */\n\t  _doesPassFilter(category, element) {\n\t    if (typeof category === 'function') {\n\t      return category.call(element, element, this);\n\t    }\n\n\t    // Check each element's data-groups attribute against the given category.\n\t    const attr = element.dataset[Shuffle.FILTER_ATTRIBUTE_KEY];\n\t    const keys = this.options.delimiter ? attr.split(this.options.delimiter) : JSON.parse(attr);\n\t    function testCategory(category) {\n\t      return keys.includes(category);\n\t    }\n\t    if (Array.isArray(category)) {\n\t      if (this.options.filterMode === Shuffle.FilterMode.ANY) {\n\t        return category.some(testCategory);\n\t      }\n\t      return category.every(testCategory);\n\t    }\n\t    return keys.includes(category);\n\t  }\n\n\t  /**\n\t   * Toggles the visible and hidden class names.\n\t   * @param {{visible, hidden}} Object with visible and hidden arrays.\n\t   * @private\n\t   */\n\t  _toggleFilterClasses({\n\t    visible,\n\t    hidden\n\t  }) {\n\t    visible.forEach(item => {\n\t      item.show();\n\t    });\n\t    hidden.forEach(item => {\n\t      item.hide();\n\t    });\n\t  }\n\n\t  /**\n\t   * Set the initial css for each item\n\t   * @param {ShuffleItem[]} items Set to initialize.\n\t   * @private\n\t   */\n\t  _initItems(items) {\n\t    items.forEach(item => {\n\t      item.init();\n\t    });\n\t  }\n\n\t  /**\n\t   * Remove element reference and styles.\n\t   * @param {ShuffleItem[]} items Set to dispose.\n\t   * @private\n\t   */\n\t  _disposeItems(items) {\n\t    items.forEach(item => {\n\t      item.dispose();\n\t    });\n\t  }\n\n\t  /**\n\t   * Updates the visible item count.\n\t   * @private\n\t   */\n\t  _updateItemCount() {\n\t    this.visibleItems = this._getFilteredItems().length;\n\t  }\n\n\t  /**\n\t   * Sets css transform transition on a group of elements. This is not executed\n\t   * at the same time as `item.init` so that transitions don't occur upon\n\t   * initialization of a new Shuffle instance.\n\t   * @param {ShuffleItem[]} items Shuffle items to set transitions on.\n\t   * @protected\n\t   */\n\t  setItemTransitions(items) {\n\t    const {\n\t      speed,\n\t      easing\n\t    } = this.options;\n\t    const positionProps = this.options.useTransforms ? ['transform'] : ['top', 'left'];\n\n\t    // Allow users to transition other properties if they exist in the `before`\n\t    // css mapping of the shuffle item.\n\t    const cssProps = Object.keys(ShuffleItem.Css.HIDDEN.before).map(k => hyphenate(k));\n\t    const properties = positionProps.concat(cssProps).join();\n\t    items.forEach(item => {\n\t      item.element.style.transitionDuration = `${speed}ms`;\n\t      item.element.style.transitionTimingFunction = easing;\n\t      item.element.style.transitionProperty = properties;\n\t    });\n\t  }\n\t  _getItems() {\n\t    return Array.from(this.element.children).filter(el => el.matches(this.options.itemSelector)).map(el => new ShuffleItem(el, this.options.isRTL));\n\t  }\n\n\t  /**\n\t   * Combine the current items array with a new one and sort it by DOM order.\n\t   * @param {ShuffleItem[]} items Items to track.\n\t   * @return {ShuffleItem[]}\n\t   */\n\t  _mergeNewItems(items) {\n\t    const children = Array.from(this.element.children);\n\t    return sorter(this.items.concat(items), {\n\t      by(element) {\n\t        return children.indexOf(element);\n\t      }\n\t    });\n\t  }\n\t  _getFilteredItems() {\n\t    return this.items.filter(item => item.isVisible);\n\t  }\n\t  _getConcealedItems() {\n\t    return this.items.filter(item => !item.isVisible);\n\t  }\n\n\t  /**\n\t   * Returns the column size, based on column width and sizer options.\n\t   * @param {number} containerWidth Size of the parent container.\n\t   * @param {number} gutterSize Size of the gutters.\n\t   * @return {number}\n\t   * @private\n\t   */\n\t  _getColumnSize(containerWidth, gutterSize) {\n\t    let size;\n\n\t    // If the columnWidth property is a function, then the grid is fluid\n\t    if (typeof this.options.columnWidth === 'function') {\n\t      size = this.options.columnWidth(containerWidth);\n\n\t      // columnWidth option isn't a function, are they using a sizing element?\n\t    } else if (this.options.sizer) {\n\t      size = Shuffle.getSize(this.options.sizer).width;\n\n\t      // if not, how about the explicitly set option?\n\t    } else if (this.options.columnWidth) {\n\t      size = this.options.columnWidth;\n\n\t      // or use the size of the first item\n\t    } else if (this.items.length > 0) {\n\t      size = Shuffle.getSize(this.items[0].element, true).width;\n\n\t      // if there's no items, use size of container\n\t    } else {\n\t      size = containerWidth;\n\t    }\n\n\t    // Don't let them set a column width of zero.\n\t    if (size === 0) {\n\t      size = containerWidth;\n\t    }\n\t    return size + gutterSize;\n\t  }\n\n\t  /**\n\t   * Returns the gutter size, based on gutter width and sizer options.\n\t   * @param {number} containerWidth Size of the parent container.\n\t   * @return {number}\n\t   * @private\n\t   */\n\t  _getGutterSize(containerWidth) {\n\t    let size;\n\t    if (typeof this.options.gutterWidth === 'function') {\n\t      size = this.options.gutterWidth(containerWidth);\n\t    } else if (this.options.sizer) {\n\t      size = getNumberStyle(this.options.sizer, 'marginLeft');\n\t    } else {\n\t      size = this.options.gutterWidth;\n\t    }\n\t    return size;\n\t  }\n\n\t  /**\n\t   * Calculate the number of columns to be used. Gets css if using sizer element.\n\t   * @param {number} [containerWidth] Optionally specify a container width if\n\t   *    it's already available.\n\t   */\n\t  _setColumns(containerWidth = Shuffle.getSize(this.element).width) {\n\t    const gutter = this._getGutterSize(containerWidth);\n\t    const columnWidth = this._getColumnSize(containerWidth, gutter);\n\t    let calculatedColumns = (containerWidth + gutter) / columnWidth;\n\n\t    // Widths given from getStyles are not precise enough...\n\t    if (Math.abs(Math.round(calculatedColumns) - calculatedColumns) < this.options.columnThreshold) {\n\t      // e.g. calculatedColumns = 11.998876\n\t      calculatedColumns = Math.round(calculatedColumns);\n\t    }\n\t    this.cols = Math.max(Math.floor(calculatedColumns || 0), 1);\n\t    this.containerWidth = containerWidth;\n\t    this.colWidth = columnWidth;\n\t  }\n\n\t  /**\n\t   * Adjust the height of the grid\n\t   */\n\t  _setContainerSize() {\n\t    this.element.style.height = `${this._getContainerSize()}px`;\n\t  }\n\n\t  /**\n\t   * Based on the column heights, it returns the biggest one.\n\t   * @return {number}\n\t   * @private\n\t   */\n\t  _getContainerSize() {\n\t    return arrayMax(this.positions);\n\t  }\n\n\t  /**\n\t   * Get the clamped stagger amount.\n\t   * @param {number} index Index of the item to be staggered.\n\t   * @return {number}\n\t   */\n\t  _getStaggerAmount(index) {\n\t    return Math.min(index * this.options.staggerAmount, this.options.staggerAmountMax);\n\t  }\n\n\t  /**\n\t   * Emit an event from this instance.\n\t   * @param {string} name Event name.\n\t   * @param {Object} [data={}] Optional object data.\n\t   */\n\t  _dispatch(name, data = {}) {\n\t    if (this.isDestroyed) {\n\t      return;\n\t    }\n\t    data.shuffle = this;\n\t    this.emit(name, data);\n\t  }\n\n\t  /**\n\t   * Zeros out the y columns array, which is used to determine item placement.\n\t   * @private\n\t   */\n\t  _resetCols() {\n\t    let i = this.cols;\n\t    this.positions = [];\n\t    while (i) {\n\t      i -= 1;\n\t      this.positions.push(0);\n\t    }\n\t  }\n\n\t  /**\n\t   * Loops through each item that should be shown and calculates the x, y position.\n\t   * @param {ShuffleItem[]} items Array of items that will be shown/layed\n\t   *     out in order in their array.\n\t   */\n\t  _layout(items) {\n\t    const itemPositions = this._getNextPositions(items);\n\t    let count = 0;\n\t    items.forEach((item, i) => {\n\t      function callback() {\n\t        item.applyCss(ShuffleItem.Css.VISIBLE.after);\n\t      }\n\n\t      // If the item will not change its position, do not add it to the render\n\t      // queue. Transitions don't fire when setting a property to the same value.\n\t      if (Point.equals(item.point, itemPositions[i]) && !item.isHidden) {\n\t        item.applyCss(ShuffleItem.Css.VISIBLE.before);\n\t        callback();\n\t        return;\n\t      }\n\t      item.point = itemPositions[i];\n\t      item.scale = ShuffleItem.Scale.VISIBLE;\n\t      item.isHidden = false;\n\n\t      // Clone the object so that the `before` object isn't modified when the\n\t      // transition delay is added.\n\t      const styles = this.getStylesForTransition(item, ShuffleItem.Css.VISIBLE.before);\n\t      styles.transitionDelay = `${this._getStaggerAmount(count)}ms`;\n\t      this._queue.push({\n\t        item,\n\t        styles,\n\t        callback\n\t      });\n\t      count += 1;\n\t    });\n\t  }\n\n\t  /**\n\t   * Return an array of Point instances representing the future positions of\n\t   * each item.\n\t   * @param {ShuffleItem[]} items Array of sorted shuffle items.\n\t   * @return {Point[]}\n\t   * @private\n\t   */\n\t  _getNextPositions(items) {\n\t    // If position data is going to be changed, add the item's size to the\n\t    // transformer to allow for calculations.\n\t    if (this.options.isCentered) {\n\t      const itemsData = items.map((item, i) => {\n\t        const itemSize = Shuffle.getSize(item.element, true);\n\t        const point = this._getItemPosition(itemSize);\n\t        return new Rect(point.x, point.y, itemSize.width, itemSize.height, i);\n\t      });\n\t      return this.getTransformedPositions(itemsData, this.containerWidth);\n\t    }\n\n\t    // If no transforms are going to happen, simply return an array of the\n\t    // future points of each item.\n\t    return items.map(item => this._getItemPosition(Shuffle.getSize(item.element, true)));\n\t  }\n\n\t  /**\n\t   * Determine the location of the next item, based on its size.\n\t   * @param {{width: number, height: number}} itemSize Object with width and height.\n\t   * @return {Point}\n\t   * @private\n\t   */\n\t  _getItemPosition(itemSize) {\n\t    return getItemPosition({\n\t      itemSize,\n\t      positions: this.positions,\n\t      gridSize: this.colWidth,\n\t      total: this.cols,\n\t      threshold: this.options.columnThreshold,\n\t      buffer: this.options.buffer\n\t    });\n\t  }\n\n\t  /**\n\t   * Mutate positions before they're applied.\n\t   * @param {Rect[]} itemRects Item data objects.\n\t   * @param {number} containerWidth Width of the containing element.\n\t   * @return {Point[]}\n\t   * @protected\n\t   */\n\t  getTransformedPositions(itemRects, containerWidth) {\n\t    return getCenteredPositions(itemRects, containerWidth);\n\t  }\n\n\t  /**\n\t   * Hides the elements that don't match our filter.\n\t   * @param {ShuffleItem[]} collection Collection to shrink.\n\t   * @private\n\t   */\n\t  _shrink(collection = this._getConcealedItems()) {\n\t    let count = 0;\n\t    collection.forEach(item => {\n\t      function callback() {\n\t        item.applyCss(ShuffleItem.Css.HIDDEN.after);\n\t      }\n\n\t      // Continuing would add a transitionend event listener to the element, but\n\t      // that listener would not execute because the transform and opacity would\n\t      // stay the same.\n\t      // The callback is executed here because it is not guaranteed to be called\n\t      // after the transitionend event because the transitionend could be\n\t      // canceled if another animation starts.\n\t      if (item.isHidden) {\n\t        item.applyCss(ShuffleItem.Css.HIDDEN.before);\n\t        callback();\n\t        return;\n\t      }\n\t      item.scale = ShuffleItem.Scale.HIDDEN;\n\t      item.isHidden = true;\n\t      const styles = this.getStylesForTransition(item, ShuffleItem.Css.HIDDEN.before);\n\t      styles.transitionDelay = `${this._getStaggerAmount(count)}ms`;\n\t      this._queue.push({\n\t        item,\n\t        styles,\n\t        callback\n\t      });\n\t      count += 1;\n\t    });\n\t  }\n\n\t  /**\n\t   * Resize handler.\n\t   * @param {ResizeObserverEntry[]} entries\n\t   */\n\t  _handleResizeCallback(entries) {\n\t    // If shuffle is disabled, destroyed, don't do anything.\n\t    // You can still manually force a shuffle update with shuffle.update({ force: true }).\n\t    if (!this.isEnabled || this.isDestroyed) {\n\t      return;\n\t    }\n\n\t    // The reason ESLint disables this is because for..of generates a lot of extra\n\t    // code using Babel, but Shuffle no longer supports browsers that old, so\n\t    // nothing to worry about.\n\t    // eslint-disable-next-line no-restricted-syntax\n\t    for (const entry of entries) {\n\t      if (Math.round(entry.contentRect.width) !== Math.round(this.containerWidth)) {\n\t        // If there was already an animation waiting, cancel it.\n\t        cancelAnimationFrame(this._rafId);\n\t        // Offload updating the DOM until the browser is ready.\n\t        this._rafId = requestAnimationFrame(this.update.bind(this));\n\t      }\n\t    }\n\t  }\n\n\t  /**\n\t   * Returns styles which will be applied to the an item for a transition.\n\t   * @param {ShuffleItem} item Item to get styles for. Should have updated\n\t   *   scale and point properties.\n\t   * @param {Object} styleObject Extra styles that will be used in the transition.\n\t   * @return {!Object} Transforms for transitions, left/top for animate.\n\t   * @protected\n\t   */\n\t  getStylesForTransition(item, styleObject) {\n\t    // Clone the object to avoid mutating the original.\n\t    const styles = {\n\t      ...styleObject\n\t    };\n\t    if (this.options.useTransforms) {\n\t      const sign = this.options.isRTL ? '-' : '';\n\t      const x = this.options.roundTransforms ? Math.round(item.point.x) : item.point.x;\n\t      const y = this.options.roundTransforms ? Math.round(item.point.y) : item.point.y;\n\t      styles.transform = `translate(${sign}${x}px, ${y}px) scale(${item.scale})`;\n\t    } else {\n\t      if (this.options.isRTL) {\n\t        styles.right = `${item.point.x}px`;\n\t      } else {\n\t        styles.left = `${item.point.x}px`;\n\t      }\n\t      styles.top = `${item.point.y}px`;\n\t    }\n\t    return styles;\n\t  }\n\n\t  /**\n\t   * Listen for the transition end on an element and execute the itemCallback\n\t   * when it finishes.\n\t   * @param {Element} element Element to listen on.\n\t   * @param {function} itemCallback Callback for the item.\n\t   * @param {function} done Callback to notify `parallel` that this one is done.\n\t   */\n\t  _whenTransitionDone(element, itemCallback, done) {\n\t    const id = onTransitionEnd(element, evt => {\n\t      itemCallback();\n\t      done(null, evt);\n\t    });\n\t    this._transitions.push(id);\n\t  }\n\n\t  /**\n\t   * Return a function which will set CSS styles and call the `done` function\n\t   * when (if) the transition finishes.\n\t   * @param {Object} opts Transition object.\n\t   * @return {function} A function to be called with a `done` function.\n\t   */\n\t  _getTransitionFunction(opts) {\n\t    return done => {\n\t      opts.item.applyCss(opts.styles);\n\t      this._whenTransitionDone(opts.item.element, opts.callback, done);\n\t    };\n\t  }\n\n\t  /**\n\t   * Execute the styles gathered in the style queue. This applies styles to elements,\n\t   * triggering transitions.\n\t   * @private\n\t   */\n\t  _processQueue() {\n\t    if (this.isTransitioning) {\n\t      this._cancelMovement();\n\t    }\n\t    const hasSpeed = this.options.speed > 0;\n\t    const hasQueue = this._queue.length > 0;\n\t    if (hasQueue && hasSpeed && this.isInitialized) {\n\t      this._startTransitions(this._queue);\n\t    } else if (hasQueue) {\n\t      this._styleImmediately(this._queue);\n\t      this._dispatch(Shuffle.EventType.LAYOUT);\n\n\t      // A call to layout happened, but none of the newly visible items will\n\t      // change position or the transition duration is zero, which will not trigger\n\t      // the transitionend event.\n\t    } else {\n\t      this._dispatch(Shuffle.EventType.LAYOUT);\n\t    }\n\n\t    // Remove everything in the style queue\n\t    this._queue.length = 0;\n\t  }\n\n\t  /**\n\t   * Wait for each transition to finish, the emit the layout event.\n\t   * @param {Object[]} transitions Array of transition objects.\n\t   */\n\t  _startTransitions(transitions) {\n\t    // Set flag that shuffle is currently in motion.\n\t    this.isTransitioning = true;\n\n\t    // Create an array of functions to be called.\n\t    const callbacks = transitions.map(obj => this._getTransitionFunction(obj));\n\t    parallel(callbacks, this._movementFinished.bind(this));\n\t  }\n\t  _cancelMovement() {\n\t    // Remove the transition end event for each listener.\n\t    this._transitions.forEach(cancelTransitionEnd);\n\n\t    // Reset the array.\n\t    this._transitions.length = 0;\n\n\t    // Show it's no longer active.\n\t    this.isTransitioning = false;\n\t  }\n\n\t  /**\n\t   * Apply styles without a transition.\n\t   * @param {Object[]} objects Array of transition objects.\n\t   * @private\n\t   */\n\t  _styleImmediately(objects) {\n\t    if (objects.length) {\n\t      const elements = objects.map(obj => obj.item.element);\n\t      Shuffle._skipTransitions(elements, () => {\n\t        objects.forEach(obj => {\n\t          obj.item.applyCss(obj.styles);\n\t          obj.callback();\n\t        });\n\t      });\n\t    }\n\t  }\n\t  _movementFinished() {\n\t    this._transitions.length = 0;\n\t    this.isTransitioning = false;\n\t    this._dispatch(Shuffle.EventType.LAYOUT);\n\t  }\n\n\t  /**\n\t   * The magic. This is what makes the plugin 'shuffle'\n\t   * @param {string|string[]|function(Element):boolean} [category] Category to filter by.\n\t   *     Can be a function, string, or array of strings.\n\t   * @param {SortOptions} [sortOptions] A sort object which can sort the visible set\n\t   */\n\t  filter(category, sortOptions) {\n\t    if (!this.isEnabled) {\n\t      return;\n\t    }\n\t    if (!category || category && category.length === 0) {\n\t      category = Shuffle.ALL_ITEMS; // eslint-disable-line no-param-reassign\n\t    }\n\t    this._filter(category);\n\n\t    // Shrink each hidden item\n\t    this._shrink();\n\n\t    // How many visible elements?\n\t    this._updateItemCount();\n\n\t    // Update transforms on visible elements so they will animate to their new positions.\n\t    this.sort(sortOptions);\n\t  }\n\n\t  /**\n\t   * Gets the visible elements, sorts them, and passes them to layout.\n\t   * @param {SortOptions} [sortOptions] The options object to pass to `sorter`.\n\t   */\n\t  sort(sortOptions = this.lastSort) {\n\t    if (!this.isEnabled) {\n\t      return;\n\t    }\n\t    this._resetCols();\n\t    const items = sorter(this._getFilteredItems(), sortOptions);\n\t    this.sortedItems = items;\n\t    this._layout(items);\n\n\t    // `_layout` always happens after `_shrink`, so it's safe to process the style\n\t    // queue here with styles from the shrink method.\n\t    this._processQueue();\n\n\t    // Adjust the height of the container.\n\t    this._setContainerSize();\n\t    this.lastSort = sortOptions;\n\t  }\n\n\t  /**\n\t   * Reposition everything.\n\t   * @param {object} options options object\n\t   * @param {boolean} [options.recalculateSizes=true] Whether to calculate column, gutter, and container widths again.\n\t   * @param {boolean} [options.force=false] By default, `update` does nothing if the instance is disabled. Setting this\n\t   *    to true forces the update to happen regardless.\n\t   */\n\t  update({\n\t    recalculateSizes = true,\n\t    force = false\n\t  } = {}) {\n\t    if (this.isEnabled || force) {\n\t      if (recalculateSizes) {\n\t        this._setColumns();\n\t      }\n\n\t      // Layout items\n\t      this.sort();\n\t    }\n\t  }\n\n\t  /**\n\t   * Use this instead of `update()` if you don't need the columns and gutters updated\n\t   * Maybe an image inside `shuffle` loaded (and now has a height), which means calculations\n\t   * could be off.\n\t   */\n\t  layout() {\n\t    this.update({\n\t      recalculateSizes: true\n\t    });\n\t  }\n\n\t  /**\n\t   * New items have been appended to shuffle. Mix them in with the current\n\t   * filter or sort status.\n\t   * @param {Element[]} newItems Collection of new items.\n\t   */\n\t  add(newItems) {\n\t    const items = arrayUnique(newItems).map(el => new ShuffleItem(el, this.options.isRTL));\n\n\t    // Add classes and set initial positions.\n\t    this._initItems(items);\n\n\t    // Determine which items will go with the current filter.\n\t    this._resetCols();\n\t    const allItems = this._mergeNewItems(items);\n\t    const sortedItems = sorter(allItems, this.lastSort);\n\t    const allSortedItemsSet = this._filter(this.lastFilter, sortedItems);\n\t    const isNewItem = item => items.includes(item);\n\t    const applyHiddenState = item => {\n\t      item.scale = ShuffleItem.Scale.HIDDEN;\n\t      item.isHidden = true;\n\t      item.applyCss(ShuffleItem.Css.HIDDEN.before);\n\t      item.applyCss(ShuffleItem.Css.HIDDEN.after);\n\t    };\n\n\t    // Layout all items again so that new items get positions.\n\t    // Synchronously apply positions.\n\t    const itemPositions = this._getNextPositions(allSortedItemsSet.visible);\n\t    allSortedItemsSet.visible.forEach((item, i) => {\n\t      if (isNewItem(item)) {\n\t        item.point = itemPositions[i];\n\t        applyHiddenState(item);\n\t        item.applyCss(this.getStylesForTransition(item, {}));\n\t      }\n\t    });\n\t    allSortedItemsSet.hidden.forEach(item => {\n\t      if (isNewItem(item)) {\n\t        applyHiddenState(item);\n\t      }\n\t    });\n\n\t    // Cause layout so that the styles above are applied.\n\t    this.element.offsetWidth; // eslint-disable-line no-unused-expressions\n\n\t    // Add transition to each item.\n\t    this.setItemTransitions(items);\n\n\t    // Update the list of items.\n\t    this.items = this._mergeNewItems(items);\n\n\t    // Update layout/visibility of new and old items.\n\t    this.filter(this.lastFilter);\n\t  }\n\n\t  /**\n\t   * Disables shuffle from updating dimensions and layout on resize\n\t   */\n\t  disable() {\n\t    this.isEnabled = false;\n\t  }\n\n\t  /**\n\t   * Enables shuffle again\n\t   * @param {boolean} [isUpdateLayout=true] if undefined, shuffle will update columns and gutters\n\t   */\n\t  enable(isUpdateLayout = true) {\n\t    this.isEnabled = true;\n\t    if (isUpdateLayout) {\n\t      this.update();\n\t    }\n\t  }\n\n\t  /**\n\t   * Remove 1 or more shuffle items.\n\t   * @param {Element[]} elements An array containing one or more\n\t   *     elements in shuffle\n\t   * @return {Shuffle} The shuffle instance.\n\t   */\n\t  remove(elements) {\n\t    if (!elements.length) {\n\t      return;\n\t    }\n\t    const collection = arrayUnique(elements);\n\t    const oldItems = collection.map(element => this.getItemByElement(element)).filter(item => !!item);\n\t    const handleLayout = () => {\n\t      this._disposeItems(oldItems);\n\n\t      // Remove the collection in the callback\n\t      collection.forEach(element => {\n\t        element.parentNode.removeChild(element);\n\t      });\n\t      this._dispatch(Shuffle.EventType.REMOVED, {\n\t        collection\n\t      });\n\t    };\n\n\t    // Hide collection first.\n\t    this._toggleFilterClasses({\n\t      visible: [],\n\t      hidden: oldItems\n\t    });\n\t    this._shrink(oldItems);\n\t    this.sort();\n\n\t    // Update the list of items here because `remove` could be called again\n\t    // with an item that is in the process of being removed.\n\t    this.items = this.items.filter(item => !oldItems.includes(item));\n\t    this._updateItemCount();\n\t    this.once(Shuffle.EventType.LAYOUT, handleLayout);\n\t  }\n\n\t  /**\n\t   * Retrieve a shuffle item by its element.\n\t   * @param {Element} element Element to look for.\n\t   * @return {?ShuffleItem} A shuffle item or undefined if it's not found.\n\t   */\n\t  getItemByElement(element) {\n\t    return this.items.find(item => item.element === element);\n\t  }\n\n\t  /**\n\t   * Dump the elements currently stored and reinitialize all child elements which\n\t   * match the `itemSelector`.\n\t   */\n\t  resetItems() {\n\t    // Remove refs to current items.\n\t    this._disposeItems(this.items);\n\t    this.isInitialized = false;\n\n\t    // Find new items in the DOM.\n\t    this.items = this._getItems();\n\n\t    // Set initial styles on the new items.\n\t    this._initItems(this.items);\n\t    this.once(Shuffle.EventType.LAYOUT, () => {\n\t      // Add transition to each item.\n\t      this.setItemTransitions(this.items);\n\t      this.isInitialized = true;\n\t    });\n\n\t    // Lay out all items.\n\t    this.filter(this.lastFilter);\n\t  }\n\n\t  /**\n\t   * Destroys shuffle, removes events, styles, and classes\n\t   */\n\t  destroy() {\n\t    this._cancelMovement();\n\t    if (this._resizeObserver) {\n\t      this._resizeObserver.unobserve(this.element);\n\t      this._resizeObserver = null;\n\t    }\n\n\t    // Reset container styles\n\t    this.element.classList.remove('shuffle');\n\t    this.element.removeAttribute('style');\n\n\t    // Reset individual item styles\n\t    this._disposeItems(this.items);\n\t    this.items.length = 0;\n\t    this.sortedItems.length = 0;\n\t    this._transitions.length = 0;\n\n\t    // Null DOM references\n\t    this.options.sizer = null;\n\t    this.element = null;\n\n\t    // Set a flag so if a debounced resize has been triggered,\n\t    // it can first check if it is actually isDestroyed and not doing anything\n\t    this.isDestroyed = true;\n\t    this.isEnabled = false;\n\t  }\n\n\t  /**\n\t   * Returns the outer width of an element, optionally including its margins.\n\t   *\n\t   * There are a few different methods for getting the width of an element, none of\n\t   * which work perfectly for all Shuffle's use cases.\n\t   *\n\t   * 1. getBoundingClientRect() `left` and `right` properties.\n\t   *   - Accounts for transform scaled elements, making it useless for Shuffle\n\t   *   elements which have shrunk.\n\t   * 2. The `offsetWidth` property.\n\t   *   - This value stays the same regardless of the elements transform property,\n\t   *   however, it does not return subpixel values.\n\t   * 3. getComputedStyle()\n\t   *   - This works great Chrome, Firefox, Safari, but IE<=11 does not include\n\t   *   padding and border when box-sizing: border-box is set, requiring a feature\n\t   *   test and extra work to add the padding back for IE and other browsers which\n\t   *   follow the W3C spec here.\n\t   *\n\t   * @param {Element} element The element.\n\t   * @param {boolean} [includeMargins=false] Whether to include margins.\n\t   * @return {{width: number, height: number}} The width and height.\n\t   */\n\t  static getSize(element, includeMargins = false) {\n\t    // Store the styles so that they can be used by others without asking for it again.\n\t    const styles = window.getComputedStyle(element, null);\n\t    let width = getNumberStyle(element, 'width', styles);\n\t    let height = getNumberStyle(element, 'height', styles);\n\t    if (includeMargins) {\n\t      const marginLeft = getNumberStyle(element, 'marginLeft', styles);\n\t      const marginRight = getNumberStyle(element, 'marginRight', styles);\n\t      const marginTop = getNumberStyle(element, 'marginTop', styles);\n\t      const marginBottom = getNumberStyle(element, 'marginBottom', styles);\n\t      width += marginLeft + marginRight;\n\t      height += marginTop + marginBottom;\n\t    }\n\t    return {\n\t      width,\n\t      height\n\t    };\n\t  }\n\n\t  /**\n\t   * Change a property or execute a function which will not have a transition\n\t   * @param {Element[]} elements DOM elements that won't be transitioned.\n\t   * @param {function} callback A function which will be called while transition\n\t   *     is set to 0ms.\n\t   * @private\n\t   */\n\t  static _skipTransitions(elements, callback) {\n\t    const zero = '0ms';\n\n\t    // Save current duration and delay.\n\t    const data = elements.map(element => {\n\t      const {\n\t        style\n\t      } = element;\n\t      const duration = style.transitionDuration;\n\t      const delay = style.transitionDelay;\n\n\t      // Set the duration to zero so it happens immediately\n\t      style.transitionDuration = zero;\n\t      style.transitionDelay = zero;\n\t      return {\n\t        duration,\n\t        delay\n\t      };\n\t    });\n\t    callback();\n\n\t    // Cause forced synchronous layout.\n\t    elements[0].offsetWidth; // eslint-disable-line no-unused-expressions\n\n\t    // Put the duration back\n\t    elements.forEach((element, i) => {\n\t      element.style.transitionDuration = data[i].duration;\n\t      element.style.transitionDelay = data[i].delay;\n\t    });\n\t  }\n\t}\n\tShuffle.ShuffleItem = ShuffleItem;\n\tShuffle.ALL_ITEMS = 'all';\n\tShuffle.FILTER_ATTRIBUTE_KEY = 'groups';\n\n\t/** @enum {string} */\n\tShuffle.EventType = {\n\t  LAYOUT: 'shuffle:layout',\n\t  REMOVED: 'shuffle:removed'\n\t};\n\n\t/** @enum {string} */\n\tShuffle.Classes = Classes;\n\n\t/** @enum {string} */\n\tShuffle.FilterMode = {\n\t  ANY: 'any',\n\t  ALL: 'all'\n\t};\n\n\t// Overridable options\n\tShuffle.options = {\n\t  // Initial filter group.\n\t  group: Shuffle.ALL_ITEMS,\n\t  // Transition/animation speed (milliseconds).\n\t  speed: 250,\n\t  // CSS easing function to use.\n\t  easing: 'cubic-bezier(0.4, 0.0, 0.2, 1)',\n\t  // e.g. '.picture-item'.\n\t  itemSelector: '*',\n\t  // Element or selector string. Use an element to determine the size of columns\n\t  // and gutters.\n\t  sizer: null,\n\t  // A static number or function that tells the plugin how wide the gutters\n\t  // between columns are (in pixels).\n\t  gutterWidth: 0,\n\t  // A static number or function that returns a number which tells the plugin\n\t  // how wide the columns are (in pixels).\n\t  columnWidth: 0,\n\t  // If your group is not json, and is comma delimited, you could set delimiter\n\t  // to ','.\n\t  delimiter: null,\n\t  // Useful for percentage based heights when they might not always be exactly\n\t  // the same (in pixels).\n\t  buffer: 0,\n\t  // Reading the width of elements isn't precise enough and can cause columns to\n\t  // jump between values.\n\t  columnThreshold: 0.01,\n\t  // Shuffle can be initialized with a sort object. It is the same object\n\t  // given to the sort method.\n\t  initialSort: null,\n\t  // Transition delay offset for each item in milliseconds.\n\t  staggerAmount: 15,\n\t  // Maximum stagger delay in milliseconds.\n\t  staggerAmountMax: 150,\n\t  // Whether to use transforms or absolute positioning.\n\t  useTransforms: true,\n\t  // Affects using an array with filter. e.g. `filter(['one', 'two'])`. With \"any\",\n\t  // the element passes the test if any of its groups are in the array. With \"all\",\n\t  // the element only passes if all groups are in the array.\n\t  // Note, this has no effect if you supply a custom filter function.\n\t  filterMode: Shuffle.FilterMode.ANY,\n\t  // Attempt to center grid items in each row.\n\t  isCentered: false,\n\t  // Attempt to align grid items to right.\n\t  isRTL: false,\n\t  // Whether to round pixel values used in translate(x, y). This usually avoids\n\t  // blurriness.\n\t  roundTransforms: true\n\t};\n\tShuffle.Point = Point;\n\tShuffle.Rect = Rect;\n\n\t// Expose for testing. Hack at your own risk.\n\tShuffle.__sorter = sorter;\n\tShuffle.__getColumnSpan = getColumnSpan;\n\tShuffle.__getAvailablePositions = getAvailablePositions;\n\tShuffle.__getShortColumn = getShortColumn;\n\tShuffle.__getCenteredPositions = getCenteredPositions;\n\n\treturn Shuffle;\n\n}));\n//# sourceMappingURL=shuffle.js.map\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst workViewer = {\n    init: () => {\n        const elements = document.querySelectorAll(\".work-item\");\n        for (let i = 0; i < elements.length; i++) {\n            elements[i].addEventListener(\"click\", workViewer.activate, false);\n        }\n        const elem2 = document.querySelectorAll(\".overlay-close\");\n        for (let i = 0; i < elem2.length; i++) {\n            elem2[i].addEventListener(\"click\", workViewer.deactivate, false);\n        }\n    },\n    activate: (event) => {\n        const target = event === null || event === void 0 ? void 0 : event.currentTarget;\n        const currElem = target.nextElementSibling;\n        if (!currElem.classList.contains(\"open\")) {\n            //if it's closed\n            document.addEventListener(\"keyup\", workViewer.deactivateWithEscape, false);\n            currElem.classList.add(\"open\");\n            document.documentElement.style.overflowY = \"hidden\";\n            const overlayText = currElem.querySelector(\".overlay-title-text\");\n            if (overlayText) {\n                overlayText.classList.add(\"overlay-title-effect\");\n            }\n        }\n    },\n    deactivate: () => {\n        const elem = document.querySelector(\".open\");\n        if (elem) {\n            elem.classList.remove(\"open\");\n            document.documentElement.style.overflowY = \"\";\n            const titleText = elem.querySelector(\".overlay-title-text\");\n            titleText.classList.remove(\"overlay-title-effect\");\n        }\n    },\n    deactivateWithEscape: (e) => {\n        if (e.key === \"Escape\") {\n            const elem = document.querySelector(\".open\");\n            elem.classList.remove(\"open\");\n            document.documentElement.style.overflowY = \"\";\n            const overlayTitleText = elem.querySelector(\".overlay-title-text\");\n            overlayTitleText.classList.remove(\"overlay-title-effect\");\n        }\n    },\n};\nexports.default = workViewer;\n","'use strict';\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\n/**\r\n * Created by Sergiu Șandor (micku7zu) on 1/27/2017.\r\n * Original idea: https://github.com/gijsroge/tilt.js\r\n * MIT License.\r\n * Version 1.8.1\r\n */\n\nvar VanillaTilt = function () {\n  function VanillaTilt(element) {\n    var settings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    classCallCheck(this, VanillaTilt);\n\n    if (!(element instanceof Node)) {\n      throw \"Can't initialize VanillaTilt because \" + element + \" is not a Node.\";\n    }\n\n    this.width = null;\n    this.height = null;\n    this.clientWidth = null;\n    this.clientHeight = null;\n    this.left = null;\n    this.top = null;\n\n    // for Gyroscope sampling\n    this.gammazero = null;\n    this.betazero = null;\n    this.lastgammazero = null;\n    this.lastbetazero = null;\n\n    this.transitionTimeout = null;\n    this.updateCall = null;\n    this.event = null;\n\n    this.updateBind = this.update.bind(this);\n    this.resetBind = this.reset.bind(this);\n\n    this.element = element;\n    this.settings = this.extendSettings(settings);\n\n    this.reverse = this.settings.reverse ? -1 : 1;\n    this.resetToStart = VanillaTilt.isSettingTrue(this.settings[\"reset-to-start\"]);\n    this.glare = VanillaTilt.isSettingTrue(this.settings.glare);\n    this.glarePrerender = VanillaTilt.isSettingTrue(this.settings[\"glare-prerender\"]);\n    this.fullPageListening = VanillaTilt.isSettingTrue(this.settings[\"full-page-listening\"]);\n    this.gyroscope = VanillaTilt.isSettingTrue(this.settings.gyroscope);\n    this.gyroscopeSamples = this.settings.gyroscopeSamples;\n\n    this.elementListener = this.getElementListener();\n\n    if (this.glare) {\n      this.prepareGlare();\n    }\n\n    if (this.fullPageListening) {\n      this.updateClientSize();\n    }\n\n    this.addEventListeners();\n    this.reset();\n\n    if (this.resetToStart === false) {\n      this.settings.startX = 0;\n      this.settings.startY = 0;\n    }\n  }\n\n  VanillaTilt.isSettingTrue = function isSettingTrue(setting) {\n    return setting === \"\" || setting === true || setting === 1;\n  };\n\n  /**\r\n   * Method returns element what will be listen mouse events\r\n   * @return {Node}\r\n   */\n\n\n  VanillaTilt.prototype.getElementListener = function getElementListener() {\n    if (this.fullPageListening) {\n      return window.document;\n    }\n\n    if (typeof this.settings[\"mouse-event-element\"] === \"string\") {\n      var mouseEventElement = document.querySelector(this.settings[\"mouse-event-element\"]);\n\n      if (mouseEventElement) {\n        return mouseEventElement;\n      }\n    }\n\n    if (this.settings[\"mouse-event-element\"] instanceof Node) {\n      return this.settings[\"mouse-event-element\"];\n    }\n\n    return this.element;\n  };\n\n  /**\r\n   * Method set listen methods for this.elementListener\r\n   * @return {Node}\r\n   */\n\n\n  VanillaTilt.prototype.addEventListeners = function addEventListeners() {\n    this.onMouseEnterBind = this.onMouseEnter.bind(this);\n    this.onMouseMoveBind = this.onMouseMove.bind(this);\n    this.onMouseLeaveBind = this.onMouseLeave.bind(this);\n    this.onWindowResizeBind = this.onWindowResize.bind(this);\n    this.onDeviceOrientationBind = this.onDeviceOrientation.bind(this);\n\n    this.elementListener.addEventListener(\"mouseenter\", this.onMouseEnterBind);\n    this.elementListener.addEventListener(\"mouseleave\", this.onMouseLeaveBind);\n    this.elementListener.addEventListener(\"mousemove\", this.onMouseMoveBind);\n\n    if (this.glare || this.fullPageListening) {\n      window.addEventListener(\"resize\", this.onWindowResizeBind);\n    }\n\n    if (this.gyroscope) {\n      window.addEventListener(\"deviceorientation\", this.onDeviceOrientationBind);\n    }\n  };\n\n  /**\r\n   * Method remove event listeners from current this.elementListener\r\n   */\n\n\n  VanillaTilt.prototype.removeEventListeners = function removeEventListeners() {\n    this.elementListener.removeEventListener(\"mouseenter\", this.onMouseEnterBind);\n    this.elementListener.removeEventListener(\"mouseleave\", this.onMouseLeaveBind);\n    this.elementListener.removeEventListener(\"mousemove\", this.onMouseMoveBind);\n\n    if (this.gyroscope) {\n      window.removeEventListener(\"deviceorientation\", this.onDeviceOrientationBind);\n    }\n\n    if (this.glare || this.fullPageListening) {\n      window.removeEventListener(\"resize\", this.onWindowResizeBind);\n    }\n  };\n\n  VanillaTilt.prototype.destroy = function destroy() {\n    clearTimeout(this.transitionTimeout);\n    if (this.updateCall !== null) {\n      cancelAnimationFrame(this.updateCall);\n    }\n\n    this.element.style.willChange = \"\";\n    this.element.style.transition = \"\";\n    this.element.style.transform = \"\";\n    this.resetGlare();\n\n    this.removeEventListeners();\n    this.element.vanillaTilt = null;\n    delete this.element.vanillaTilt;\n\n    this.element = null;\n  };\n\n  VanillaTilt.prototype.onDeviceOrientation = function onDeviceOrientation(event) {\n    if (event.gamma === null || event.beta === null) {\n      return;\n    }\n\n    this.updateElementPosition();\n\n    if (this.gyroscopeSamples > 0) {\n      this.lastgammazero = this.gammazero;\n      this.lastbetazero = this.betazero;\n\n      if (this.gammazero === null) {\n        this.gammazero = event.gamma;\n        this.betazero = event.beta;\n      } else {\n        this.gammazero = (event.gamma + this.lastgammazero) / 2;\n        this.betazero = (event.beta + this.lastbetazero) / 2;\n      }\n\n      this.gyroscopeSamples -= 1;\n    }\n\n    var totalAngleX = this.settings.gyroscopeMaxAngleX - this.settings.gyroscopeMinAngleX;\n    var totalAngleY = this.settings.gyroscopeMaxAngleY - this.settings.gyroscopeMinAngleY;\n\n    var degreesPerPixelX = totalAngleX / this.width;\n    var degreesPerPixelY = totalAngleY / this.height;\n\n    var angleX = event.gamma - (this.settings.gyroscopeMinAngleX + this.gammazero);\n    var angleY = event.beta - (this.settings.gyroscopeMinAngleY + this.betazero);\n\n    var posX = angleX / degreesPerPixelX;\n    var posY = angleY / degreesPerPixelY;\n\n    if (this.updateCall !== null) {\n      cancelAnimationFrame(this.updateCall);\n    }\n\n    this.event = {\n      clientX: posX + this.left,\n      clientY: posY + this.top\n    };\n\n    this.updateCall = requestAnimationFrame(this.updateBind);\n  };\n\n  VanillaTilt.prototype.onMouseEnter = function onMouseEnter() {\n    this.updateElementPosition();\n    this.element.style.willChange = \"transform\";\n    this.setTransition();\n  };\n\n  VanillaTilt.prototype.onMouseMove = function onMouseMove(event) {\n    if (this.updateCall !== null) {\n      cancelAnimationFrame(this.updateCall);\n    }\n\n    this.event = event;\n    this.updateCall = requestAnimationFrame(this.updateBind);\n  };\n\n  VanillaTilt.prototype.onMouseLeave = function onMouseLeave() {\n    this.setTransition();\n\n    if (this.settings.reset) {\n      requestAnimationFrame(this.resetBind);\n    }\n  };\n\n  VanillaTilt.prototype.reset = function reset() {\n    this.onMouseEnter();\n\n    if (this.fullPageListening) {\n      this.event = {\n        clientX: (this.settings.startX + this.settings.max) / (2 * this.settings.max) * this.clientWidth,\n        clientY: (this.settings.startY + this.settings.max) / (2 * this.settings.max) * this.clientHeight\n      };\n    } else {\n      this.event = {\n        clientX: this.left + (this.settings.startX + this.settings.max) / (2 * this.settings.max) * this.width,\n        clientY: this.top + (this.settings.startY + this.settings.max) / (2 * this.settings.max) * this.height\n      };\n    }\n\n    var backupScale = this.settings.scale;\n    this.settings.scale = 1;\n    this.update();\n    this.settings.scale = backupScale;\n    this.resetGlare();\n  };\n\n  VanillaTilt.prototype.resetGlare = function resetGlare() {\n    if (this.glare) {\n      this.glareElement.style.transform = \"rotate(180deg) translate(-50%, -50%)\";\n      this.glareElement.style.opacity = \"0\";\n    }\n  };\n\n  VanillaTilt.prototype.getValues = function getValues() {\n    var x = void 0,\n        y = void 0;\n\n    if (this.fullPageListening) {\n      x = this.event.clientX / this.clientWidth;\n      y = this.event.clientY / this.clientHeight;\n    } else {\n      x = (this.event.clientX - this.left) / this.width;\n      y = (this.event.clientY - this.top) / this.height;\n    }\n\n    x = Math.min(Math.max(x, 0), 1);\n    y = Math.min(Math.max(y, 0), 1);\n\n    var tiltX = (this.reverse * (this.settings.max - x * this.settings.max * 2)).toFixed(2);\n    var tiltY = (this.reverse * (y * this.settings.max * 2 - this.settings.max)).toFixed(2);\n    var angle = Math.atan2(this.event.clientX - (this.left + this.width / 2), -(this.event.clientY - (this.top + this.height / 2))) * (180 / Math.PI);\n\n    return {\n      tiltX: tiltX,\n      tiltY: tiltY,\n      percentageX: x * 100,\n      percentageY: y * 100,\n      angle: angle\n    };\n  };\n\n  VanillaTilt.prototype.updateElementPosition = function updateElementPosition() {\n    var rect = this.element.getBoundingClientRect();\n\n    this.width = this.element.offsetWidth;\n    this.height = this.element.offsetHeight;\n    this.left = rect.left;\n    this.top = rect.top;\n  };\n\n  VanillaTilt.prototype.update = function update() {\n    var values = this.getValues();\n\n    this.element.style.transform = \"perspective(\" + this.settings.perspective + \"px) \" + \"rotateX(\" + (this.settings.axis === \"x\" ? 0 : values.tiltY) + \"deg) \" + \"rotateY(\" + (this.settings.axis === \"y\" ? 0 : values.tiltX) + \"deg) \" + \"scale3d(\" + this.settings.scale + \", \" + this.settings.scale + \", \" + this.settings.scale + \")\";\n\n    if (this.glare) {\n      this.glareElement.style.transform = \"rotate(\" + values.angle + \"deg) translate(-50%, -50%)\";\n      this.glareElement.style.opacity = \"\" + values.percentageY * this.settings[\"max-glare\"] / 100;\n    }\n\n    this.element.dispatchEvent(new CustomEvent(\"tiltChange\", {\n      \"detail\": values\n    }));\n\n    this.updateCall = null;\n  };\n\n  /**\r\n   * Appends the glare element (if glarePrerender equals false)\r\n   * and sets the default style\r\n   */\n\n\n  VanillaTilt.prototype.prepareGlare = function prepareGlare() {\n    // If option pre-render is enabled we assume all html/css is present for an optimal glare effect.\n    if (!this.glarePrerender) {\n      // Create glare element\n      var jsTiltGlare = document.createElement(\"div\");\n      jsTiltGlare.classList.add(\"js-tilt-glare\");\n\n      var jsTiltGlareInner = document.createElement(\"div\");\n      jsTiltGlareInner.classList.add(\"js-tilt-glare-inner\");\n\n      jsTiltGlare.appendChild(jsTiltGlareInner);\n      this.element.appendChild(jsTiltGlare);\n    }\n\n    this.glareElementWrapper = this.element.querySelector(\".js-tilt-glare\");\n    this.glareElement = this.element.querySelector(\".js-tilt-glare-inner\");\n\n    if (this.glarePrerender) {\n      return;\n    }\n\n    Object.assign(this.glareElementWrapper.style, {\n      \"position\": \"absolute\",\n      \"top\": \"0\",\n      \"left\": \"0\",\n      \"width\": \"100%\",\n      \"height\": \"100%\",\n      \"overflow\": \"hidden\",\n      \"pointer-events\": \"none\",\n      \"border-radius\": \"inherit\"\n    });\n\n    Object.assign(this.glareElement.style, {\n      \"position\": \"absolute\",\n      \"top\": \"50%\",\n      \"left\": \"50%\",\n      \"pointer-events\": \"none\",\n      \"background-image\": \"linear-gradient(0deg, rgba(255,255,255,0) 0%, rgba(255,255,255,1) 100%)\",\n      \"transform\": \"rotate(180deg) translate(-50%, -50%)\",\n      \"transform-origin\": \"0% 0%\",\n      \"opacity\": \"0\"\n    });\n\n    this.updateGlareSize();\n  };\n\n  VanillaTilt.prototype.updateGlareSize = function updateGlareSize() {\n    if (this.glare) {\n      var glareSize = (this.element.offsetWidth > this.element.offsetHeight ? this.element.offsetWidth : this.element.offsetHeight) * 2;\n\n      Object.assign(this.glareElement.style, {\n        \"width\": glareSize + \"px\",\n        \"height\": glareSize + \"px\"\n      });\n    }\n  };\n\n  VanillaTilt.prototype.updateClientSize = function updateClientSize() {\n    this.clientWidth = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;\n\n    this.clientHeight = window.innerHeight || document.documentElement.clientHeight || document.body.clientHeight;\n  };\n\n  VanillaTilt.prototype.onWindowResize = function onWindowResize() {\n    this.updateGlareSize();\n    this.updateClientSize();\n  };\n\n  VanillaTilt.prototype.setTransition = function setTransition() {\n    var _this = this;\n\n    clearTimeout(this.transitionTimeout);\n    this.element.style.transition = this.settings.speed + \"ms \" + this.settings.easing;\n    if (this.glare) this.glareElement.style.transition = \"opacity \" + this.settings.speed + \"ms \" + this.settings.easing;\n\n    this.transitionTimeout = setTimeout(function () {\n      _this.element.style.transition = \"\";\n      if (_this.glare) {\n        _this.glareElement.style.transition = \"\";\n      }\n    }, this.settings.speed);\n  };\n\n  /**\r\n   * Method return patched settings of instance\r\n   * @param {boolean} settings.reverse - reverse the tilt direction\r\n   * @param {number} settings.max - max tilt rotation (degrees)\r\n   * @param {startX} settings.startX - the starting tilt on the X axis, in degrees. Default: 0\r\n   * @param {startY} settings.startY - the starting tilt on the Y axis, in degrees. Default: 0\r\n   * @param {number} settings.perspective - Transform perspective, the lower the more extreme the tilt gets\r\n   * @param {string} settings.easing - Easing on enter/exit\r\n   * @param {number} settings.scale - 2 = 200%, 1.5 = 150%, etc..\r\n   * @param {number} settings.speed - Speed of the enter/exit transition\r\n   * @param {boolean} settings.transition - Set a transition on enter/exit\r\n   * @param {string|null} settings.axis - What axis should be enabled. Can be \"x\" or \"y\"\r\n   * @param {boolean} settings.glare - if it should have a \"glare\" effect\r\n   * @param {number} settings.max-glare - the maximum \"glare\" opacity (1 = 100%, 0.5 = 50%)\r\n   * @param {boolean} settings.glare-prerender - false = VanillaTilt creates the glare elements for you, otherwise\r\n   * @param {boolean} settings.full-page-listening - If true, parallax effect will listen to mouse move events on the whole document, not only the selected element\r\n   * @param {string|object} settings.mouse-event-element - String selector or link to HTML-element what will be listen mouse events\r\n   * @param {boolean} settings.reset - false = If the tilt effect has to be reset on exit\r\n   * @param {boolean} settings.reset-to-start - true = On reset event (mouse leave) will return to initial start angle (if startX or startY is set)\r\n   * @param {gyroscope} settings.gyroscope - Enable tilting by deviceorientation events\r\n   * @param {gyroscopeSensitivity} settings.gyroscopeSensitivity - Between 0 and 1 - The angle at which max tilt position is reached. 1 = 90deg, 0.5 = 45deg, etc..\r\n   * @param {gyroscopeSamples} settings.gyroscopeSamples - How many gyroscope moves to decide the starting position.\r\n   */\n\n\n  VanillaTilt.prototype.extendSettings = function extendSettings(settings) {\n    var defaultSettings = {\n      reverse: false,\n      max: 15,\n      startX: 0,\n      startY: 0,\n      perspective: 1000,\n      easing: \"cubic-bezier(.03,.98,.52,.99)\",\n      scale: 1,\n      speed: 300,\n      transition: true,\n      axis: null,\n      glare: false,\n      \"max-glare\": 1,\n      \"glare-prerender\": false,\n      \"full-page-listening\": false,\n      \"mouse-event-element\": null,\n      reset: true,\n      \"reset-to-start\": true,\n      gyroscope: true,\n      gyroscopeMinAngleX: -45,\n      gyroscopeMaxAngleX: 45,\n      gyroscopeMinAngleY: -45,\n      gyroscopeMaxAngleY: 45,\n      gyroscopeSamples: 10\n    };\n\n    var newSettings = {};\n    for (var property in defaultSettings) {\n      if (property in settings) {\n        newSettings[property] = settings[property];\n      } else if (this.element.hasAttribute(\"data-tilt-\" + property)) {\n        var attribute = this.element.getAttribute(\"data-tilt-\" + property);\n        try {\n          newSettings[property] = JSON.parse(attribute);\n        } catch (e) {\n          newSettings[property] = attribute;\n        }\n      } else {\n        newSettings[property] = defaultSettings[property];\n      }\n    }\n\n    return newSettings;\n  };\n\n  VanillaTilt.init = function init(elements, settings) {\n    if (elements instanceof Node) {\n      elements = [elements];\n    }\n\n    if (elements instanceof NodeList) {\n      elements = [].slice.call(elements);\n    }\n\n    if (!(elements instanceof Array)) {\n      return;\n    }\n\n    elements.forEach(function (element) {\n      if (!(\"vanillaTilt\" in element)) {\n        element.vanillaTilt = new VanillaTilt(element, settings);\n      }\n    });\n  };\n\n  return VanillaTilt;\n}();\n\nif (typeof document !== \"undefined\") {\n  /* expose the class to window */\n  window.VanillaTilt = VanillaTilt;\n\n  /**\r\n   * Auto load\r\n   */\n  VanillaTilt.init(document.querySelectorAll(\"[data-tilt]\"));\n}\n\nmodule.exports = VanillaTilt;\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nrequire(\"./scss/main.scss\");\nconst application_1 = require(\"./js/application\");\nconst work_viewer_1 = require(\"./js/work-viewer\");\nconst animate_1 = require(\"./js/animate\");\nrequire(\"@fontsource/roboto/400.css\");\nrequire(\"@fontsource/roboto/700.css\");\ndocument.addEventListener(\"DOMContentLoaded\", () => {\n    application_1.default.loadApplication();\n    work_viewer_1.default.init();\n    animate_1.default.scrollArrow();\n    application_1.default.worksFilter();\n    animate_1.default.typingEffect();\n    animate_1.default.hideMoreBtnMobile();\n    animate_1.default.inputAnimation();\n    animate_1.default.rippleEffect();\n    animate_1.default.emailSend();\n    animate_1.default.hexagonRotate();\n    const yearContainer = document.getElementById(\"year\");\n    if (yearContainer) {\n        yearContainer.innerHTML = String(new Date().getFullYear());\n    }\n});\n"],"names":["Object","defineProperty","exports","value","getOffset","validateEmail","EMAIL_REGEXP","Array","isArray","length","isEmpty","test","el","box","getBoundingClientRect","docElem","document","documentElement","top","window","scrollY","clientTop","left","scrollX","clientLeft","__awaiter","this","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","e","rejected","result","done","then","apply","velocity_animate_1","constants_1","utils_1","scrollMagic","theaterJS","animate","inputAnimation","onFormGroupEvent","event","_a","currentInput","currentTarget","parentLabel","parentNode","querySelector","type","classList","add","remove","from","getElementsByClassName","forEach","formControl","addEventListener","selectedInput","selectedPencil","previousElementSibling","velocity","y","opacity","nextElementSibling","visibilityToggle","createElement","label","formGroup","_b","element","style","visibility","rippleEffect","svgWrapper","preventDefault","buttonElement","divCreated","btnOffset","xPos","pageX","yPos","pageY","clientHeight","background","appendChild","setTimeout","showEmailSendFinished","getElementById","duration","easing","submitContactForm","data","formData","FormData","append","default","WEB3FORMS_KEY","name","email","subject","message","response","fetch","WEB3FORMS_URL","method","body","json","ok","success","error","console","emailSend","button","item","mailLoader","display","height","alert","border","parentElement","hexagonRotate","hexagonWrapper","currentHexagon","iconPosition","toggle","backgroundColor","color","hideMoreBtnMobile","info","typingEffect","controller","Controller","theater","on","getCurrentActor","$element","addActor","addScene","Scene","triggerElement","offset","reverse","addTo","accuracy","log","scrollArrow","scrollIntoView","behavior","factory","modules","installedModules","moduleId","module","id","loaded","call","m","c","p","_slicedToArray","arr","i","Symbol","iterator","_arr","_n","_d","_e","undefined","_s","_i","push","err","sliceIterator","TypeError","_interopRequireDefault","obj","__esModule","_toConsumableArray","arr2","_actor2","_helpersUtils2","_helpersType2","_helpersKeyboard2","_helpersHtml2","NAVIGATOR","navigator","DEFAULTS","autoplay","erase","minSpeed","maxSpeed","locale","options","arguments","merge","isNumber","languages","isString","substr","supports","defaultLocale","props","casting","status","onStage","currentScene","scenario","events","setCurrentActor","actorName","play","playNextScene","publish","nextScene","_nextScene$args","args","slice","actor","typeAction","eraseAction","callbackAction","waitAction","debug","initialValue","displayValue","cursor","isFixing","previousMistakeCursor","previousFixCursor","htmlMap","map","strip","actual","isMistaking","shouldBeMistaken","nextChar","charAt","randomCharNear","inject","getTypingSpeed","arg","speed","nbCharactersToErase","callback","delay","bind","_len2","_key2","eventName","callbacks","concat","freeze","defineProperties","a","sequence","_len","scenes","_key","addSceneToSequence","scene","s","partials","split","shift","sceneObj","join","replace","isFunction","isObject","unshift","prototype","getCurrentSpeech","replay","stop","trim","get","configurable","enumerable","init","DOCUMENT","selector","$e","Error","newValue","innerHTML","fastest","slowest","randomFloat","getPercentageOf","endValue","Math","max","set","toString","o","dst","objs","len","key","hasOwnProperty","random","min","floor","percentage","_type2","_utils2","_keyboardsJson2","keyboard","list","mapped","mapKeyboard","alphabet","lines","chars","x","charsLength","ch","nearbyChars","uppercase","charPosition","toLowerCase","abs","randomChar","toUpperCase","_voidElementsJson","_voidElementsJson2","isVoidElement","tag","tagName","match","Boolean","indexOf","str","regexp","tags","openers","exec","position","index","opener","pop","Shuffle","tiltjs","app","loadApplication","startX","startY","perspective","transition","worksFilter","grid","sizer","btns","shfl","itemSelector","btn","group","isActive","contains","getElementsByTagName","getAttribute","querySelectorAll","filter","ScrollMagic","_util","version","PIN_SPACER_ATTRIBUTE","_updateTimeout","_refreshTimeout","NAMESPACE","SCROLL_DIRECTION_FORWARD","SCROLL_DIRECTION_REVERSE","SCROLL_DIRECTION_PAUSED","DEFAULT_OPTIONS","CONTROLLER_OPTIONS","defaults","_options","extend","_sceneObjects","_updateScenesOnNextCycle","_scrollPos","_scrollDirection","_isDocument","_viewPortSize","_enabled","construct","container","elements","getViewportSize","onChange","ri","parseInt","refreshInterval","Number","scheduleRefresh","refresh","getScrollPos","vertical","scrollTop","scrollLeft","width","setScrollPos","_setScrollPos","pos","scrollTo","updateScenes","scenesToUpdate","oldScrollPos","deltaScroll","scrollPos","update","loglevel","debounceUpdate","rAF","resizeEvent","Event","bubbles","cancelable","createEvent","initEvent","dispatchEvent","_log","output","splice","sortScenes","ScenesArray","sort","b","scrollOffset","newScene","globalSceneOptions","removeScene","off","updateScene","immediately","scrollTarget","additionalParameter","Function","elem","hasAttribute","param","containerOffset","elementOffset","scrollPosMethod","about","values","size","scrollDirection","isDocument","newLoglevel","enabled","newState","destroy","resetScenes","clearTimeout","removeEventListener","cAF","addOption","defaultValue","extension","oldClass","$super","constructor","_durationUpdateMethod","_controller","SCENE_STATE_BEFORE","SCENE_STATE_DURING","SCENE_STATE_AFTER","SCENE_OPTIONS","_state","_progress","_scrollOffset","start","end","_triggerPos","optionName","addSceneOption","validateOption","_listeners","names","fullname","nameparts","eventname","namespace","keys","listener","trigger","vars","listeners","what","updateTriggerElementPosition","updateScrollOffset","updateDuration","onContainerResize","tmpParent","reset","newProgress","startPos","endPos","progress","_pin","updatePinState","doUpdate","oldState","reverseOrForward","eventVars","state","stateChanged","_pinOptions","triggerHook","suppressEvents","varname","changeOption","newval","reason","elementPos","telem","controllerInfo","changed","_validate","validate","val","String","perc","parseFloat","check","logMSG","oldval","newVal","shifts","triggerPosition","durationChanged","updatePinDimensions","removePin","forceUnpin","containerInfo","pinTarget","spacer","firstChild","newCSS","inFlow","change","css","pushFollowers","fixedPos","scrollDistance","round","during","marginCollapse","isMarginCollapseType","relSize","autoFullWidth","updatePinInContainer","updateRelativePinSpacer","onMousewheelOverPin","wheelDelta","detail","setPin","settings","defaultSettings","spacerClass","pushFollowersActivelySet","parentDisplay","boundsParams","pinCSS","sizeCSS","insertBefore","spacerCSS","boxSizing","mozBoxSizing","webkitBoxSizing","setAttribute","addClass","___origStyle","pinInlineCSS","margin","bottom","right","margins","removeChild","_cssClasses","_cssClassElems","removeClassToggle","setClassToggle","classes","elems","removeClass","translate","validationCallback","target","timeStamp","timestamp","Date","now","U","floatval","number","_getComputedStyle","currentStyle","getComputedStyle","_dimension","which","outer","includeMargin","_type","DomElement","dimension","marginTop","marginBottom","marginLeft","marginRight","_camelCase","g","lastTime","vendors","_requestAnimationFrame","requestAnimationFrame","_cancelAnimationFrame","cancelAnimationFrame","currTime","getTime","timeToCall","loglevels","time","getHours","getMinutes","getSeconds","getMilliseconds","func","v","HTMLElement","SVGElement","nodeType","nodeName","_get","NodeList","ref","pageYOffset","pageXOffset","relativeToViewport","rect","classname","className","RegExp","option","addIndicators","removeIndicators","setTween","removeTween","setVelocity","removeVelocity","_typeof","createClass","descriptor","writable","Constructor","protoProps","staticProps","isBoolean","variable","isNode","isPlainObject","proto","getPrototypeOf","isVelocityResult","isWrapped","cloneArray","arrayLike","defineProperty$1","readonly","getValue","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","return","Element","Actions","registerAction","internal","property","propertyIsEnumerable","warn","DEFAULT_DURATION","Duration","fast","normal","slow","Easings","registerEasing","linearEasing","percentComplete","startValue","fixRange","num","A","aA1","aA2","B","C","calcBezier","aT","getSlope","generateBezier","kSampleStepSize","float32ArraySupported","isNaN","isFinite","mX1","mY1","mX2","mY2","mSampleValues","Float32Array","precomputed","f","precompute","getTForX","getControlPoints","aX","intervalStart","currentSample","kSplineTableSize","guessForT","initialSlope","aGuessT","currentSlope","newtonRaphsonIterate","aA","aB","currentX","currentT","binarySubdivide","_i2","calcSampleValues","cos","PI","exp","easeIn","easeOut","easeInOut","springAccelerationForState","tension","friction","springEvaluateStateWithDerivative","initialState","dt","derivative","dx","dv","springIntegrateState","d","dxdt","dvdt","generateSpringRK4","initState","path","tolerance","haveDuration","timeLapsed","lastState","cache","parseDuration","def","validateCache","validateBegin","validateComplete","noError","validateDelay","parsed","validateDuration","validateEasing","steps","validateFpsLimit","validateLoop","validateQueue","validateRepeat","validateSpeed","validateSync","cache$1","begin","complete","fpsLimit","loop","mobileHA","minFrameTime","promise","promiseRejectEmpty","queue","repeat","sync","defaults$1","defaults$$1","instance","classCallCheck","validatePromise","validatePromiseRejectEmpty","Normalizations","NormalizationUnits","NoCacheNormalizations","Set","constructors","constructorCache","Map","dataName","Data","ownerDocument","defaultView","types","_constructor","newData","count","computedStyle","queueList","lastAnimationList","lastFinishList","isClient","windowScrollAnchor","State","isMobile","userAgent","isGingerbread","prefixElement","scrollAnchor","scrollPropertyLeft","scrollPropertyTop","isTicking","first","last","firstNew","animation","prev","_prev","_next","queue$1","queueName","freeAnimationCall","SequencesObject","completeCall","activeCall","isLoop","isRepeat","isStopped","_flags","_completed","_total","callComplete","resolver","_resolver","timeStart","skip","dequeue","repeatAgain","ellapsedTime","registerNormalization","nextArg","has","unit","units","hasNormalization","getNormalization","propertyName","fn","setPropertyValue","propertyValue","noCache","Velocity$$1","removeNestedCalc","tokens","depth","token","cache$2","camelCase","fixed","$","letter","rxColor6","rxColor3","rxColorName","rxRGB","rxSpaces","ColorNames","makeRGBA","ignore","r","fixColors","$0","$1","$2","augmentDimension","wantInner","getPropertyValue","sides","fields","augment","field","getWidthHeight","computePropertyValue","computedValue","skipCache","rxHex","commands","function","elementArrayIndex","tween","includes","getNormalizationUnit","string","expandProperties","properties","tweens","create","valueData","arr1","explodeTween","rxToken","rxNumber","findPattern","parts","partsLength","indexes","numbers","part","pattern","addString","text","_part","returnStringType","isDisplay","isVisibility","_part2","more","_part3","bits","isUnitless","hasNumbers","_part4","index2","digits","changeOrUnit","_unit","_part5","patternCalc","_unit2","_firstLetter","isComplex","isMaths","_part6","bit","substring","inRGB","_text","starting","startNumbers","percent","validateTweens","JSON","stringify","beginCall","progressCall","tweenValue","lastTick","asyncCallbacks","progressed","clear","_iteratorNormalCompletion2","_didIteratorError2","_iteratorError2","_step2","_iterator2","completed","FRAME_TIME","performance","perf","nowOffset","timing","navigationStart","rAFProxy","rAFShim","ticking","worker","Worker","URL","createObjectURL","Blob","_this","interval","onmessage","setInterval","postMessage","clearInterval","tick","hidden","timeCurrent","deltaTime","defaultSpeed","defaultEasing","defaultDuration","nextCall","flags","_ready","_timeStart","_started","_first","activeEasing","millisecondsEllapsed","mock","currentValue","easingComplete","best","j","tweenFrom","tweenTo","rawPercent","tweenPercent","checkAnimationShouldBeFinished","defaultQueue","endValues","promiseHandler","finishAll","animations","animationFlags","isExpanded","isReady","isStarted","isPaused","isSync","isReverse","checkAnimation","pauseResume","action","propertyAction","prop","_result","res","_iteratorNormalCompletion3","_didIteratorError3","_iteratorError3","_step3","_iterator3","_prop","_result2","_iteratorNormalCompletion4","_didIteratorError4","_iteratorError4","_step4","_iterator4","_element","_iteratorNormalCompletion5","_didIteratorError5","_iteratorError5","_step5","_iterator5","_element2","_iteratorNormalCompletion6","_didIteratorError6","_iteratorError6","_step6","_iterator6","_rejecter","checkAnimationShouldBeStopped","flag","isPercentComplete","_animation","SyntaxError","requireForcefeeding","fakeAnimation","singleResult","maybeSequence","_property","expandSequence","propertyTween","tweenEasing","_property2","colorValues","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgrey","darkgreen","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkslategrey","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dimgrey","dodgerblue","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","gray","grey","green","greenyellow","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgrey","lightgreen","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightslategrey","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","easeOutBouncePercent","easeInBouncePercent","amount","pow","registerBackIn","registerBackOut","registerBackInOut","PI2","getDimension","amplitude","period","sin","asin","registerElasticIn","registerElasticOut","registerElasticInOut","inlineRx","listItemRx","tableRowRx","tableRx","tableRowGroupRx","scroll","direction","client","scrollValue","scrollWidth","clientWidth","scrollHeight","rxAddPx","getSetPrefixed","unprefixed","getSetStyle","rxVendors","addUnit","_addUnit","base","rxSubtype","rxElement","getDimension$1","getBBox","getOwnPropertyNames","subtype","createElementNS","attribute","VelocityStatic","VERSION","Velocity$1","Sequences","patch","Velocity","documentMode","div","jQuery","Zepto","HTMLCollection","_loop","rxPercents","registerSequence","_name","percents","sequenceList","orderedPercents","a1","b1","stepProperties","realSequence","originalProperty","globalPromise","noPromiseOption","patchPromise","promiseObject","catch","finally","_ref","args0","syntacticSugar","argumentIndex","propertiesMap","optionsMap","rejecter","isAction","opts","optionPromiseRejectEmpty","actionArgs","_promise","_ref2","hasValidDuration","validDuration","drag","stagger","optionsBegin","optionsComplete","optionsProgress","validateProgress","optionsSync","rootAnimation","lastAnimation","assign","optionCallback","global","VelocityStatic$1","Velocity$2","jQuery$1","Zepto$1","_loop$1","property$1","getDefaultExportFromCjs","hasRequiredTinyEmitter","tinyEmitter","requireTinyEmitter","E","ctx","once","self","_","emit","evtArr","evts","liveEvents","TinyEmitter","arrayParallel","hasRequiredArrayParallel","requireArrayParallel","noop","fns","context","pending","finished","results","maybeDone","parallel","getNumber","Point","equals","Rect","w","h","intersects","Classes","BASE","SHUFFLE_ITEM","VISIBLE","HIDDEN","id$1","ShuffleItem","isRTL","isVisible","isHidden","show","removeAttribute","hide","addClasses","applyCss","Css","INITIAL","DIRECTION","rtl","ltr","scale","Scale","point","removeClasses","dispose","willChange","before","after","transitionDelay","testComputedSize","cssText","getNumberStyle","styles","paddingTop","paddingBottom","borderTopWidth","borderBottomWidth","paddingLeft","paddingRight","borderLeftWidth","borderRightWidth","randomize","array","n","temp","by","compare","sorter","original","revert","valA","valB","transitions","uniqueId","cancelTransitionEnd","onTransitionEnd","evt","arrayMax","arrayMin","getColumnSpan","itemWidth","columnWidth","columns","threshold","columnSpan","ceil","getAvailablePositions","positions","available","getShortColumn","buffer","minPosition","getItemPosition","itemSize","gridSize","total","span","setY","shortColumnIndex","setHeight","getCenteredPositions","itemRects","containerWidth","rowMap","itemRect","rects","rows","centeredRows","lastItem","finalRects","canMove","newRects","every","newRect","noOverlap","some","intersectingRect","rowIndex","findIndex","items","flat","hyphenate","m1","arrayUnique","super","lastSort","ALL_ITEMS","lastFilter","isEnabled","isDestroyed","isInitialized","_transitions","isTransitioning","_queue","_getElementOption","_init","_getItems","sortedItems","_initItems","readyState","layout","onLoad","containerCss","getSize","_validateStyles","_setColumns","initialSort","_rafId","_resizeObserver","ResizeObserver","_handleResizeCallback","observe","offsetWidth","setItemTransitions","jquery","overflow","_filter","category","collection","_getFilteredSets","_toggleFilterClasses","visible","_doesPassFilter","attr","dataset","FILTER_ATTRIBUTE_KEY","delimiter","parse","testCategory","filterMode","FilterMode","ANY","_disposeItems","_updateItemCount","visibleItems","_getFilteredItems","positionProps","useTransforms","cssProps","k","transitionDuration","transitionTimingFunction","transitionProperty","children","matches","_mergeNewItems","_getConcealedItems","_getColumnSize","gutterSize","_getGutterSize","gutterWidth","gutter","calculatedColumns","columnThreshold","cols","colWidth","_setContainerSize","_getContainerSize","_getStaggerAmount","staggerAmount","staggerAmountMax","_dispatch","shuffle","_resetCols","_layout","itemPositions","_getNextPositions","getStylesForTransition","isCentered","itemsData","_getItemPosition","getTransformedPositions","_shrink","entries","entry","contentRect","styleObject","sign","roundTransforms","transform","_whenTransitionDone","itemCallback","_getTransitionFunction","_processQueue","_cancelMovement","hasSpeed","hasQueue","_startTransitions","_styleImmediately","EventType","LAYOUT","_movementFinished","objects","_skipTransitions","sortOptions","recalculateSizes","force","newItems","allSortedItemsSet","isNewItem","applyHiddenState","disable","enable","isUpdateLayout","oldItems","getItemByElement","handleLayout","REMOVED","find","resetItems","unobserve","includeMargins","zero","ALL","__sorter","__getColumnSpan","__getAvailablePositions","__getShortColumn","__getCenteredPositions","workViewer","activate","elem2","deactivate","currElem","deactivateWithEscape","overflowY","overlayText","VanillaTilt","Node","gammazero","betazero","lastgammazero","lastbetazero","transitionTimeout","updateCall","updateBind","resetBind","extendSettings","resetToStart","isSettingTrue","glare","glarePrerender","fullPageListening","gyroscope","gyroscopeSamples","elementListener","getElementListener","prepareGlare","updateClientSize","addEventListeners","setting","mouseEventElement","onMouseEnterBind","onMouseEnter","onMouseMoveBind","onMouseMove","onMouseLeaveBind","onMouseLeave","onWindowResizeBind","onWindowResize","onDeviceOrientationBind","onDeviceOrientation","removeEventListeners","resetGlare","vanillaTilt","gamma","beta","updateElementPosition","totalAngleX","gyroscopeMaxAngleX","gyroscopeMinAngleX","totalAngleY","gyroscopeMaxAngleY","gyroscopeMinAngleY","degreesPerPixelX","degreesPerPixelY","posX","posY","clientX","clientY","setTransition","backupScale","glareElement","getValues","tiltX","toFixed","tiltY","percentageX","percentageY","angle","atan2","offsetHeight","axis","CustomEvent","jsTiltGlare","jsTiltGlareInner","glareElementWrapper","updateGlareSize","glareSize","innerWidth","innerHeight","newSettings","__webpack_module_cache__","__webpack_require__","cachedModule","__webpack_modules__","definition","toStringTag","application_1","work_viewer_1","animate_1","yearContainer","getFullYear"],"ignoreList":[],"sourceRoot":""}