velocity.js.map

{"version":3,"sources":["../src/constants.ts","../src/types.ts","../src/utility.ts","../src/Velocity/actions/actions.ts","../src/Velocity/actions/defaultAction.ts","../src/Velocity/actions/finish.ts","../src/Velocity/actions/option.ts","../src/Velocity/actions/pauseResume.ts","../src/Velocity/actions/reverse.ts","../src/Velocity/actions/stop.ts","../src/Velocity/actions/style.ts","../src/Velocity/actions/tween.ts","../src/Velocity/state.ts","../src/Velocity/css/camelCase.ts","../src/Velocity/css/fixColors.ts","../src/Velocity/css/colors.ts","../src/Velocity/css/getPropertyValue.ts","../src/Velocity/css/getUnit.ts","../src/Velocity/css/setPropertyValue.ts","../src/Velocity/easing/easings.ts","../src/Velocity/easing/back.ts","../src/Velocity/easing/bezier.ts","../src/Velocity/easing/bounce.ts","../src/Velocity/easing/elastic.ts","../src/Velocity/easing/spring_rk4.ts","../src/Velocity/easing/step.ts","../src/Velocity/easing/string.ts","../src/Velocity/normalizations/normalizations.ts","../src/Velocity/normalizations/svg/attributes.ts","../src/Velocity/normalizations/svg/dimensions.ts","../src/Velocity/normalizations/dimensions.ts","../src/Velocity/normalizations/display.ts","../src/Velocity/normalizations/scroll.ts","../src/Velocity/normalizations/style.ts","../src/Velocity/normalizations/tween.ts","../src/Velocity/complete.ts","../src/Velocity/data.ts","../src/Velocity/debug.ts","../src/Velocity/defaults.ts","../src/Velocity/mock.ts","../src/Velocity/patch.ts","../src/Velocity/queue.ts","../src/Velocity/redirects.ts","../src/Velocity/registereffect.ts","../src/Velocity/runsequence.ts","../src/Velocity/tick.ts","../src/Velocity/timestamp.ts","../src/Velocity/tweens.ts","../src/Velocity/validate.ts","../src/Velocity/version.ts","../src/core.ts","../src/app.ts"],"names":["PUBLIC_MEMBERS","ALL_VENDOR_PREFIXES","DURATION_FAST","DURATION_NORMAL","DURATION_SLOW","FUZZY_MS_PER_SECOND","DEFAULT_CACHE","DEFAULT_DELAY","DEFAULT_DURATION","DEFAULT_EASING","DEFAULT_FPSLIMIT","DEFAULT_LOOP","DEFAULT_PROMISE","DEFAULT_PROMISE_REJECT_EMPTY","DEFAULT_QUEUE","DEFAULT_REPEAT","DEFAULT_SPEED","DEFAULT_SYNC","TWEEN_NUMBER_REGEX","CLASSNAME","Duration","fast","normal","slow","isBoolean","variable","isNumber","isNumberWhenParsed","isNaN","Number","isString","isFunction","Object","prototype","toString","call","isNode","nodeType","isVelocityResult","length","velocity","propertyIsEnumerable","object","property","isWrapped","window","isSVG","SVGElement","isPlainObject","proto","getPrototypeOf","hasOwnProperty","constructor","isEmptyObject","name_1","createEmptyObject","create","defineProperty","name","value","configurable","writable","_now","Date","now","getTime","_inArray","array","i","sanitizeElements","elements","getValue","args","_args","arguments","_arg","undefined","addClass","element","className","Element","classList","add","removeClass","remove","replace","RegExp","VelocityStatic","Actions","registerAction","internal","callback","console","warn","defaultAction","promiseHandler","action","Redirects","options","opts_1","__assign","durationOriginal_1","parseFloat","duration","delayOriginal_1","delay","backwards","reverse","forEach","elementIndex","stagger","drag","test","Math","max","_resolver","abortError","_rejecter","Error","log","checkAnimationShouldBeFinished","animation","queueName","defaultQueue","validateTweens","queue","_flags","_started","_first","begin","callBegin","tweens","tween_1","pattern","currentValue","endValue","end","CSS","setPropertyValue","fn","completeCall","finish","validateQueue","defaults","finishAll","animations","activeCall","State","first","nextCall","firstNew","_next","then","animationFlags","isExpanded","isReady","isStarted","isStopped","isPaused","isSync","isReverse","option","key","indexOf","push","result","flag","isPercentComplete","validateCache","validateBegin","validateComplete","validateDelay","validateDuration","validateFpsLimit","validateLoop","validateRepeat","num","timeStart","lastTick","checkAnimation","pauseResume","SyntaxError","checkAnimationShouldBeStopped","stop","style","styleAction","fixColors","getPropertyValue","error","propertyName","value_1","String","tween","percentComplete","properties","easing","tweenAction","requireForcefeeding","info","document","body","fakeAnimation","singleResult","count","_a","Array","isArray","activeEasing","validateEasing","expandProperties","tween_2","easing_1","startValue","start","result_1","round","isClient","isMobile","navigator","userAgent","isAndroid","isGingerbread","isChrome","chrome","isFirefox","prefixElement","createElement","windowScrollAnchor","pageYOffset","scrollAnchor","documentElement","parentNode","scrollPropertyLeft","scrollPropertyTop","isTicking","cache","camelCase","fixed","$","letter","toUpperCase","ColorNames","makeRGBA","ignore","r","g","b","parseInt","rxColor6","rxColor3","rxColorName","rxRGB","rxSpaces","str","$0","$1","$2","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","name_2","color","floor","computePropertyValue","data","Data","computedStyle","getComputedStyle","computedValue","toggleDisplay","augmentDimension","topLeft","position","getBoundingClientRect","skipCache","propertyValue","NoCacheNormalizations","has","getNormalization","debug","Units","getUnit","units","unit","j","Easing","Easings","registerEasing","cos","PI","exp","registerBackIn","amount","pow","registerBackOut","registerBackInOut","fixRange","min","A","aA1","aA2","B","C","calcBezier","aT","getSlope","generateBezier","mX1","mY1","mX2","mY2","NEWTON_ITERATIONS","NEWTON_MIN_SLOPE","SUBDIVISION_PRECISION","SUBDIVISION_MAX_ITERATIONS","kSplineTableSize","kSampleStepSize","float32ArraySupported","isFinite","mSampleValues","Float32Array","newtonRaphsonIterate","aX","aGuessT","currentSlope","currentX","calcSampleValues","binarySubdivide","aA","aB","currentT","abs","getTForX","intervalStart","currentSample","lastSample","dist","guessForT","initialSlope","_precomputed","precompute","f","getControlPoints","x","y","easeIn","easeOut","easeInOut","easeOutBounce","easeInBounce","pi2","registerElasticIn","amplitude","period","sin","asin","registerElasticOut","registerElasticInOut","s","springAccelerationForState","state","tension","friction","v","springEvaluateStateWithDerivative","initialState","dt","derivative","dx","dv","springIntegrateState","a","c","d","dxdt","dvdt","generateSpringRK4","initState","path","time_lapsed","tolerance","DT","have_duration","last_state","generateStep","steps","MaxType","Normalizations","NormalizationUnits","Set","constructors","registerNormalization","index","nextArg","hasNormalization","getNormalizationUnit","types","getAttribute","setAttribute","base","rxSubtype","rxElement","getOwnPropertyNames","globals","subtype","exec","createElementNS","toLowerCase","attribute","e","getDimension","getBBox","wantInner","isBorderBox","sides","fields","augment","inlineRx","listItemRx","tableRowRx","tableRx","tableRowGroupRx","display","nodeName","clientWidth","scrollWidth","clientHeight","scrollHeight","scroll","direction","client","scroll_1","HTMLElement","rxAddPx","getSetPrefixed","unprefixed","getSetStyle","rxVendors","addUnit","getSetTween","callComplete","complete","setTimeout","isLoop","loop","isRepeat","repeat","repeatAgain","lastFinishList","ellapsedTime","_completed","_total","resolver","dequeue","freeAnimationCall","newData","queueList","lastAnimationList","_cache","_begin","_complete","_delay","_duration","_easing","_fpsLimit","_loop","_minFrameTime","_promise","_promiseRejectEmpty","_queue","_repeat","_speed","_sync","mobileHA","defineProperties","reset","enumerable","get","set","fpsLimit","minFrameTime","promise","validatePromise","promiseRejectEmpty","validatePromiseRejectEmpty","speed","validateSpeed","sync","validateSync","mock","patch","global","VelocityFn","animate","prev","last","_prev","skip","next","elementsIndex","elementsSize","opts","inlineValues","computedValues","height","marginTop","marginBottom","paddingTop","paddingBottom","isInline","overflow","promiseData","propertiesMap","opacity","this","animateParentHeight","totalDuration","totalHeightDelta","propertiesToSum","RegisterEffect","effectName","redirectOptions","finalElement","defaultDuration","callIndex","calls","durationPercentage","shareDuration","propertyMap","redirectDuration","callOptions","match","visibility","injectFinalCallbacks_1","resetProperty","resetValue","resetOptions","_deepCopyObject","target","sources","_i","TypeError","to","source","shift","RunSequence","originalSequence","sequence","currentCall","currentCallOptions","o","nextCallOptions","timing","sequenceQueue","callbackOriginal_1","nextCallElements","callProgress","timeCurrent","tweenValue","progress","firstProgress","firstComplete","asyncCallbacks","_nextProgress","_nextComplete","FRAME_TIME","performance","perf","nowOffset_1","navigationStart","rAFProxy","rAFShim","requestAnimationFrame","ticker","hidden","addEventListener","updateTicker","event","tick","ticking","timestamp","deltaTime","defaultSpeed","defaultEasing","lastProgress","lastComplete","flags","queue_1","_ready","delta","millisecondsEllapsed","tween_3","JSON","stringify","rxHex","commands","Map","elementArrayIndex","valueData","tween_4","arr1","arr2","explodeTween","isForcefeed","runAgain","arrayStart","arrayEnd","indexStart","indexEnd","inCalc","inRGB","inRGBA","isStringValue","charStart","charEnd","tempStart","tempEnd","dotStart","dotEnd","unitStart","unitEnd","startNumbers_1","count_1","index_1","pop","tween_5","parseDuration","def","noError","parsed","apply","validateProgress","version","__args","_arguments","args0","syntacticSugar","p","names","argumentIndex","optionsMap","rejecter","assign","bind","isAction","Promise","_resolve","_reject","_then","catch","finally","optionsBegin","optionsComplete","optionsProgress","optionsSync","offset","rootAnimation","lastAnimation","IE","documentMode","div","innerHTML","getElementsByTagName","jQuery","Zepto","NodeList","HTMLCollection"],"mappings":"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","file":"velocity.js","sourceRoot":"src/","sourcesContent":["/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Constants and defaults. These values should never change without a MINOR\r\n * version bump.\r\n */\r\n\r\n//[\"completeCall\", \"CSS\", \"State\", \"getEasing\", \"Easings\", \"data\", \"debug\", \"defaults\", \"hook\", \"init\", \"mock\", \"pauseAll\", \"queue\", \"dequeue\", \"freeAnimationCall\", \"Redirects\", \"RegisterEffect\", \"resumeAll\", \"RunSequence\", \"lastTick\", \"tick\", \"timestamp\", \"expandTween\", \"version\"]\r\nconst PUBLIC_MEMBERS = [\"version\", \"RegisterEffect\", \"style\", \"patch\", \"timestamp\"];\r\n/**\r\n * Without this it will only un-prefix properties that have a valid \"normal\"\r\n * version.\r\n */\r\nconst ALL_VENDOR_PREFIXES = true;\r\n\r\nconst DURATION_FAST = 200;\r\nconst DURATION_NORMAL = 400;\r\nconst DURATION_SLOW = 600;\r\n\r\nconst FUZZY_MS_PER_SECOND = 980;\r\n\r\nconst DEFAULT_CACHE = true;\r\nconst DEFAULT_DELAY = 0;\r\nconst DEFAULT_DURATION = DURATION_NORMAL;\r\nconst DEFAULT_EASING = \"swing\";\r\nconst DEFAULT_FPSLIMIT = 60;\r\nconst DEFAULT_LOOP = 0;\r\nconst DEFAULT_PROMISE = true;\r\nconst DEFAULT_PROMISE_REJECT_EMPTY = true;\r\nconst DEFAULT_QUEUE = \"\";\r\nconst DEFAULT_REPEAT = 0;\r\nconst DEFAULT_SPEED = 1;\r\nconst DEFAULT_SYNC = true;\r\nconst TWEEN_NUMBER_REGEX = /[\\d\\.-]/;\r\n\r\nconst CLASSNAME = \"velocity-animating\";\r\n\r\nconst Duration = {\r\n\t\"fast\": DURATION_FAST,\r\n\t\"normal\": DURATION_NORMAL,\r\n\t\"slow\": DURATION_SLOW,\r\n};\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Runtime type checking methods.\r\n */\r\n\r\nfunction isBoolean(variable): variable is boolean {\r\n\treturn variable === true || variable === false;\r\n}\r\n\r\nfunction isNumber(variable): variable is number {\r\n\treturn typeof variable === \"number\";\r\n}\r\n\r\n/**\r\n * Faster way to parse a string/number as a number https://jsperf.com/number-vs-parseint-vs-plus/3\r\n * @param variable The given string or number\r\n * @returns {variable is number} Returns boolean true if it is a number, false otherwise\r\n */\r\nfunction isNumberWhenParsed(variable: string | number): variable is number {\r\n\treturn !isNaN(Number(variable));\r\n}\r\n\r\nfunction isString(variable): variable is string {\r\n\treturn typeof variable === \"string\";\r\n}\r\n\r\nfunction isFunction(variable): variable is Function {\r\n\treturn Object.prototype.toString.call(variable) === \"[object Function]\";\r\n}\r\n\r\nfunction isNode(variable): variable is HTMLorSVGElement {\r\n\treturn !!(variable && variable.nodeType);\r\n}\r\n\r\nfunction isVelocityResult(variable): variable is VelocityResult {\r\n\treturn variable && isNumber(variable.length) && isFunction((variable as VelocityResult).velocity);\r\n}\r\n\r\nfunction propertyIsEnumerable(object: Object, property: string): boolean {\r\n\treturn Object.prototype.propertyIsEnumerable.call(object, property);\r\n}\r\n\r\n/* Determine if variable is an array-like wrapped jQuery, Zepto or similar element, or even a NodeList etc. */\r\n\r\n/* NOTE: HTMLFormElements also have a length. */\r\nfunction isWrapped(variable): variable is HTMLorSVGElement[] {\r\n\treturn variable\r\n\t\t&& variable !== window\r\n\t\t&& isNumber(variable.length)\r\n\t\t&& !isString(variable)\r\n\t\t&& !isFunction(variable)\r\n\t\t&& !isNode(variable)\r\n\t\t&& (variable.length === 0 || isNode(variable[0]));\r\n}\r\n\r\nfunction isSVG(variable): variable is SVGElement {\r\n\treturn SVGElement && variable instanceof SVGElement;\r\n}\r\n\r\nfunction isPlainObject(variable): variable is {} {\r\n\tif (!variable || typeof variable !== \"object\" || variable.nodeType || Object.prototype.toString.call(variable) !== \"[object Object]\") {\r\n\t\treturn false;\r\n\t}\r\n\tlet proto = Object.getPrototypeOf(variable) as Object;\r\n\r\n\treturn !proto || (proto.hasOwnProperty(\"constructor\") && proto.constructor === Object);\r\n}\r\n\r\nfunction isEmptyObject(variable): variable is {} {\r\n\tfor (let name in variable) {\r\n\t\tif (variable.hasOwnProperty(name)) {\r\n\t\t\treturn false;\r\n\t\t}\r\n\t}\r\n\treturn true;\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\n/**\r\n * Creates an empty object without any prototype chain.\r\n */\r\nfunction createEmptyObject() {\r\n\treturn Object.create(null);\r\n}\r\n\r\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 */\r\nfunction defineProperty(proto: any, name: string, value: Function | any) {\r\n\tif (proto) {\r\n\t\tObject.defineProperty(proto, name, {\r\n\t\t\tconfigurable: true,\r\n\t\t\twritable: true,\r\n\t\t\tvalue: value\r\n\t\t});\r\n\t}\r\n}\r\n\r\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 */\r\nconst _now = Date.now ? Date.now : function() {\r\n\treturn (new Date()).getTime();\r\n};\r\n\r\n/**\r\n * Check whether a value belongs to an array\r\n * https://jsperf.com/includes-vs-indexof-vs-while-loop/6\r\n * @param array The given array\r\n * @param value The given element to check if it is part of the array\r\n * @returns {boolean} True if it exists, false otherwise\r\n */\r\nfunction _inArray<T>(array: T[], value: T): boolean {\r\n\tlet i = 0;\r\n\r\n\twhile (i < array.length) {\r\n\t\tif (array[i++] === value) {\r\n\t\t\treturn true;\r\n\t\t}\r\n\t}\r\n\treturn false;\r\n}\r\n\r\n/**\r\n * Convert an element or array-like element list into an array if needed.\r\n */\r\nfunction sanitizeElements(elements: HTMLorSVGElement | HTMLorSVGElement[]): HTMLorSVGElement[] {\r\n\tif (isNode(elements)) {\r\n\t\treturn [elements];\r\n\t}\r\n\treturn elements as HTMLorSVGElement[];\r\n}\r\n\r\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 */\r\nfunction getValue<T>(...args: T[]): T;\r\nfunction getValue<T>(args: any): T {\r\n\tfor (let i = 0, _args = arguments; i < _args.length; i++) {\r\n\t\tconst _arg = _args[i];\r\n\r\n\t\tif (_arg !== undefined && _arg === _arg) {\r\n\t\t\treturn _arg;\r\n\t\t}\r\n\t}\r\n}\r\n\r\n/**\r\n * Add a single className to an Element.\r\n */\r\nfunction addClass(element: HTMLorSVGElement, className: string): void {\r\n\tif (element instanceof Element) {\r\n\t\tif (element.classList) {\r\n\t\t\telement.classList.add(className);\r\n\t\t} else {\r\n\t\t\tremoveClass(element, className);\r\n\t\t\telement.className += (element.className.length ? \" \" : \"\") + className;\r\n\t\t}\r\n\t}\r\n}\r\n\r\n/**\r\n * Remove a single className from an Element.\r\n */\r\nfunction removeClass(element: HTMLorSVGElement, className: string): void {\r\n\tif (element instanceof Element) {\r\n\t\tif (element.classList) {\r\n\t\t\telement.classList.remove(className);\r\n\t\t} else {\r\n\t\t\t// TODO: Need some jsperf tests on performance - can we get rid of the regex and maybe use split / array manipulation?\r\n\t\t\telement.className = element.className.toString().replace(new RegExp(\"(^|\\\\s)\" + className + \"(\\\\s|$)\", \"gi\"), \" \");\r\n\t\t}\r\n\t}\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Actions that can be performed by passing a string instead of a propertiesMap.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\t/**\r\n\t * Actions cannot be replaced if they are internal (hasOwnProperty is false\r\n\t * but they still exist). Otherwise they can be replaced by users.\r\n\t * \r\n\t * All external method calls should be using actions rather than sub-calls\r\n\t * of Velocity itself.\r\n\t */\r\n\texport const Actions: {[name: string]: VelocityActionFn} = createEmptyObject();\r\n\r\n\t/**\r\n\t * Used to register an action. This should never be called by users\r\n\t * directly, instead it should be called via  an action:<br/>\r\n\t * <code>Velocity(\"registerAction\", \"name\", VelocityActionFn);</code>\r\n\t * \r\n\t * @private\r\n\t */\r\n\texport function registerAction(args?: [string, VelocityActionFn], internal?: boolean) {\r\n\t\tconst name: string = args[0],\r\n\t\t\tcallback = args[1];\r\n\r\n\t\tif (!isString(name)) {\r\n\t\t\tconsole.warn(\"VelocityJS: Trying to set 'registerAction' name to an invalid value:\", name);\r\n\t\t} else if (!isFunction(callback)) {\r\n\t\t\tconsole.warn(\"VelocityJS: Trying to set 'registerAction' callback to an invalid value:\", name, callback);\r\n\t\t} else if (Actions[name] && !propertyIsEnumerable(Actions, name)) {\r\n\t\t\tconsole.warn(\"VelocityJS: Trying to override internal 'registerAction' callback\", name);\r\n\t\t} else if (internal === true) {\r\n\t\t\tdefineProperty(Actions, name, callback);\r\n\t\t} else {\r\n\t\t\tActions[name] = callback;\r\n\t\t}\r\n\t}\r\n\r\n\tregisterAction([\"registerAction\", registerAction as any], true);\r\n}\r\n","///<reference path=\"actions.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Default action.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\r\n\t/**\r\n\t * When the stop action is triggered, the elements' currently active call is immediately stopped. The active call might have\r\n\t * been applied to multiple elements, in which case all of the call's elements will be stopped. When an element\r\n\t * is stopped, the next item in its animation queue is immediately triggered.\r\n\t * An additional argument may be passed in to clear an element's remaining queued calls. Either true (which defaults to the \"fx\" queue)\r\n\t * or a custom queue string can be passed in.\r\n\t * Note: The stop command runs prior to Velocity's Queueing phase since its behavior is intended to take effect *immediately*,\r\n\t * regardless of the element's current queue state.\r\n\t * \r\n\t * @param {HTMLorSVGElement[]} elements The collection of HTML or SVG elements\r\n\t * @param {StrictVelocityOptions} The strict Velocity options\r\n\t * @param {Promise<HTMLorSVGElement[]>} An optional promise if the user uses promises\r\n\t * @param {(value?: (HTMLorSVGElement[] | VelocityResult)) => void} resolver The resolve method of the promise\r\n\t */\r\n\tfunction defaultAction(args?: any[], elements?: HTMLorSVGElement[] | VelocityResult, promiseHandler?: VelocityPromise, action?: string): void {\r\n\t\t// TODO: default is wrong, should be runSequence based, and needs all arguments\r\n\t\tif (isString(action) && VelocityStatic.Redirects[action]) {\r\n\t\t\tconst options = isPlainObject(args[0]) ? args[0] as VelocityOptions : {},\r\n\t\t\t\topts = {...options},\r\n\t\t\t\tdurationOriginal = parseFloat(options.duration as any),\r\n\t\t\t\tdelayOriginal = parseFloat(options.delay as any) || 0;\r\n\r\n\t\t\t/* If the backwards option was passed in, reverse the element set so that elements animate from the last to the first. */\r\n\t\t\tif (opts.backwards === true) {\r\n\t\t\t\telements = elements.reverse();\r\n\t\t\t}\r\n\r\n\t\t\t/* Individually trigger the redirect for each element in the set to prevent users from having to handle iteration logic in their redirect. */\r\n\t\t\telements.forEach(function(element, elementIndex) {\r\n\r\n\t\t\t\t/* If the stagger option was passed in, successively delay each element by the stagger value (in ms). Retain the original delay value. */\r\n\t\t\t\tif (parseFloat(opts.stagger as string)) {\r\n\t\t\t\t\topts.delay = delayOriginal + (parseFloat(opts.stagger as string) * elementIndex);\r\n\t\t\t\t} else if (isFunction(opts.stagger)) {\r\n\t\t\t\t\topts.delay = delayOriginal + opts.stagger.call(element, elementIndex, elements.length);\r\n\t\t\t\t}\r\n\r\n\t\t\t\t/* If the drag option was passed in, successively increase/decrease (depending on the presense of opts.backwards)\r\n                 the duration of each element's animation, using floors to prevent producing very short durations. */\r\n\t\t\t\tif (opts.drag) {\r\n\t\t\t\t\t/* Default the duration of UI pack effects (callouts and transitions) to 1000ms instead of the usual default duration of 400ms. */\r\n\t\t\t\t\topts.duration = durationOriginal || (/^(callout|transition)/.test(action) ? 1000 : DEFAULT_DURATION);\r\n\r\n\t\t\t\t\t/* For each element, take the greater duration of: A) animation completion percentage relative to the original duration,\r\n                     B) 75% of the original duration, or C) a 200ms fallback (in case duration is already set to a low value).\r\n                     The end result is a baseline of 75% of the redirect's duration that increases/decreases as the end of the element set is approached. */\r\n\t\t\t\t\topts.duration = Math.max(opts.duration * (opts.backwards ? 1 - elementIndex / elements.length : (elementIndex + 1) / elements.length), opts.duration * 0.75, 200);\r\n\t\t\t\t}\r\n\r\n\t\t\t\t/* Pass in the call's opts object so that the redirect can optionally extend it. It defaults to an empty object instead of null to\r\n                 reduce the opts checking logic required inside the redirect. */\r\n\t\t\t\tVelocityStatic.Redirects[action].call(element, element, opts, elementIndex, elements.length, elements, promiseHandler && promiseHandler._resolver);\r\n\t\t\t});\r\n\r\n\t\t\t/* Since the animation logic resides within the redirect's own code, abort the remainder of this call.\r\n             (The performance overhead up to this point is virtually non-existant.) */\r\n\t\t\t/* Note: The jQuery call chain is kept intact by returning the complete element set. */\r\n\t\t} else {\r\n\t\t\tconst abortError = \"Velocity: First argument (\" + action + \") was not a property map, a known action, or a registered redirect. Aborting.\";\r\n\r\n\t\t\tif (promiseHandler) {\r\n\t\t\t\tpromiseHandler._rejecter(new Error(abortError));\r\n\t\t\t} else if (window.console) {\r\n\t\t\t\tconsole.log(abortError);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tregisterAction([\"default\", defaultAction], true);\r\n}\r\n","///<reference path=\"actions.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Finish all animation.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\r\n\t/**\r\n\t * Check if an animation should be finished, and if so we set the tweens to\r\n\t * the final value for it, then call complete.\r\n\t */\r\n\tfunction checkAnimationShouldBeFinished(animation: AnimationCall, queueName: false | string, defaultQueue: false | string) {\r\n\t\tvalidateTweens(animation);\r\n\t\tif (queueName === undefined || queueName === getValue(animation.queue, animation.options.queue, defaultQueue)) {\r\n\t\t\tif (!(animation._flags & AnimationFlags.STARTED)) {\r\n\t\t\t\t// Copied from tick.ts - ensure that the animation is completely\r\n\t\t\t\t// valid and run begin() before complete().\r\n\t\t\t\tconst options = animation.options;\r\n\r\n\t\t\t\t// The begin callback is fired once per call, not once per\r\n\t\t\t\t// element, and is passed the full raw DOM element set as both\r\n\t\t\t\t// its context and its first argument.\r\n\t\t\t\tif (options._started++ === 0) {\r\n\t\t\t\t\toptions._first = animation;\r\n\t\t\t\t\tif (options.begin) {\r\n\t\t\t\t\t\t// Pass to an external fn with a try/catch block for optimisation\r\n\t\t\t\t\t\tcallBegin(animation);\r\n\t\t\t\t\t\t// Only called once, even if reversed or repeated\r\n\t\t\t\t\t\toptions.begin = undefined;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tanimation._flags |= AnimationFlags.STARTED;\r\n\t\t\t}\r\n\t\t\tfor (const property in animation.tweens) {\r\n\t\t\t\tconst tween = animation.tweens[property],\r\n\t\t\t\t\tpattern = tween.pattern;\r\n\t\t\t\tlet currentValue = \"\",\r\n\t\t\t\t\ti = 0;\r\n\r\n\t\t\t\tif (pattern) {\r\n\t\t\t\t\tfor (; i < pattern.length; i++) {\r\n\t\t\t\t\t\tconst endValue = tween.end[i];\r\n\r\n\t\t\t\t\t\tcurrentValue += endValue == null ? pattern[i] : endValue;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tCSS.setPropertyValue(animation.element, property, currentValue, tween.fn);\r\n\t\t\t}\r\n\t\t\tcompleteCall(animation);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * When the finish action is triggered, the elements' currently active call is\r\n\t * immediately finished. When an element is finished, the next item in its\r\n\t * animation queue is immediately triggered. If passed via a chained call\r\n\t * then this will only target the animations in that call, and not the\r\n\t * elements linked to it.\r\n\t * \r\n\t * A queue name may be passed in to specify that only animations on the\r\n\t * named queue are finished. The default queue is named \"\". In addition the\r\n\t * value of `false` is allowed for the queue name.\r\n\t * \r\n\t * An final argument may be passed in to clear an element's remaining queued\r\n\t * calls. This may only be the value `true`.\r\n\t */\r\n\tfunction finish(args: any[], elements: VelocityResult, promiseHandler?: VelocityPromise): void {\r\n\t\tconst queueName: string | false = validateQueue(args[0], true),\r\n\t\t\tdefaultQueue: false | string = defaults.queue,\r\n\t\t\tfinishAll = args[queueName === undefined ? 0 : 1] === true;\r\n\r\n\t\tif (isVelocityResult(elements) && elements.velocity.animations) {\r\n\t\t\tfor (let i = 0, animations = elements.velocity.animations; i < animations.length; i++) {\r\n\t\t\t\tcheckAnimationShouldBeFinished(animations[i], queueName, defaultQueue);\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tlet activeCall = State.first,\r\n\t\t\t\tnextCall: AnimationCall;\r\n\r\n\t\t\twhile ((activeCall = State.firstNew)) {\r\n\t\t\t\tvalidateTweens(activeCall);\r\n\t\t\t}\r\n\t\t\tfor (activeCall = State.first; activeCall && (finishAll || activeCall !== State.firstNew); activeCall = nextCall || State.firstNew) {\r\n\t\t\t\tnextCall = activeCall._next;\r\n\t\t\t\tif (!elements || _inArray(elements, activeCall.element)) {\r\n\t\t\t\t\tcheckAnimationShouldBeFinished(activeCall, queueName, defaultQueue);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (promiseHandler) {\r\n\t\t\tif (isVelocityResult(elements) && elements.velocity.animations && elements.then) {\r\n\t\t\t\telements.then(promiseHandler._resolver);\r\n\t\t\t} else {\r\n\t\t\t\tpromiseHandler._resolver(elements);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tregisterAction([\"finish\", finish], true);\r\n}\r\n","///<reference path=\"actions.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Get or set a value from one or more running animations.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\t/**\r\n\t * Used to map getters for the various AnimationFlags.\r\n\t */\r\n\tconst animationFlags: {[key: string]: number} = {\r\n\t\t\"isExpanded\": AnimationFlags.EXPANDED,\r\n\t\t\"isReady\": AnimationFlags.READY,\r\n\t\t\"isStarted\": AnimationFlags.STARTED,\r\n\t\t\"isStopped\": AnimationFlags.STOPPED,\r\n\t\t\"isPaused\": AnimationFlags.PAUSED,\r\n\t\t\"isSync\": AnimationFlags.SYNC,\r\n\t\t\"isReverse\": AnimationFlags.REVERSE\r\n\t};\r\n\r\n\t/**\r\n\t * Get or set an option or running AnimationCall data value. If there is no\r\n\t * value passed then it will get, otherwise we will set.\r\n\t * \r\n\t * NOTE: When using \"get\" this will not touch the Promise as it is never\r\n\t * returned to the user.\r\n\t */\r\n\tfunction option(args?: any[], elements?: VelocityResult, promiseHandler?: VelocityPromise, action?: string): any {\r\n\t\tconst key = args[0],\r\n\t\t\tqueue = action.indexOf(\".\") >= 0 ? action.replace(/^.*\\./, \"\") : undefined,\r\n\t\t\tqueueName = queue === \"false\" ? false : validateQueue(queue, true);\r\n\t\tlet animations: AnimationCall[],\r\n\t\t\tvalue = args[1];\r\n\r\n\t\tif (!key) {\r\n\t\t\tconsole.warn(\"VelocityJS: Cannot access a non-existant key!\");\r\n\t\t\treturn null;\r\n\t\t}\r\n\t\t// If we're chaining the return value from Velocity then we are only\r\n\t\t// interested in the values related to that call\r\n\t\tif (isVelocityResult(elements) && elements.velocity.animations) {\r\n\t\t\tanimations = elements.velocity.animations;\r\n\t\t} else {\r\n\t\t\tanimations = [];\r\n\r\n\t\t\tfor (let activeCall = State.first; activeCall; activeCall = activeCall._next) {\r\n\t\t\t\tif (elements.indexOf(activeCall.element) >= 0 && getValue(activeCall.queue, activeCall.options.queue) === queueName) {\r\n\t\t\t\t\tanimations.push(activeCall);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t// If we're dealing with multiple elements that are pointing at a\r\n\t\t\t// single running animation, then instead treat them as a single\r\n\t\t\t// animation.\r\n\t\t\tif (elements.length > 1 && animations.length > 1) {\r\n\t\t\t\tlet i = 1,\r\n\t\t\t\t\toptions = animations[0].options;\r\n\r\n\t\t\t\twhile (i < animations.length) {\r\n\t\t\t\t\tif (animations[i++].options !== options) {\r\n\t\t\t\t\t\toptions = null;\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\t// TODO: this needs to check that they're actually a sync:true animation to merge the results, otherwise the individual values may be different\r\n\t\t\t\tif (options) {\r\n\t\t\t\t\tanimations = [animations[0]];\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\t// GET\r\n\t\tif (value === undefined) {\r\n\t\t\tconst result = [],\r\n\t\t\t\tflag = animationFlags[key];\r\n\r\n\t\t\tfor (let i = 0; i < animations.length; i++) {\r\n\t\t\t\tif (flag === undefined) {\r\n\t\t\t\t\t// A normal key to get.\r\n\t\t\t\t\tresult.push(getValue(animations[i][key], animations[i].options[key]));\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// A flag that we're checking against.\r\n\t\t\t\t\tresult.push((animations[i]._flags & flag) === 0);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (elements.length === 1 && animations.length === 1) {\r\n\t\t\t\t// If only a single animation is found and we're only targetting a\r\n\t\t\t\t// single element, then return the value directly\r\n\t\t\t\treturn result[0];\r\n\t\t\t}\r\n\t\t\treturn result;\r\n\t\t}\r\n\t\t// SET\r\n\t\tlet isPercentComplete: boolean;\r\n\r\n\t\tswitch (key) {\r\n\t\t\tcase \"cache\":\r\n\t\t\t\tvalue = validateCache(value);\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"begin\":\r\n\t\t\t\tvalue = validateBegin(value);\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"complete\":\r\n\t\t\t\tvalue = validateComplete(value);\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"delay\":\r\n\t\t\t\tvalue = validateDelay(value);\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"duration\":\r\n\t\t\t\tvalue = validateDuration(value);\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"fpsLimit\":\r\n\t\t\t\tvalue = validateFpsLimit(value);\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"loop\":\r\n\t\t\t\tvalue = validateLoop(value);\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"percentComplete\":\r\n\t\t\t\tisPercentComplete = true;\r\n\t\t\t\tvalue = parseFloat(value);\r\n\t\t\t\tbreak;\r\n\t\t\tcase \"repeat\":\r\n\t\t\tcase \"repeatAgain\":\r\n\t\t\t\tvalue = validateRepeat(value);\r\n\t\t\t\tbreak;\r\n\t\t\tdefault:\r\n\t\t\t\tif (key[0] !== \"_\") {\r\n\t\t\t\t\tconst num = parseFloat(value);\r\n\r\n\t\t\t\t\tif (value == num) {\r\n\t\t\t\t\t\tvalue = num;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t// deliberate fallthrough\r\n\t\t\tcase \"queue\":\r\n\t\t\tcase \"promise\":\r\n\t\t\tcase \"promiseRejectEmpty\":\r\n\t\t\tcase \"easing\":\r\n\t\t\tcase \"started\":\r\n\t\t\t\tconsole.warn(\"VelocityJS: Trying to set a read-only key:\", key);\r\n\t\t\t\treturn;\r\n\t\t}\r\n\t\tif (value === undefined || value !== value) {\r\n\t\t\tconsole.warn(\"VelocityJS: Trying to set an invalid value:\", key, \"=\", value, \"(\" + args[1] + \")\");\r\n\t\t\treturn null;\r\n\t\t}\r\n\t\tfor (let i = 0; i < animations.length; i++) {\r\n\t\t\tconst animation = animations[i];\r\n\r\n\t\t\tif (isPercentComplete) {\r\n\t\t\t\tanimation.timeStart = lastTick - (getValue(animation.duration, animation.options.duration, defaults.duration) * value);\r\n\t\t\t} else {\r\n\t\t\t\tanimation[key] = value;\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (promiseHandler) {\r\n\t\t\tif (isVelocityResult(elements) && elements.velocity.animations && elements.then) {\r\n\t\t\t\telements.then(promiseHandler._resolver);\r\n\t\t\t} else {\r\n\t\t\t\tpromiseHandler._resolver(elements);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tregisterAction([\"option\", option], true);\r\n}\r\n","///<reference path=\"actions.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Pause and resume animation.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\r\n\t/**\r\n\t * Check if an animation should be paused / resumed.\r\n\t */\r\n\tfunction checkAnimation(animation: AnimationCall, queueName: false | string, defaultQueue: false | string, isPaused: boolean) {\r\n\t\tif (queueName === undefined || queueName === getValue(animation.queue, animation.options.queue, defaultQueue)) {\r\n\t\t\tif (isPaused) {\r\n\t\t\t\tanimation._flags |= AnimationFlags.PAUSED;\r\n\t\t\t} else {\r\n\t\t\t\tanimation._flags &= ~AnimationFlags.PAUSED;\r\n\t\t\t}\r\n\t\t}\r\n\t};\r\n\r\n\t/**\r\n\t * Pause and Resume are call-wide (not on a per element basis). Thus, calling pause or resume on a\r\n\t * single element will cause any calls that contain tweens for that element to be paused/resumed\r\n\t * as well.\r\n\t */\r\n\tfunction pauseResume(args?: any[], elements?: VelocityResult, promiseHandler?: VelocityPromise, action?: string) {\r\n\t\tconst isPaused = action.indexOf(\"pause\") === 0,\r\n\t\t\tqueue = action.indexOf(\".\") >= 0 ? action.replace(/^.*\\./, \"\") : undefined,\r\n\t\t\tqueueName = queue === \"false\" ? false : validateQueue(args[0]),\r\n\t\t\tdefaultQueue = defaults.queue;\r\n\r\n\t\tif (isVelocityResult(elements) && elements.velocity.animations) {\r\n\t\t\tfor (let i = 0, animations = elements.velocity.animations; i < animations.length; i++) {\r\n\t\t\t\tcheckAnimation(animations[i], queueName, defaultQueue, isPaused);\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tlet activeCall: AnimationCall = State.first;\r\n\r\n\t\t\twhile (activeCall) {\r\n\t\t\t\tif (!elements || _inArray(elements, activeCall.element)) {\r\n\t\t\t\t\tcheckAnimation(activeCall, queueName, defaultQueue, isPaused);\r\n\t\t\t\t}\r\n\t\t\t\tactiveCall = activeCall._next;\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (promiseHandler) {\r\n\t\t\tif (isVelocityResult(elements) && elements.velocity.animations && elements.then) {\r\n\t\t\t\telements.then(promiseHandler._resolver);\r\n\t\t\t} else {\r\n\t\t\t\tpromiseHandler._resolver(elements);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tregisterAction([\"pause\", pauseResume], true);\r\n\tregisterAction([\"resume\", pauseResume], true);\r\n}\r\n","///<reference path=\"actions.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Actions that can be performed by passing a string instead of a propertiesMap.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\tregisterAction([\"reverse\", function(args?: any[], elements?: HTMLorSVGElement[] | VelocityResult, promiseHandler?: VelocityPromise, action?: string) {\r\n\t\t// TODO: Code needs to split out before here - but this is needed to prevent it being overridden\r\n\t\tthrow new SyntaxError(\"VelocityJS: The 'reverse' action is private.\");\r\n\t}], true)\r\n}\r\n","///<reference path=\"actions.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Stop animation.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\r\n\t/**\r\n\t * Check if an animation should be stopped, and if so then set the STOPPED\r\n\t * flag on it, then call complete.\r\n\t */\r\n\tfunction checkAnimationShouldBeStopped(animation: AnimationCall, queueName: false | string, defaultQueue: false | string) {\r\n\t\tvalidateTweens(animation);\r\n\t\tif (queueName === undefined || queueName === getValue(animation.queue, animation.options.queue, defaultQueue)) {\r\n\t\t\tanimation._flags |= AnimationFlags.STOPPED;\r\n\t\t\tcompleteCall(animation);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * When the stop action is triggered, the elements' currently active call is\r\n\t * immediately stopped. When an element is stopped, the next item in its\r\n\t * animation queue is immediately triggered. If passed via a chained call\r\n\t * then this will only target the animations in that call, and not the\r\n\t * elements linked to it.\r\n\t * \r\n\t * A queue name may be passed in to specify that only animations on the\r\n\t * named queue are stopped. The default queue is named \"\". In addition the\r\n\t * value of `false` is allowed for the queue name.\r\n\t * \r\n\t * An final argument may be passed in to clear an element's remaining queued\r\n\t * calls. This may only be the value `true`.\r\n\t * \r\n\t * Note: The stop command runs prior to Velocity's Queueing phase since its\r\n\t * behavior is intended to take effect *immediately*, regardless of the\r\n\t * element's current queue state.\r\n\t */\r\n\tfunction stop(args: any[], elements: VelocityResult, promiseHandler?: VelocityPromise, action?: string): void {\r\n\t\tconst queueName: string | false = validateQueue(args[0], true),\r\n\t\t\tdefaultQueue: false | string = defaults.queue,\r\n\t\t\tfinishAll = args[queueName === undefined ? 0 : 1] === true;\r\n\r\n\t\tif (isVelocityResult(elements) && elements.velocity.animations) {\r\n\t\t\tfor (let i = 0, animations = elements.velocity.animations; i < animations.length; i++) {\r\n\t\t\t\tcheckAnimationShouldBeStopped(animations[i], queueName, defaultQueue);\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tlet activeCall = State.first,\r\n\t\t\t\tnextCall: AnimationCall;\r\n\r\n\t\t\twhile ((activeCall = State.firstNew)) {\r\n\t\t\t\tvalidateTweens(activeCall);\r\n\t\t\t}\r\n\t\t\tfor (activeCall = State.first; activeCall && (finishAll || activeCall !== State.firstNew); activeCall = nextCall || State.firstNew) {\r\n\t\t\t\tnextCall = activeCall._next;\r\n\t\t\t\tif (!elements || _inArray(elements, activeCall.element)) {\r\n\t\t\t\t\tcheckAnimationShouldBeStopped(activeCall, queueName, defaultQueue);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (promiseHandler) {\r\n\t\t\tif (isVelocityResult(elements) && elements.velocity.animations && elements.then) {\r\n\t\t\t\telements.then(promiseHandler._resolver);\r\n\t\t\t} else {\r\n\t\t\t\tpromiseHandler._resolver(elements);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tregisterAction([\"stop\", stop], true);\r\n}\r\n","///<reference path=\"actions.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Get or set a property from one or more elements.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\r\n\t/**\r\n\t * Expose a style shortcut - can't be used with chaining, but might be of\r\n\t * use to people.\r\n\t */\r\n\texport function style(elements: VelocityResult, property: {[property: string]: string}): VelocityResult;\r\n\texport function style(elements: VelocityResult, property: string): string | string[];\r\n\texport function style(elements: VelocityResult, property: string, value: string): VelocityResult;\r\n\texport function style(elements: VelocityResult, property: string | {[property: string]: string}, value?: string) {\r\n\t\treturn styleAction([property, value], elements);\r\n\t}\r\n\r\n\t/**\r\n\t * Get or set a style of Nomralised property value on one or more elements.\r\n\t * If there is no value passed then it will get, otherwise we will set.\r\n\t * \r\n\t * NOTE: When using \"get\" this will not touch the Promise as it is never\r\n\t * returned to the user.\r\n\t * \r\n\t * This can fail to set, and will reject the Promise if it does so.\r\n\t * \r\n\t * Velocity(elements, \"style\", \"property\", \"value\") => elements;\r\n\t * Velocity(elements, \"style\", {\"property\": \"value\", ...}) => elements;\r\n\t * Velocity(element, \"style\", \"property\") => \"value\";\r\n\t * Velocity(elements, \"style\", \"property\") => [\"value\", ...];\r\n\t */\r\n\tfunction styleAction(args?: any[], elements?: VelocityResult, promiseHandler?: VelocityPromise, action?: string): any {\r\n\t\tconst property = args[0],\r\n\t\t\tvalue = args[1];\r\n\r\n\t\tif (!property) {\r\n\t\t\tconsole.warn(\"VelocityJS: Cannot access a non-existant property!\");\r\n\t\t\treturn null;\r\n\t\t}\r\n\t\t// GET\r\n\t\tif (value === undefined && !isPlainObject(property)) {\r\n\t\t\t// If only a single animation is found and we're only targetting a\r\n\t\t\t// single element, then return the value directly\r\n\t\t\tif (elements.length === 1) {\r\n\t\t\t\treturn CSS.fixColors(CSS.getPropertyValue(elements[0], property));\r\n\t\t\t}\r\n\t\t\tconst result = [];\r\n\r\n\t\t\tfor (let i = 0; i < elements.length; i++) {\r\n\t\t\t\tresult.push(CSS.fixColors(CSS.getPropertyValue(elements[i], property)));\r\n\t\t\t}\r\n\t\t\treturn result;\r\n\t\t}\r\n\t\t// SET\r\n\t\tlet error: string;\r\n\r\n\t\tif (isPlainObject(property)) {\r\n\t\t\tfor (const propertyName in property) {\r\n\t\t\t\tfor (let i = 0; i < elements.length; i++) {\r\n\t\t\t\t\tconst value = property[propertyName];\r\n\r\n\t\t\t\t\tif (isString(value) || isNumber(value)) {\r\n\t\t\t\t\t\tCSS.setPropertyValue(elements[i], propertyName, property[propertyName]);\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\terror = (error ? error + \", \" : \"\") + \"Cannot set a property '\" + propertyName + \"' to an unknown type: \" + (typeof value);\r\n\t\t\t\t\t\tconsole.warn(\"VelocityJS: Cannot set a property '\" + propertyName + \"' to an unknown type:\", value);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t} else if (isString(value) || isNumber(value)) {\r\n\t\t\tfor (let i = 0; i < elements.length; i++) {\r\n\t\t\t\tCSS.setPropertyValue(elements[i], property, String(value));\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\terror = \"Cannot set a property '\" + property + \"' to an unknown type: \" + (typeof value);\r\n\t\t\tconsole.warn(\"VelocityJS: Cannot set a property '\" + property + \"' to an unknown type:\", value);\r\n\t\t}\r\n\t\tif (promiseHandler) {\r\n\t\t\tif (error) {\r\n\t\t\t\tpromiseHandler._rejecter(error);\r\n\t\t\t} else if (isVelocityResult(elements) && elements.velocity.animations && elements.then) {\r\n\t\t\t\telements.then(promiseHandler._resolver);\r\n\t\t\t} else {\r\n\t\t\t\tpromiseHandler._resolver(elements);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tregisterAction([\"style\", styleAction], true);\r\n}\r\n","///<reference path=\"actions.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Get or set a property from one or more elements.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\r\n\t/**\r\n\t * Expose a style shortcut - can't be used with chaining, but might be of\r\n\t * use to people.\r\n\t */\r\n\texport function tween(elements: HTMLorSVGElement[], percentComplete: number, properties: VelocityProperties, easing?: VelocityEasingType);\r\n\texport function tween(elements: HTMLorSVGElement[], percentComplete: number, propertyName: string, property: VelocityProperty, easing?: VelocityEasingType);\r\n\texport function tween(elements: HTMLorSVGElement[], percentComplete: number, properties: VelocityProperties | string, property?: VelocityProperty | VelocityEasingType, easing?: VelocityEasingType) {\r\n\t\treturn tweenAction(arguments as any, elements);\r\n\t}\r\n\r\n\t/**\r\n\t * \r\n\t */\r\n\tfunction tweenAction(args?: any[], elements?: HTMLorSVGElement[], promiseHandler?: VelocityPromise, action?: string): any {\r\n\t\tlet requireForcefeeding: boolean;\r\n\r\n\t\tif (!elements) {\r\n\t\t\tif (!args.length) {\r\n\t\t\t\tconsole.info(\"Velocity(<element>, \\\"tween\\\", percentComplete, property, end | [end, <easing>, <start>], <easing>) => value\\n\"\r\n\t\t\t\t\t+ \"Velocity(<element>, \\\"tween\\\", percentComplete, {property: end | [end, <easing>, <start>], ...}, <easing>) => {property: value, ...}\");\r\n\t\t\t\treturn null;\r\n\t\t\t}\r\n\t\t\telements = [document.body];\r\n\t\t\trequireForcefeeding = true;\r\n\t\t} else if (elements.length !== 1) {\r\n\t\t\t// TODO: Allow more than a single element to return an array of results\r\n\t\t\tthrow new Error(\"VelocityJS: Cannot tween more than one element!\");\r\n\t\t}\r\n\t\tconst percentComplete: number = args[0],\r\n\t\t\tfakeAnimation = {\r\n\t\t\t\telements: elements,\r\n\t\t\t\telement: elements[0],\r\n\t\t\t\tqueue: false,\r\n\t\t\t\toptions: {\r\n\t\t\t\t\tduration: 1000\r\n\t\t\t\t},\r\n\t\t\t\ttweens: null as {[property: string]: VelocityTween}\r\n\t\t\t},\r\n\t\t\tresult: {[property: string]: string} = {};\r\n\t\tlet properties: VelocityProperties = args[1],\r\n\t\t\tsingleResult: boolean,\r\n\t\t\teasing: VelocityEasingType = args[2],\r\n\t\t\tcount = 0;\r\n\r\n\t\tif (isString(args[1])) {\r\n\t\t\tsingleResult = true;\r\n\t\t\tproperties = {\r\n\t\t\t\t[args[1]]: args[2]\r\n\t\t\t};\r\n\t\t\teasing = args[3];\r\n\t\t} else if (Array.isArray(args[1])) {\r\n\t\t\tsingleResult = true;\r\n\t\t\tproperties = {\r\n\t\t\t\t\"tween\": args[1]\r\n\t\t\t} as any;\r\n\t\t\teasing = args[2];\r\n\t\t}\r\n\t\tif (!isNumber(percentComplete) || percentComplete < 0 || percentComplete > 1) {\r\n\t\t\tthrow new Error(\"VelocityJS: Must tween a percentage from 0 to 1!\");\r\n\t\t}\r\n\t\tif (!isPlainObject(properties)) {\r\n\t\t\tthrow new Error(\"VelocityJS: Cannot tween an invalid property!\");\r\n\t\t}\r\n\t\tif (requireForcefeeding) {\r\n\t\t\tfor (const property in properties) {\r\n\t\t\t\tif (properties.hasOwnProperty(property) && (!Array.isArray(properties[property]) || properties[property].length < 2)) {\r\n\t\t\t\t\tthrow new Error(\"VelocityJS: When not supplying an element you must force-feed values: \" + property);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\tconst activeEasing = validateEasing(getValue(easing, defaults.easing), 1000);\r\n\r\n\t\texpandProperties(fakeAnimation as AnimationCall, properties);\r\n\t\tfor (const property in fakeAnimation.tweens) {\r\n\t\t\t// For every element, iterate through each property.\r\n\t\t\tconst tween = fakeAnimation.tweens[property],\r\n\t\t\t\teasing = tween.easing || activeEasing,\r\n\t\t\t\tpattern = tween.pattern;\r\n\t\t\tlet currentValue = \"\";\r\n\r\n\t\t\tcount++;\r\n\t\t\tif (pattern) {\r\n\t\t\t\tfor (let i = 0; i < pattern.length; i++) {\r\n\t\t\t\t\tconst startValue = tween.start[i];\r\n\r\n\t\t\t\t\tif (startValue == null) {\r\n\t\t\t\t\t\tcurrentValue += pattern[i];\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tconst result = easing(percentComplete, startValue as number, tween.end[i] as number, property)\r\n\r\n\t\t\t\t\t\tcurrentValue += pattern[i] === true ? Math.round(result) : result;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tresult[property] = currentValue;\r\n\t\t}\r\n\t\tif (singleResult && count === 1) {\r\n\t\t\tfor (const property in result) {\r\n\t\t\t\tif (result.hasOwnProperty(property)) {\r\n\t\t\t\t\treturn result[property];\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn result;\r\n\t}\r\n\r\n\tregisterAction([\"tween\", tweenAction], true);\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\t/**\r\n\t * Container for page-wide Velocity state data.\r\n\t */\r\n\texport namespace State {\r\n\t\texport let\r\n\t\t\t/**\r\n\t\t\t * Detect if this is a NodeJS or web browser\r\n\t\t\t */\r\n\t\t\tisClient = window && window === window.window,\r\n\t\t\t/**\r\n\t\t\t * Detect mobile devices to determine if mobileHA should be turned\r\n\t\t\t * on.\r\n\t\t\t */\r\n\t\t\tisMobile = isClient && /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent),\r\n\t\t\t/**\r\n\t\t\t * The mobileHA option's behavior changes on older Android devices\r\n\t\t\t * (Gingerbread, versions 2.3.3-2.3.7).\r\n\t\t\t */\r\n\t\t\tisAndroid = isClient && /Android/i.test(navigator.userAgent),\r\n\t\t\t/**\r\n\t\t\t * The mobileHA option's behavior changes on older Android devices\r\n\t\t\t * (Gingerbread, versions 2.3.3-2.3.7).\r\n\t\t\t */\r\n\t\t\tisGingerbread = isClient && /Android 2\\.3\\.[3-7]/i.test(navigator.userAgent),\r\n\t\t\t/**\r\n\t\t\t * Chrome browser\r\n\t\t\t */\r\n\t\t\tisChrome = isClient && (window as any).chrome,\r\n\t\t\t/**\r\n\t\t\t * Firefox browser\r\n\t\t\t */\r\n\t\t\tisFirefox = isClient && /Firefox/i.test(navigator.userAgent),\r\n\t\t\t/**\r\n\t\t\t * Create a cached element for re-use when checking for CSS property\r\n\t\t\t * prefixes.\r\n\t\t\t */\r\n\t\t\tprefixElement = isClient && document.createElement(\"div\"),\r\n\t\t\t/**\r\n\t\t\t * Retrieve the appropriate scroll anchor and property name for the\r\n\t\t\t * browser: https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollY\r\n\t\t\t */\r\n\t\t\twindowScrollAnchor = isClient && window.pageYOffset !== undefined,\r\n\t\t\t/**\r\n\t\t\t * Cache the anchor used for animating window scrolling.\r\n\t\t\t */\r\n\t\t\tscrollAnchor = windowScrollAnchor ? window : (!isClient || document.documentElement || document.body.parentNode || document.body),\r\n\t\t\t/**\r\n\t\t\t * Cache the browser-specific property names associated with the\r\n\t\t\t * scroll anchor.\r\n\t\t\t */\r\n\t\t\tscrollPropertyLeft = windowScrollAnchor ? \"pageXOffset\" : \"scrollLeft\",\r\n\t\t\t/**\r\n\t\t\t * Cache the browser-specific property names associated with the\r\n\t\t\t * scroll anchor.\r\n\t\t\t */\r\n\t\t\tscrollPropertyTop = windowScrollAnchor ? \"pageYOffset\" : \"scrollTop\",\r\n\t\t\t/**\r\n\t\t\t * The className we add / remove when animating.\r\n\t\t\t */\r\n\t\t\tclassName = CLASSNAME,\r\n\t\t\t/**\r\n\t\t\t * Keep track of whether our RAF tick is running.\r\n\t\t\t */\r\n\t\t\tisTicking = false,\r\n\t\t\t/**\r\n\t\t\t * Container for every in-progress call to Velocity.\r\n\t\t\t */\r\n\t\t\tfirst: AnimationCall,\r\n\t\t\t/**\r\n\t\t\t * Container for every in-progress call to Velocity.\r\n\t\t\t */\r\n\t\t\tlast: AnimationCall,\r\n\t\t\t/**\r\n\t\t\t * First new animation - to shortcut starting them all up and push\r\n\t\t\t * any css reads to the start of the tick\r\n\t\t\t */\r\n\t\t\tfirstNew: AnimationCall\r\n\t};\r\n};\r\n","///<reference path=\"../state.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic.CSS {\r\n\t/**\r\n\t * Cache every camelCase match to avoid repeating lookups.\r\n\t */\r\n\tconst cache: {[property: string]: string} = createEmptyObject();\r\n\r\n\t/**\r\n\t * Camelcase a property name into its JavaScript notation (e.g.\r\n\t * \"background-color\" ==> \"backgroundColor\"). Camelcasing is used to\r\n\t * normalize property names between and across calls.\r\n\t */\r\n\texport function camelCase(property: string): string {\r\n\t\tconst fixed = cache[property];\r\n\r\n\t\tif (fixed) {\r\n\t\t\treturn fixed;\r\n\t\t}\r\n\t\treturn cache[property] = property.replace(/-([a-z])/g, ($: string, letter: string) => letter.toUpperCase());\r\n\t}\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic.CSS {\r\n\t/**\r\n\t * This is the list of color names -> rgb values. The object is in here so\r\n\t * that the actual name conversion can be in a separate file and not\r\n\t * included for custom builds.\r\n\t */\r\n\texport const ColorNames: {[name: string]: string} = createEmptyObject();\r\n\r\n\t/**\r\n\t * Convert a hex list to an rgba value. Designed to be used in replace.\r\n\t */\r\n\tfunction makeRGBA(ignore: any, r: string, g: string, b: string): string {\r\n\t\treturn \"rgba(\" + parseInt(r, 16) + \",\" + parseInt(g, 16) + \",\" + parseInt(b, 16) + \",1)\";\r\n\t}\r\n\r\n\tconst rxColor6 = /#([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})/gi,\r\n\t\trxColor3 = /#([a-f\\d])([a-f\\d])([a-f\\d])/gi,\r\n\t\trxColorName = /(rgba?\\(\\s*)?(\\b[a-z]+\\b)/g,\r\n\t\trxRGB = /rgb(a?)\\(([^\\)]+)\\)/gi,\r\n\t\trxSpaces = /\\s+/g;\r\n\r\n\t/**\r\n\t * Replace any css colour name with its rgba() value. It is possible to use\r\n\t * the name within an \"rgba(blue, 0.4)\" string this way.\r\n\t */\r\n\texport function fixColors(str: string): string {\r\n\t\treturn str\r\n\t\t\t.replace(rxColor6, makeRGBA)\r\n\t\t\t.replace(rxColor3, function($0, r, g, b) {\r\n\t\t\t\treturn makeRGBA($0, r + r, g + g, b + b);\r\n\t\t\t})\r\n\t\t\t.replace(rxColorName, function($0, $1, $2) {\r\n\t\t\t\tif (ColorNames[$2]) {\r\n\t\t\t\t\treturn ($1 ? $1 : \"rgba(\") + ColorNames[$2] + ($1 ? \"\" : \",1)\");\r\n\t\t\t\t}\r\n\t\t\t\treturn $0;\r\n\t\t\t})\r\n\t\t\t.replace(rxRGB, function($0, $1, $2: string) {\r\n\t\t\t\treturn \"rgba(\" + $2.replace(rxSpaces, \"\") + ($1 ? \"\" : \",1\") + \")\";\r\n\t\t\t});\r\n\t}\r\n}\r\n","///<reference path=\"fixColors.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic.CSS {\r\n\t// Converting from hex as it makes for a smaller file.\r\n\t// TODO: When build system changes to webpack, make this one optional.\r\n\tconst colorValues = {\r\n\t\t\"aliceblue\": 0xf0f8ff,\r\n\t\t\"antiquewhite\": 0xfaebd7,\r\n\t\t\"aqua\": 0x00ffff,\r\n\t\t\"aquamarine\": 0x7fffd4,\r\n\t\t\"azure\": 0xf0ffff,\r\n\t\t\"beige\": 0xf5f5dc,\r\n\t\t\"bisque\": 0xffe4c4,\r\n\t\t\"black\": 0x000000,\r\n\t\t\"blanchedalmond\": 0xffebcd,\r\n\t\t\"blue\": 0x0000ff,\r\n\t\t\"blueviolet\": 0x8a2be2,\r\n\t\t\"brown\": 0xa52a2a,\r\n\t\t\"burlywood\": 0xdeb887,\r\n\t\t\"cadetblue\": 0x5f9ea0,\r\n\t\t\"chartreuse\": 0x7fff00,\r\n\t\t\"chocolate\": 0xd2691e,\r\n\t\t\"coral\": 0xff7f50,\r\n\t\t\"cornflowerblue\": 0x6495ed,\r\n\t\t\"cornsilk\": 0xfff8dc,\r\n\t\t\"crimson\": 0xdc143c,\r\n\t\t\"cyan\": 0x00ffff,\r\n\t\t\"darkblue\": 0x00008b,\r\n\t\t\"darkcyan\": 0x008b8b,\r\n\t\t\"darkgoldenrod\": 0xb8860b,\r\n\t\t\"darkgray\": 0xa9a9a9,\r\n\t\t\"darkgrey\": 0xa9a9a9,\r\n\t\t\"darkgreen\": 0x006400,\r\n\t\t\"darkkhaki\": 0xbdb76b,\r\n\t\t\"darkmagenta\": 0x8b008b,\r\n\t\t\"darkolivegreen\": 0x556b2f,\r\n\t\t\"darkorange\": 0xff8c00,\r\n\t\t\"darkorchid\": 0x9932cc,\r\n\t\t\"darkred\": 0x8b0000,\r\n\t\t\"darksalmon\": 0xe9967a,\r\n\t\t\"darkseagreen\": 0x8fbc8f,\r\n\t\t\"darkslateblue\": 0x483d8b,\r\n\t\t\"darkslategray\": 0x2f4f4f,\r\n\t\t\"darkslategrey\": 0x2f4f4f,\r\n\t\t\"darkturquoise\": 0x00ced1,\r\n\t\t\"darkviolet\": 0x9400d3,\r\n\t\t\"deeppink\": 0xff1493,\r\n\t\t\"deepskyblue\": 0x00bfff,\r\n\t\t\"dimgray\": 0x696969,\r\n\t\t\"dimgrey\": 0x696969,\r\n\t\t\"dodgerblue\": 0x1e90ff,\r\n\t\t\"firebrick\": 0xb22222,\r\n\t\t\"floralwhite\": 0xfffaf0,\r\n\t\t\"forestgreen\": 0x228b22,\r\n\t\t\"fuchsia\": 0xff00ff,\r\n\t\t\"gainsboro\": 0xdcdcdc,\r\n\t\t\"ghostwhite\": 0xf8f8ff,\r\n\t\t\"gold\": 0xffd700,\r\n\t\t\"goldenrod\": 0xdaa520,\r\n\t\t\"gray\": 0x808080,\r\n\t\t\"grey\": 0x808080,\r\n\t\t\"green\": 0x008000,\r\n\t\t\"greenyellow\": 0xadff2f,\r\n\t\t\"honeydew\": 0xf0fff0,\r\n\t\t\"hotpink\": 0xff69b4,\r\n\t\t\"indianred\": 0xcd5c5c,\r\n\t\t\"indigo\": 0x4b0082,\r\n\t\t\"ivory\": 0xfffff0,\r\n\t\t\"khaki\": 0xf0e68c,\r\n\t\t\"lavender\": 0xe6e6fa,\r\n\t\t\"lavenderblush\": 0xfff0f5,\r\n\t\t\"lawngreen\": 0x7cfc00,\r\n\t\t\"lemonchiffon\": 0xfffacd,\r\n\t\t\"lightblue\": 0xadd8e6,\r\n\t\t\"lightcoral\": 0xf08080,\r\n\t\t\"lightcyan\": 0xe0ffff,\r\n\t\t\"lightgoldenrodyellow\": 0xfafad2,\r\n\t\t\"lightgray\": 0xd3d3d3,\r\n\t\t\"lightgrey\": 0xd3d3d3,\r\n\t\t\"lightgreen\": 0x90ee90,\r\n\t\t\"lightpink\": 0xffb6c1,\r\n\t\t\"lightsalmon\": 0xffa07a,\r\n\t\t\"lightseagreen\": 0x20b2aa,\r\n\t\t\"lightskyblue\": 0x87cefa,\r\n\t\t\"lightslategray\": 0x778899,\r\n\t\t\"lightslategrey\": 0x778899,\r\n\t\t\"lightsteelblue\": 0xb0c4de,\r\n\t\t\"lightyellow\": 0xffffe0,\r\n\t\t\"lime\": 0x00ff00,\r\n\t\t\"limegreen\": 0x32cd32,\r\n\t\t\"linen\": 0xfaf0e6,\r\n\t\t\"magenta\": 0xff00ff,\r\n\t\t\"maroon\": 0x800000,\r\n\t\t\"mediumaquamarine\": 0x66cdaa,\r\n\t\t\"mediumblue\": 0x0000cd,\r\n\t\t\"mediumorchid\": 0xba55d3,\r\n\t\t\"mediumpurple\": 0x9370db,\r\n\t\t\"mediumseagreen\": 0x3cb371,\r\n\t\t\"mediumslateblue\": 0x7b68ee,\r\n\t\t\"mediumspringgreen\": 0x00fa9a,\r\n\t\t\"mediumturquoise\": 0x48d1cc,\r\n\t\t\"mediumvioletred\": 0xc71585,\r\n\t\t\"midnightblue\": 0x191970,\r\n\t\t\"mintcream\": 0xf5fffa,\r\n\t\t\"mistyrose\": 0xffe4e1,\r\n\t\t\"moccasin\": 0xffe4b5,\r\n\t\t\"navajowhite\": 0xffdead,\r\n\t\t\"navy\": 0x000080,\r\n\t\t\"oldlace\": 0xfdf5e6,\r\n\t\t\"olive\": 0x808000,\r\n\t\t\"olivedrab\": 0x6b8e23,\r\n\t\t\"orange\": 0xffa500,\r\n\t\t\"orangered\": 0xff4500,\r\n\t\t\"orchid\": 0xda70d6,\r\n\t\t\"palegoldenrod\": 0xeee8aa,\r\n\t\t\"palegreen\": 0x98fb98,\r\n\t\t\"paleturquoise\": 0xafeeee,\r\n\t\t\"palevioletred\": 0xdb7093,\r\n\t\t\"papayawhip\": 0xffefd5,\r\n\t\t\"peachpuff\": 0xffdab9,\r\n\t\t\"peru\": 0xcd853f,\r\n\t\t\"pink\": 0xffc0cb,\r\n\t\t\"plum\": 0xdda0dd,\r\n\t\t\"powderblue\": 0xb0e0e6,\r\n\t\t\"purple\": 0x800080,\r\n\t\t\"rebeccapurple\": 0x663399,\r\n\t\t\"red\": 0xff0000,\r\n\t\t\"rosybrown\": 0xbc8f8f,\r\n\t\t\"royalblue\": 0x4169e1,\r\n\t\t\"saddlebrown\": 0x8b4513,\r\n\t\t\"salmon\": 0xfa8072,\r\n\t\t\"sandybrown\": 0xf4a460,\r\n\t\t\"seagreen\": 0x2e8b57,\r\n\t\t\"seashell\": 0xfff5ee,\r\n\t\t\"sienna\": 0xa0522d,\r\n\t\t\"silver\": 0xc0c0c0,\r\n\t\t\"skyblue\": 0x87ceeb,\r\n\t\t\"slateblue\": 0x6a5acd,\r\n\t\t\"slategray\": 0x708090,\r\n\t\t\"slategrey\": 0x708090,\r\n\t\t\"snow\": 0xfffafa,\r\n\t\t\"springgreen\": 0x00ff7f,\r\n\t\t\"steelblue\": 0x4682b4,\r\n\t\t\"tan\": 0xd2b48c,\r\n\t\t\"teal\": 0x008080,\r\n\t\t\"thistle\": 0xd8bfd8,\r\n\t\t\"tomato\": 0xff6347,\r\n\t\t\"turquoise\": 0x40e0d0,\r\n\t\t\"violet\": 0xee82ee,\r\n\t\t\"wheat\": 0xf5deb3,\r\n\t\t\"white\": 0xffffff,\r\n\t\t\"whitesmoke\": 0xf5f5f5,\r\n\t\t\"yellow\": 0xffff00,\r\n\t\t\"yellowgreen\": 0x9acd32\r\n\t};\r\n\r\n\tfor (let name in colorValues) {\r\n\t\tif (colorValues.hasOwnProperty(name)) {\r\n\t\t\tlet color = colorValues[name];\r\n\r\n\t\t\tColorNames[name] = Math.floor(color / 65536) + \",\" + Math.floor(color / 256 % 256) + \",\" + (color % 256);\r\n\t\t}\r\n\t}\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic.CSS {\r\n\r\n\t// TODO: This is still a complete mess\r\n\texport function computePropertyValue(element: HTMLorSVGElement, property: string): string {\r\n\t\tconst data = Data(element),\r\n\t\t\t// If computedStyle is cached, use it.\r\n\t\t\tcomputedStyle = data && data.computedStyle ? data.computedStyle : window.getComputedStyle(element, null);\r\n\t\tlet computedValue: string | number = 0;\r\n\r\n\t\tif (data && !data.computedStyle) {\r\n\t\t\tdata.computedStyle = computedStyle;\r\n\t\t}\r\n\t\tif (property === \"width\" || property === \"height\") {\r\n\t\t\t// Browsers do not return height and width values for elements\r\n\t\t\t// that are set to display:\"none\". Thus, we temporarily toggle\r\n\t\t\t// display to the element type's default value.\r\n\t\t\tconst toggleDisplay: boolean = getPropertyValue(element, \"display\") === \"none\";\r\n\r\n\t\t\t// When box-sizing isn't set to border-box, height and width\r\n\t\t\t// style values are incorrectly computed when an element's\r\n\t\t\t// scrollbars are visible (which expands the element's\r\n\t\t\t// dimensions). Thus, we defer to the more accurate\r\n\t\t\t// offsetHeight/Width property, which includes the total\r\n\t\t\t// dimensions for interior, border, padding, and scrollbar. We\r\n\t\t\t// subtract border and padding to get the sum of interior +\r\n\t\t\t// scrollbar.\r\n\t\t\t// TODO: offsetHeight does not exist on SVGElement\r\n\t\t\tif (toggleDisplay) {\r\n\t\t\t\tsetPropertyValue(element, \"display\", \"auto\");\r\n\t\t\t}\r\n\t\t\tcomputedValue = augmentDimension(element, property, true);\r\n\t\t\tif (toggleDisplay) {\r\n\t\t\t\tsetPropertyValue(element, \"display\", \"none\");\r\n\t\t\t}\r\n\t\t\treturn String(computedValue);\r\n\t\t}\r\n\r\n\t\t/* 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\t\t 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\t\t 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. */\r\n\t\t/* TODO: There is a borderColor normalisation in legacy/ - figure out where this is needed... */\r\n\r\n\t\tcomputedValue = computedStyle[property];\r\n\t\t/* Fall back to the property's style value (if defined) when computedValue returns nothing,\r\n\t\t which can happen when the element hasn't been painted. */\r\n\t\tif (!computedValue) {\r\n\t\t\tcomputedValue = element.style[property];\r\n\t\t}\r\n\t\t/* For top, right, bottom, and left (TRBL) values that are set to \"auto\" on elements of \"fixed\" or \"absolute\" position,\r\n\t\t defer to jQuery for converting \"auto\" to a numeric value. (For elements with a \"static\" or \"relative\" position, \"auto\" has the same\r\n\t\t effect as being set to 0, so no conversion is necessary.) */\r\n\t\t/* An example of why numeric conversion is necessary: When an element with \"position:absolute\" has an untouched \"left\"\r\n\t\t property, which reverts to \"auto\", left's value is 0 relative to its parent element, but is often non-zero relative\r\n\t\t 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\"). */\r\n\t\tif (computedValue === \"auto\") {\r\n\t\t\tswitch (property) {\r\n\t\t\t\tcase \"top\":\r\n\t\t\t\tcase \"left\":\r\n\t\t\t\t\tlet topLeft = true;\r\n\t\t\t\tcase \"right\":\r\n\t\t\t\tcase \"bottom\":\r\n\t\t\t\t\tconst position = getPropertyValue(element, \"position\"); /* GET */\r\n\r\n\t\t\t\t\tif (position === \"fixed\" || (topLeft && position === \"absolute\")) {\r\n\t\t\t\t\t\t// Note: this has no pixel unit on its returned values,\r\n\t\t\t\t\t\t// we re-add it here to conform with\r\n\t\t\t\t\t\t// computePropertyValue's behavior.\r\n\t\t\t\t\t\tcomputedValue = element.getBoundingClientRect[property] + \"px\"; /* GET */\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t}\r\n\t\t\t\t// Deliberate fallthrough!\r\n\t\t\t\tdefault:\r\n\t\t\t\t\tcomputedValue = \"0px\";\r\n\t\t\t\t\tbreak\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn computedValue ? String(computedValue) : \"\";\r\n\t}\r\n\r\n\t/**\r\n\t * Get a property value. This will grab via the cache if it exists, then\r\n\t * via any normalisations.\r\n\t */\r\n\texport function getPropertyValue(element: HTMLorSVGElement, propertyName: string, fn?: VelocityNormalizationsFn, skipCache?: boolean): string {\r\n\t\tconst data = Data(element);\r\n\t\tlet propertyValue: string;\r\n\r\n\t\tif (NoCacheNormalizations.has(propertyName)) {\r\n\t\t\tskipCache = true;\r\n\t\t}\r\n\t\tif (!skipCache && data && data.cache[propertyName] != null) {\r\n\t\t\tpropertyValue = data.cache[propertyName];\r\n\t\t} else {\r\n\t\t\tfn = fn || getNormalization(element, propertyName);\r\n\t\t\tif (fn) {\r\n\t\t\t\tpropertyValue = fn(element);\r\n\t\t\t\tif (data) {\r\n\t\t\t\t\tdata.cache[propertyName] = propertyValue;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (debug >= 2) {\r\n\t\t\tconsole.info(\"Get \" + propertyName + \": \" + propertyValue);\r\n\t\t}\r\n\t\treturn propertyValue;\r\n\t}\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic.CSS {\r\n\t/**\r\n\t * All possible units in CSS. Used to recognise units when parsing tweens.\r\n\t */\r\n\tconst Units = [\r\n\t\t\"%\", // relative\r\n\t\t\"em\", \"ex\", \"ch\", \"rem\", // font relative\r\n\t\t\"vw\", \"vh\", \"vmin\", \"vmax\", // viewport relative\r\n\t\t\"cm\", \"mm\", \"Q\", \"in\", \"pc\", \"pt\", \"px\", // absolute lengths\r\n\t\t\"deg\", \"grad\", \"rad\", \"turn\", // angles\r\n\t\t\"s\", \"ms\" // time\r\n\t];\r\n\r\n\t/**\r\n\t * Get the current unit for this property. Only used when parsing tweens\r\n\t * to check if the unit is changing between the start and end values.\r\n\t */\r\n\texport function getUnit(property: string, start?: number): string {\r\n\t\tstart = start || 0;\r\n\t\tif (property[start] && property[start] !== \" \") {\r\n\t\t\tfor (let i = 0, units = Units; i < units.length; i++) {\r\n\t\t\t\tconst unit = units[i];\r\n\t\t\t\tlet j = 0;\r\n\r\n\t\t\t\tdo {\r\n\t\t\t\t\tif (j >= unit.length) {\r\n\t\t\t\t\t\treturn unit;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (unit[j] !== property[start + j]) {\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t}\r\n\t\t\t\t} while (++j);\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn \"\";\r\n\t}\r\n\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic.CSS {\r\n\t/**\r\n\t * The singular setPropertyValue, which routes the logic for all\r\n\t * normalizations.\r\n\t */\r\n\texport function setPropertyValue(element: HTMLorSVGElement, propertyName: string, propertyValue: any, fn?: VelocityNormalizationsFn) {\r\n\t\tconst data = Data(element);\r\n\r\n\t\tif (isString(propertyValue)\r\n\t\t\t&& propertyValue[0] === \"c\"\r\n\t\t\t&& propertyValue[1] === \"a\"\r\n\t\t\t&& propertyValue[2] === \"l\"\r\n\t\t\t&& propertyValue[3] === \"c\"\r\n\t\t\t&& propertyValue[4] === \"(\"\r\n\t\t\t&& propertyValue[5] === \"0\"\r\n\t\t\t&& propertyValue[5] === \" \") {\r\n\t\t\t// Make sure we un-calc unit changing values - try not to trigger\r\n\t\t\t// this code any more often than we have to since it's expensive\r\n\t\t\tpropertyValue = propertyValue.replace(/^calc\\(0[^\\d]* \\+ ([^\\(\\)]+)\\)$/, \"$1\");\r\n\t\t}\r\n\t\tif (data && data.cache[propertyName] !== propertyValue) {\r\n\t\t\t// By setting it to undefined we force a true \"get\" later\r\n\t\t\tdata.cache[propertyName] = propertyValue || undefined;\r\n\t\t\tfn = fn || getNormalization(element, propertyName);\r\n\t\t\tif (fn) {\r\n\t\t\t\tfn(element, propertyValue);\r\n\t\t\t}\r\n\t\t\tif (debug >= 2) {\r\n\t\t\t\tconsole.info(\"Set \" + propertyName + \": \" + propertyValue, element);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n};\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\ninterface VelocityEasingsType {\r\n\t\"linear\": true;\r\n\t\"swing\": true;\r\n\t\"spring\": true;\r\n}\r\n\r\nnamespace VelocityStatic.Easing {\r\n\texport const Easings: {[name: string]: VelocityEasingFn} = createEmptyObject();\r\n\r\n\t/**\r\n\t * Used to register a easing. This should never be called by users\r\n\t * directly, instead it should be called via an action:<br/>\r\n\t * <code>Velocity(\"registerEasing\", \"name\", VelocityEasingFn);</code>\r\n\t *\r\n\t * @private\r\n\t */\r\n\texport function registerEasing(args?: [string, VelocityEasingFn]) {\r\n\t\tconst name: string = args[0],\r\n\t\t\tcallback = args[1];\r\n\r\n\t\tif (!isString(name)) {\r\n\t\t\tconsole.warn(\"VelocityJS: Trying to set 'registerEasing' name to an invalid value:\", name);\r\n\t\t} else if (!isFunction(callback)) {\r\n\t\t\tconsole.warn(\"VelocityJS: Trying to set 'registerEasing' callback to an invalid value:\", name, callback);\r\n\t\t} else if (Easings[name]) {\r\n\t\t\tconsole.warn(\"VelocityJS: Trying to override 'registerEasing' callback\", name);\r\n\t\t} else {\r\n\t\t\tEasings[name] = callback;\r\n\t\t}\r\n\t}\r\n\r\n\tregisterAction([\"registerEasing\", registerEasing], true);\r\n\r\n\t/* Basic (same as jQuery) easings. */\r\n\tregisterEasing([\"linear\", function(percentComplete, startValue, endValue) {\r\n\t\treturn startValue + percentComplete * (endValue - startValue);\r\n\t}]);\r\n\r\n\tregisterEasing([\"swing\", function(percentComplete, startValue, endValue) {\r\n\t\treturn startValue + (0.5 - Math.cos(percentComplete * Math.PI) / 2) * (endValue - startValue);\r\n\t}]);\r\n\r\n\t/* Bonus \"spring\" easing, which is a less exaggerated version of easeInOutElastic. */\r\n\tregisterEasing([\"spring\", function(percentComplete, startValue, endValue) {\r\n\t\treturn startValue + (1 - (Math.cos(percentComplete * 4.5 * Math.PI) * Math.exp(-percentComplete * 6))) * (endValue - startValue);\r\n\t}]);\r\n};\r\n","///<reference path=\"easings.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Back easings, based on code from https://github.com/yuichiroharai/easeplus-velocity\r\n */\r\n\r\ninterface VelocityEasingsType {\r\n\t\"easeInBack\": true;\r\n\t\"easeOutBack\": true;\r\n\t\"easeInOutBack\": true;\r\n}\r\n\r\nnamespace VelocityStatic.Easing {\r\n\texport function registerBackIn(name: string, amount: number) {\r\n\t\tregisterEasing([name, function(percentComplete: number, startValue: number, endValue: number): number {\r\n\t\t\tif (percentComplete === 0) {\r\n\t\t\t\treturn startValue;\r\n\t\t\t}\r\n\t\t\tif (percentComplete === 1) {\r\n\t\t\t\treturn endValue;\r\n\t\t\t}\r\n\t\t\treturn Math.pow(percentComplete, 2) * ((amount + 1) * percentComplete - amount) * (endValue - startValue);\r\n\t\t}]);\r\n\t}\r\n\r\n\texport function registerBackOut(name: string, amount: number) {\r\n\t\tregisterEasing([name, function(percentComplete: number, startValue: number, endValue: number): number {\r\n\t\t\tif (percentComplete === 0) {\r\n\t\t\t\treturn startValue;\r\n\t\t\t}\r\n\t\t\tif (percentComplete === 1) {\r\n\t\t\t\treturn endValue;\r\n\t\t\t}\r\n\t\t\treturn (Math.pow(--percentComplete, 2) * ((amount + 1) * percentComplete + amount) + 1) * (endValue - startValue);\r\n\t\t}]);\r\n\t}\r\n\r\n\texport function registerBackInOut(name: string, amount: number) {\r\n\t\tamount *= 1.525;\r\n\t\tregisterEasing([name, function(percentComplete: number, startValue: number, endValue: number): number {\r\n\t\t\tif (percentComplete === 0) {\r\n\t\t\t\treturn startValue;\r\n\t\t\t}\r\n\t\t\tif (percentComplete === 1) {\r\n\t\t\t\treturn endValue;\r\n\t\t\t}\r\n\t\t\treturn ((percentComplete *= 2) < 1\r\n\t\t\t\t? (Math.pow(percentComplete, 2) * ((amount + 1) * percentComplete - amount))\r\n\t\t\t\t: (Math.pow(percentComplete -= 2, 2) * ((amount + 1) * percentComplete + amount) + 2)\r\n\t\t\t) * 0.5 * (endValue - startValue);\r\n\t\t}]);\r\n\t}\r\n\r\n\tregisterBackIn(\"easeInBack\", 1.7);\r\n\tregisterBackOut(\"easeOutBack\", 1.7);\r\n\tregisterBackInOut(\"easeInOutBack\", 1.7);\r\n\r\n\t// TODO: Expose these as actions to register custom easings?\r\n};\r\n","///<reference path=\"easings.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Bezier curve function generator. Copyright Gaetan Renaudeau. MIT License: http://en.wikipedia.org/wiki/MIT_License\r\n */\r\n\r\ninterface VelocityEasingsType {\r\n\t\"ease\": true;\r\n\t\"easeIn\": true;\r\n\t\"ease-in\": true;\r\n\t\"easeOut\": true;\r\n\t\"ease-out\": true;\r\n\t\"easeInOut\": true;\r\n\t\"ease-in-out\": true;\r\n\t\"easeInSine\": true;\r\n\t\"easeOutSine\": true;\r\n\t\"easeInOutSine\": true;\r\n\t\"easeInQuad\": true;\r\n\t\"easeOutQuad\": true;\r\n\t\"easeInOutQuad\": true;\r\n\t\"easeInCubic\": true;\r\n\t\"easeOutCubic\": true;\r\n\t\"easeInOutCubic\": true;\r\n\t\"easeInQuart\": true;\r\n\t\"easeOutQuart\": true;\r\n\t\"easeInOutQuart\": true;\r\n\t\"easeInQuint\": true;\r\n\t\"easeOutQuint\": true;\r\n\t\"easeInOutQuint\": true;\r\n\t\"easeInExpo\": true;\r\n\t\"easeOutExpo\": true;\r\n\t\"easeInOutExpo\": true;\r\n\t\"easeInCirc\": true;\r\n\t\"easeOutCirc\": true;\r\n\t\"easeInOutCirc\": true;\r\n}\r\n\r\nnamespace VelocityStatic.Easing {\r\n\t/**\r\n\t * Fix to a range of <code>0 <= num <= 1</code>.\r\n\t */\r\n\tfunction fixRange(num: number) {\r\n\t\treturn Math.min(Math.max(num, 0), 1);\r\n\t}\r\n\r\n\tfunction A(aA1, aA2) {\r\n\t\treturn 1.0 - 3.0 * aA2 + 3.0 * aA1;\r\n\t}\r\n\r\n\tfunction B(aA1, aA2) {\r\n\t\treturn 3.0 * aA2 - 6.0 * aA1;\r\n\t}\r\n\r\n\tfunction C(aA1) {\r\n\t\treturn 3.0 * aA1;\r\n\t}\r\n\r\n\tfunction calcBezier(aT, aA1, aA2) {\r\n\t\treturn ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;\r\n\t}\r\n\r\n\tfunction getSlope(aT, aA1, aA2) {\r\n\t\treturn 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);\r\n\t}\r\n\r\n\texport function generateBezier(mX1: number, mY1: number, mX2: number, mY2: number): VelocityEasingFn {\r\n\t\tconst NEWTON_ITERATIONS = 4,\r\n\t\t\tNEWTON_MIN_SLOPE = 0.001,\r\n\t\t\tSUBDIVISION_PRECISION = 0.0000001,\r\n\t\t\tSUBDIVISION_MAX_ITERATIONS = 10,\r\n\t\t\tkSplineTableSize = 11,\r\n\t\t\tkSampleStepSize = 1.0 / (kSplineTableSize - 1.0),\r\n\t\t\tfloat32ArraySupported = \"Float32Array\" in window;\r\n\r\n\t\t/* Must contain four arguments. */\r\n\t\tif (arguments.length !== 4) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\t/* Arguments must be numbers. */\r\n\t\tfor (let i = 0; i < 4; ++i) {\r\n\t\t\tif (typeof arguments[i] !== \"number\" || isNaN(arguments[i]) || !isFinite(arguments[i])) {\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t/* X values must be in the [0, 1] range. */\r\n\t\tmX1 = fixRange(mX1);\r\n\t\tmX2 = fixRange(mX2);\r\n\r\n\t\tconst mSampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);\r\n\r\n\t\tfunction newtonRaphsonIterate(aX, aGuessT) {\r\n\t\t\tfor (let i = 0; i < NEWTON_ITERATIONS; ++i) {\r\n\t\t\t\tconst currentSlope = getSlope(aGuessT, mX1, mX2);\r\n\r\n\t\t\t\tif (currentSlope === 0.0) {\r\n\t\t\t\t\treturn aGuessT;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst currentX = calcBezier(aGuessT, mX1, mX2) - aX;\r\n\t\t\t\taGuessT -= currentX / currentSlope;\r\n\t\t\t}\r\n\r\n\t\t\treturn aGuessT;\r\n\t\t}\r\n\r\n\t\tfunction calcSampleValues() {\r\n\t\t\tfor (let i = 0; i < kSplineTableSize; ++i) {\r\n\t\t\t\tmSampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tfunction binarySubdivide(aX, aA, aB) {\r\n\t\t\tlet currentX, currentT, i = 0;\r\n\r\n\t\t\tdo {\r\n\t\t\t\tcurrentT = aA + (aB - aA) / 2.0;\r\n\t\t\t\tcurrentX = calcBezier(currentT, mX1, mX2) - aX;\r\n\t\t\t\tif (currentX > 0.0) {\r\n\t\t\t\t\taB = currentT;\r\n\t\t\t\t} else {\r\n\t\t\t\t\taA = currentT;\r\n\t\t\t\t}\r\n\t\t\t} while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);\r\n\r\n\t\t\treturn currentT;\r\n\t\t}\r\n\r\n\t\tfunction getTForX(aX) {\r\n\t\t\tlet intervalStart = 0.0,\r\n\t\t\t\tcurrentSample = 1,\r\n\t\t\t\tlastSample = kSplineTableSize - 1;\r\n\r\n\t\t\tfor (; currentSample !== lastSample && mSampleValues[currentSample] <= aX; ++currentSample) {\r\n\t\t\t\tintervalStart += kSampleStepSize;\r\n\t\t\t}\r\n\r\n\t\t\t--currentSample;\r\n\r\n\t\t\tconst dist = (aX - mSampleValues[currentSample]) / (mSampleValues[currentSample + 1] - mSampleValues[currentSample]),\r\n\t\t\t\tguessForT = intervalStart + dist * kSampleStepSize,\r\n\t\t\t\tinitialSlope = getSlope(guessForT, mX1, mX2);\r\n\r\n\t\t\tif (initialSlope >= NEWTON_MIN_SLOPE) {\r\n\t\t\t\treturn newtonRaphsonIterate(aX, guessForT);\r\n\t\t\t} else if (initialSlope === 0.0) {\r\n\t\t\t\treturn guessForT;\r\n\t\t\t} else {\r\n\t\t\t\treturn binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tlet _precomputed = false;\r\n\r\n\t\tfunction precompute() {\r\n\t\t\t_precomputed = true;\r\n\t\t\tif (mX1 !== mY1 || mX2 !== mY2) {\r\n\t\t\t\tcalcSampleValues();\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tconst f = function(percentComplete: number, startValue: number, endValue: number, property?: string) {\r\n\t\t\tif (!_precomputed) {\r\n\t\t\t\tprecompute();\r\n\t\t\t}\r\n\t\t\tif (percentComplete === 0) {\r\n\t\t\t\treturn startValue;\r\n\t\t\t}\r\n\t\t\tif (percentComplete === 1) {\r\n\t\t\t\treturn endValue;\r\n\t\t\t}\r\n\t\t\tif (mX1 === mY1 && mX2 === mY2) {\r\n\t\t\t\treturn startValue + percentComplete * (endValue - startValue);\r\n\t\t\t}\r\n\t\t\treturn startValue + calcBezier(getTForX(percentComplete), mY1, mY2) * (endValue - startValue);\r\n\t\t};\r\n\r\n\t\t(f as any).getControlPoints = function() {\r\n\t\t\treturn [{x: mX1, y: mY1}, {x: mX2, y: mY2}];\r\n\t\t};\r\n\r\n\t\tconst str = \"generateBezier(\" + [mX1, mY1, mX2, mY2] + \")\";\r\n\t\tf.toString = function() {\r\n\t\t\treturn str;\r\n\t\t};\r\n\r\n\t\treturn f;\r\n\t}\r\n\r\n\t/* Common easings */\r\n\tconst easeIn = generateBezier(0.42, 0.0, 1.00, 1.0),\r\n\t\teaseOut = generateBezier(0.00, 0.0, 0.58, 1.0),\r\n\t\teaseInOut = generateBezier(0.42, 0.0, 0.58, 1.0);\r\n\r\n\tregisterEasing([\"ease\", generateBezier(0.25, 0.1, 0.25, 1.0)]);\r\n\tregisterEasing([\"easeIn\", easeIn]);\r\n\tregisterEasing([\"ease-in\", easeIn]);\r\n\tregisterEasing([\"easeOut\", easeOut]);\r\n\tregisterEasing([\"ease-out\", easeOut]);\r\n\tregisterEasing([\"easeInOut\", easeInOut]);\r\n\tregisterEasing([\"ease-in-out\", easeInOut]);\r\n\tregisterEasing([\"easeInSine\", generateBezier(0.47, 0, 0.745, 0.715)]);\r\n\tregisterEasing([\"easeOutSine\", generateBezier(0.39, 0.575, 0.565, 1)]);\r\n\tregisterEasing([\"easeInOutSine\", generateBezier(0.445, 0.05, 0.55, 0.95)]);\r\n\tregisterEasing([\"easeInQuad\", generateBezier(0.55, 0.085, 0.68, 0.53)]);\r\n\tregisterEasing([\"easeOutQuad\", generateBezier(0.25, 0.46, 0.45, 0.94)]);\r\n\tregisterEasing([\"easeInOutQuad\", generateBezier(0.455, 0.03, 0.515, 0.955)]);\r\n\tregisterEasing([\"easeInCubic\", generateBezier(0.55, 0.055, 0.675, 0.19)]);\r\n\tregisterEasing([\"easeOutCubic\", generateBezier(0.215, 0.61, 0.355, 1)]);\r\n\tregisterEasing([\"easeInOutCubic\", generateBezier(0.645, 0.045, 0.355, 1)]);\r\n\tregisterEasing([\"easeInQuart\", generateBezier(0.895, 0.03, 0.685, 0.22)]);\r\n\tregisterEasing([\"easeOutQuart\", generateBezier(0.165, 0.84, 0.44, 1)]);\r\n\tregisterEasing([\"easeInOutQuart\", generateBezier(0.77, 0, 0.175, 1)]);\r\n\tregisterEasing([\"easeInQuint\", generateBezier(0.755, 0.05, 0.855, 0.06)]);\r\n\tregisterEasing([\"easeOutQuint\", generateBezier(0.23, 1, 0.32, 1)]);\r\n\tregisterEasing([\"easeInOutQuint\", generateBezier(0.86, 0, 0.07, 1)]);\r\n\tregisterEasing([\"easeInExpo\", generateBezier(0.95, 0.05, 0.795, 0.035)]);\r\n\tregisterEasing([\"easeOutExpo\", generateBezier(0.19, 1, 0.22, 1)]);\r\n\tregisterEasing([\"easeInOutExpo\", generateBezier(1, 0, 0, 1)]);\r\n\tregisterEasing([\"easeInCirc\", generateBezier(0.6, 0.04, 0.98, 0.335)]);\r\n\tregisterEasing([\"easeOutCirc\", generateBezier(0.075, 0.82, 0.165, 1)]);\r\n\tregisterEasing([\"easeInOutCirc\", generateBezier(0.785, 0.135, 0.15, 0.86)]);\r\n};\r\n","///<reference path=\"easings.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Bounce easings, based on code from https://github.com/yuichiroharai/easeplus-velocity\r\n */\r\n\r\ninterface VelocityEasingsType {\r\n\t\"easeInBounce\": true;\r\n\t\"easeOutBounce\": true;\r\n\t\"easeInOutBounce\": true;\r\n}\r\n\r\nnamespace VelocityStatic.Easing {\r\n\tfunction easeOutBounce(percentComplete: number): number {\r\n\t\tif (percentComplete < 1 / 2.75) {\r\n\t\t\treturn (7.5625 * percentComplete * percentComplete);\r\n\t\t}\r\n\t\tif (percentComplete < 2 / 2.75) {\r\n\t\t\treturn (7.5625 * (percentComplete -= 1.5 / 2.75) * percentComplete + 0.75);\r\n\t\t}\r\n\t\tif (percentComplete < 2.5 / 2.75) {\r\n\t\t\treturn (7.5625 * (percentComplete -= 2.25 / 2.75) * percentComplete + 0.9375);\r\n\t\t}\r\n\t\treturn (7.5625 * (percentComplete -= 2.625 / 2.75) * percentComplete + 0.984375);\r\n\t};\r\n\r\n\tfunction easeInBounce(percentComplete: number): number {\r\n\t\treturn 1 - easeOutBounce(1 - percentComplete);\r\n\t};\r\n\r\n\tregisterEasing([\"easeInBounce\", function(percentComplete: number, startValue: number, endValue: number): number {\r\n\t\tif (percentComplete === 0) {\r\n\t\t\treturn startValue;\r\n\t\t}\r\n\t\tif (percentComplete === 1) {\r\n\t\t\treturn endValue;\r\n\t\t}\r\n\t\treturn easeInBounce(percentComplete) * (endValue - startValue);\r\n\t}]);\r\n\r\n\tregisterEasing([\"easeOutBounce\", function(percentComplete: number, startValue: number, endValue: number): number {\r\n\t\tif (percentComplete === 0) {\r\n\t\t\treturn startValue;\r\n\t\t}\r\n\t\tif (percentComplete === 1) {\r\n\t\t\treturn endValue;\r\n\t\t}\r\n\t\treturn easeOutBounce(percentComplete) * (endValue - startValue);\r\n\t}]);\r\n\r\n\tregisterEasing([\"easeInOutBounce\", function(percentComplete: number, startValue: number, endValue: number): number {\r\n\t\tif (percentComplete === 0) {\r\n\t\t\treturn startValue;\r\n\t\t}\r\n\t\tif (percentComplete === 1) {\r\n\t\t\treturn endValue;\r\n\t\t}\r\n\t\treturn (percentComplete < 0.5\r\n\t\t\t? easeInBounce(percentComplete * 2) * .5\r\n\t\t\t: easeOutBounce(percentComplete * 2 - 1) * 0.5 + 0.5\r\n\t\t) * (endValue - startValue);\r\n\t}]);\r\n};\r\n","///<reference path=\"easings.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Elastic easings, based on code from https://github.com/yuichiroharai/easeplus-velocity\r\n */\r\n\r\ninterface VelocityEasingsType {\r\n\t\"easeInElastic\": true;\r\n\t\"easeOutElastic\": true;\r\n\t\"easeInOutElastic\": true;\r\n}\r\n\r\nnamespace VelocityStatic.Easing {\r\n\tconst pi2 = Math.PI * 2;\r\n\r\n\texport function registerElasticIn(name: string, amplitude: number, period: number) {\r\n\t\tregisterEasing([name, function(percentComplete: number, startValue: number, endValue: number): number {\r\n\t\t\tif (percentComplete === 0) {\r\n\t\t\t\treturn startValue;\r\n\t\t\t}\r\n\t\t\tif (percentComplete === 1) {\r\n\t\t\t\treturn endValue;\r\n\t\t\t}\r\n\t\t\treturn -(amplitude * Math.pow(2, 10 * (percentComplete -= 1)) * Math.sin((percentComplete - (period / pi2 * Math.asin(1 / amplitude))) * pi2 / period)) * (endValue - startValue);\r\n\t\t}]);\r\n\t}\r\n\r\n\texport function registerElasticOut(name: string, amplitude: number, period: number) {\r\n\t\tregisterEasing([name, function(percentComplete: number, startValue: number, endValue: number): number {\r\n\t\t\tif (percentComplete === 0) {\r\n\t\t\t\treturn startValue;\r\n\t\t\t}\r\n\t\t\tif (percentComplete === 1) {\r\n\t\t\t\treturn endValue;\r\n\t\t\t}\r\n\t\t\treturn (amplitude * Math.pow(2, -10 * percentComplete) * Math.sin((percentComplete - (period / pi2 * Math.asin(1 / amplitude))) * pi2 / period) + 1) * (endValue - startValue);\r\n\t\t}]);\r\n\t}\r\n\r\n\texport function registerElasticInOut(name: string, amplitude: number, period: number) {\r\n\t\tregisterEasing([name, function(percentComplete: number, startValue: number, endValue: number): number {\r\n\t\t\tif (percentComplete === 0) {\r\n\t\t\t\treturn startValue;\r\n\t\t\t}\r\n\t\t\tif (percentComplete === 1) {\r\n\t\t\t\treturn endValue;\r\n\t\t\t}\r\n\t\t\tconst s = period / pi2 * Math.asin(1 / amplitude);\r\n\r\n\t\t\tpercentComplete = percentComplete * 2 - 1;\r\n\t\t\treturn (percentComplete < 0\r\n\t\t\t\t? -0.5 * (amplitude * Math.pow(2, 10 * percentComplete) * Math.sin((percentComplete - s) * pi2 / period))\r\n\t\t\t\t: amplitude * Math.pow(2, -10 * percentComplete) * Math.sin((percentComplete - s) * pi2 / period) * 0.5 + 1\r\n\t\t\t) * (endValue - startValue);\r\n\t\t}]);\r\n\t}\r\n\r\n\tregisterElasticIn(\"easeInElastic\", 1, 0.3);\r\n\tregisterElasticOut(\"easeOutElastic\", 1, 0.3);\r\n\tregisterElasticInOut(\"easeInOutElastic\", 1, 0.3 * 1.5);\r\n\r\n\t// TODO: Expose these as actions to register custom easings?\r\n};\r\n","///<reference path=\"easings.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic.Easing {\r\n\r\n\tinterface springState {\r\n\t\tx: number;\r\n\t\tv: number;\r\n\t\ttension: number;\r\n\t\tfriction: number;\r\n\t};\r\n\r\n\tinterface springDelta {\r\n\t\tdx: number;\r\n\t\tdv: number;\r\n\t};\r\n\r\n\t/* Runge-Kutta spring physics function generator. Adapted from Framer.js, copyright Koen Bok. MIT License: http://en.wikipedia.org/wiki/MIT_License */\r\n\t/* 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\t then adjusts the time delta -- using the relation between actual time and duration -- to calculate the path for the duration-constrained animation. */\r\n\tfunction springAccelerationForState(state: springState) {\r\n\t\treturn (-state.tension * state.x) - (state.friction * state.v);\r\n\t}\r\n\r\n\tfunction springEvaluateStateWithDerivative(initialState: springState, dt: number, derivative: springDelta): springDelta {\r\n\t\tconst state = {\r\n\t\t\tx: initialState.x + derivative.dx * dt,\r\n\t\t\tv: initialState.v + derivative.dv * dt,\r\n\t\t\ttension: initialState.tension,\r\n\t\t\tfriction: initialState.friction\r\n\t\t};\r\n\r\n\t\treturn {\r\n\t\t\tdx: state.v,\r\n\t\t\tdv: springAccelerationForState(state)\r\n\t\t};\r\n\t}\r\n\r\n\tfunction springIntegrateState(state: springState, dt: number) {\r\n\t\tconst a = {\r\n\t\t\tdx: state.v,\r\n\t\t\tdv: springAccelerationForState(state)\r\n\t\t},\r\n\t\t\tb = springEvaluateStateWithDerivative(state, dt * 0.5, a),\r\n\t\t\tc = springEvaluateStateWithDerivative(state, dt * 0.5, b),\r\n\t\t\td = springEvaluateStateWithDerivative(state, dt, c),\r\n\t\t\tdxdt = 1.0 / 6.0 * (a.dx + 2.0 * (b.dx + c.dx) + d.dx),\r\n\t\t\tdvdt = 1.0 / 6.0 * (a.dv + 2.0 * (b.dv + c.dv) + d.dv);\r\n\r\n\t\tstate.x = state.x + dxdt * dt;\r\n\t\tstate.v = state.v + dvdt * dt;\r\n\r\n\t\treturn state;\r\n\t}\r\n\r\n\texport function generateSpringRK4(tension: number, friction: number): number;\r\n\texport function generateSpringRK4(tension: number, friction: number, duration: number): VelocityEasingFn;\r\n\texport function generateSpringRK4(tension: number, friction: number, duration?: number): any {\r\n\t\tlet initState: springState = {\r\n\t\t\tx: -1,\r\n\t\t\tv: 0,\r\n\t\t\ttension: parseFloat(tension as any) || 500,\r\n\t\t\tfriction: parseFloat(friction as any) || 20\r\n\t\t},\r\n\t\t\tpath = [0],\r\n\t\t\ttime_lapsed = 0,\r\n\t\t\ttolerance = 1 / 10000,\r\n\t\t\tDT = 16 / 1000,\r\n\t\t\thave_duration = duration != null, // deliberate \"==\", as undefined == null != 0\r\n\t\t\tdt: number,\r\n\t\t\tlast_state: springState;\r\n\r\n\t\t/* Calculate the actual time it takes for this animation to complete with the provided conditions. */\r\n\t\tif (have_duration) {\r\n\t\t\t/* Run the simulation without a duration. */\r\n\t\t\ttime_lapsed = generateSpringRK4(initState.tension, initState.friction);\r\n\t\t\t/* Compute the adjusted time delta. */\r\n\t\t\tdt = (time_lapsed as number) / duration * DT;\r\n\t\t} else {\r\n\t\t\tdt = DT;\r\n\t\t}\r\n\r\n\t\twhile (true) {\r\n\t\t\t/* Next/step function .*/\r\n\t\t\tlast_state = springIntegrateState(last_state || initState, dt);\r\n\t\t\t/* Store the position. */\r\n\t\t\tpath.push(1 + last_state.x);\r\n\t\t\ttime_lapsed += 16;\r\n\t\t\t/* If the change threshold is reached, break. */\r\n\t\t\tif (!(Math.abs(last_state.x) > tolerance && Math.abs(last_state.v) > tolerance)) {\r\n\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t/* If duration is not defined, return the actual time required for completing this animation. Otherwise, return a closure that holds the\r\n\t\t computed path and returns a snapshot of the position according to a given percentComplete. */\r\n\t\treturn !have_duration ? time_lapsed : function(percentComplete: number, startValue: number, endValue: number) {\r\n\t\t\tif (percentComplete === 0) {\r\n\t\t\t\treturn startValue;\r\n\t\t\t}\r\n\t\t\tif (percentComplete === 1) {\r\n\t\t\t\treturn endValue;\r\n\t\t\t}\r\n\t\t\treturn startValue + path[(percentComplete * (path.length - 1)) | 0] * (endValue - startValue);\r\n\t\t};\r\n\t};\r\n};\r\n","///<reference path=\"easings.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details\r\n * \r\n * Step easing generator.\r\n */\r\n\r\nnamespace VelocityStatic.Easing {\r\n\tconst cache: {[steps: number]: VelocityEasingFn} = {};\r\n\r\n\texport function generateStep(steps): VelocityEasingFn {\r\n\t\tconst fn = cache[steps];\r\n\r\n\t\tif (fn) {\r\n\t\t\treturn fn;\r\n\t\t}\r\n\t\treturn cache[steps] = function(percentComplete: number, startValue: number, endValue: number) {\r\n\t\t\tif (percentComplete === 0) {\r\n\t\t\t\treturn startValue;\r\n\t\t\t}\r\n\t\t\tif (percentComplete === 1) {\r\n\t\t\t\treturn endValue;\r\n\t\t\t}\r\n\t\t\treturn startValue + Math.round(percentComplete * steps) * (1 / steps) * (endValue - startValue);\r\n\t\t};\r\n\t}\r\n};\r\n","///<reference path=\"easings.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n * \r\n * Easings to act on strings, either set at the start or at the end depending on\r\n * need.\r\n */\r\n\r\ninterface VelocityEasingsType {\r\n\t\"at-start\": true;\r\n\t\"during\": true;\r\n\t\"at-end\": true;\r\n}\r\n\r\nnamespace VelocityStatic.Easing {\r\n\t/**\r\n\t * Easing function that sets to the specified value immediately after the\r\n\t * animation starts.\r\n\t */\r\n\tregisterEasing([\"at-start\", function(percentComplete: number, startValue: any, endValue: any): any {\r\n\t\treturn percentComplete === 0\r\n\t\t\t? startValue\r\n\t\t\t: endValue;\r\n\t} as any]);\r\n\r\n\t/**\r\n\t * Easing function that sets to the specified value while the animation is\r\n\t * running.\r\n\t */\r\n\tregisterEasing([\"during\", function(percentComplete: number, startValue: any, endValue: any): any {\r\n\t\treturn percentComplete === 0 || percentComplete === 1\r\n\t\t\t? startValue\r\n\t\t\t: endValue;\r\n\t} as any]);\r\n\r\n\t/**\r\n\t * Easing function that sets to the specified value when the animation ends.\r\n\t */\r\n\tregisterEasing([\"at-end\", function(percentComplete: number, startValue: any, endValue: any): any {\r\n\t\treturn percentComplete === 1\r\n\t\t\t? endValue\r\n\t\t\t: startValue;\r\n\t} as any]);\r\n};\r\n","///<reference path=\"../actions/_all.d.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n * \r\n * Normalisations are used when getting or setting a (normally css compound\r\n * properties) value that can have a different order in different browsers.\r\n * \r\n * It can also be used to extend and create specific properties that otherwise\r\n * don't exist (such as for scrolling, or inner/outer dimensions).\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\r\n\t/**\r\n\t * The highest type index for finding the best normalization for a property.\r\n\t */\r\n\texport let MaxType: number = -1;\r\n\r\n\t/**\r\n\t * Unlike \"actions\", normalizations can always be replaced by users.\r\n\t */\r\n\texport const Normalizations: {[name: string]: VelocityNormalizationsFn}[] = [];\r\n\r\n\t/**\r\n\t * Store a cross-reference to units to be added to specific normalization\r\n\t * functions if the user supplies a unit-less number.\r\n\t * \r\n\t * This is pretty much confined to adding \"px\" to several css properties.\r\n\t */\r\n\texport const NormalizationUnits: {[unit: string]: VelocityNormalizationsFn[]} = createEmptyObject();\r\n\r\n\t/**\r\n\t * Any normalisations that should never be cached are listed here.\r\n\t * Faster than an array - https://jsperf.com/array-includes-and-find-methods-vs-set-has\r\n\t */\r\n\texport const NoCacheNormalizations = new Set<string>();\r\n\r\n\t/**\r\n\t * Used to define a constructor.\r\n\t */\r\n\tinterface ClassConstructor {\r\n\t\tnew(): Object;\r\n\t}\r\n\r\n\t/**\r\n\t * An array of classes used for the per-class normalizations. This\r\n\t * translates into a bitwise enum for quick cross-reference, and so that\r\n\t * the element doesn't need multiple <code>instanceof</code> calls every\r\n\t * frame.\r\n\t */\r\n\texport const constructors: ClassConstructor[] = [];\r\n\r\n\t/**\r\n\t * Used to register a normalization. This should never be called by users\r\n\t * directly, instead it should be called via an action:<br/>\r\n\t * <code>Velocity(\"registerNormalization\", Element, \"name\", VelocityNormalizationsFn[, false]);</code>\r\n\t * \r\n\t * The fourth argument can be an explicit <code>false</code>, which prevents\r\n\t * the property from being cached. Please note that this can be dangerous\r\n\t * for performance!\r\n\t *\r\n\t * @private\r\n\t */\r\n\texport function registerNormalization(args?: [ClassConstructor, string, VelocityNormalizationsFn] | [ClassConstructor, string, VelocityNormalizationsFn, boolean] | [ClassConstructor, string, VelocityNormalizationsFn, string] | [ClassConstructor, string, VelocityNormalizationsFn, string, boolean]) {\r\n\t\tconst constructor = args[0],\r\n\t\t\tname: string = args[1],\r\n\t\t\tcallback = args[2];\r\n\r\n\t\tif (isString(constructor) || !(constructor instanceof Object)) {\r\n\t\t\tconsole.warn(\"VelocityJS: Trying to set 'registerNormalization' constructor to an invalid value:\", constructor);\r\n\t\t} else if (!isString(name)) {\r\n\t\t\tconsole.warn(\"VelocityJS: Trying to set 'registerNormalization' name to an invalid value:\", name);\r\n\t\t} else if (!isFunction(callback)) {\r\n\t\t\tconsole.warn(\"VelocityJS: Trying to set 'registerNormalization' callback to an invalid value:\", name, callback);\r\n\t\t} else {\r\n\t\t\tlet index = constructors.indexOf(constructor),\r\n\t\t\t\tnextArg = 3;\r\n\r\n\t\t\tif (index < 0) {\r\n\t\t\t\tMaxType = index = constructors.push(constructor) - 1;\r\n\t\t\t\tNormalizations[index] = createEmptyObject();\r\n\t\t\t}\r\n\t\t\tNormalizations[index][name] = callback;\r\n\t\t\tif (isString(args[nextArg])) {\r\n\t\t\t\tlet unit = args[nextArg++] as string,\r\n\t\t\t\t\tunits = NormalizationUnits[unit];\r\n\r\n\t\t\t\tif (!units) {\r\n\t\t\t\t\tunits = NormalizationUnits[unit] = [];\r\n\t\t\t\t}\r\n\t\t\t\tunits.push(callback);\r\n\t\t\t}\r\n\t\t\tif (args[nextArg] === false) {\r\n\t\t\t\tNoCacheNormalizations.add(name);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Used to check if a normalisation exists on a specific class.\r\n\t */\r\n\texport function hasNormalization(args?: [ClassConstructor, string]) {\r\n\t\tconst constructor = args[0],\r\n\t\t\tname: string = args[1];\r\n\t\tlet index = constructors.indexOf(constructor);\r\n\r\n\t\treturn !!Normalizations[index][name];\r\n\t}\r\n\r\n\t/**\r\n\t * Get the unit to add to a unitless number based on the normalization used.\r\n\t */\r\n\texport function getNormalizationUnit(fn: VelocityNormalizationsFn) {\r\n\t\tfor (let unit in NormalizationUnits) {\r\n\t\t\tif (_inArray(NormalizationUnits[unit], fn)) {\r\n\t\t\t\treturn unit;\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn \"\";\r\n\t}\r\n\r\n\t/**\r\n\t * Get the normalization for an element and propertyName combination. This\r\n\t * value should be cached at asking time, as it may change if the user adds\r\n\t * more normalizations.\r\n\t */\r\n\texport function getNormalization(element: HTMLorSVGElement, propertyName: string) {\r\n\t\tconst data = Data(element);\r\n\t\tlet fn: VelocityNormalizationsFn;\r\n\r\n\t\tfor (let index = MaxType, types = data.types; !fn && index >= 0; index--) {\r\n\t\t\tif (types & (1 << index)) {\r\n\t\t\t\tfn = Normalizations[index][propertyName];\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn fn;\r\n\t}\r\n\r\n\tregisterAction([\"registerNormalization\", registerNormalization]);\r\n\tregisterAction([\"hasNormalization\", hasNormalization]);\r\n}\r\n","///<reference path=\"../normalizations.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic.CSS {\r\n\r\n\t/**\r\n\t * Get/set an attribute.\r\n\t */\r\n\tfunction getAttribute(name: string) {\r\n\t\treturn function(element: Element, propertyValue?: string): string | void {\r\n\t\t\tif (propertyValue === undefined) {\r\n\t\t\t\treturn element.getAttribute(name);\r\n\t\t\t}\r\n\t\t\telement.setAttribute(name, propertyValue);\r\n\t\t} as VelocityNormalizationsFn;\r\n\t}\r\n\r\n\tconst base = document.createElement(\"div\"),\r\n\t\trxSubtype = /^SVG(.*)Element$/,\r\n\t\trxElement = /Element$/;\r\n\r\n\tObject.getOwnPropertyNames(window).forEach(function(globals) {\r\n\t\tconst subtype = rxSubtype.exec(globals);\r\n\r\n\t\tif (subtype && subtype[1] !== \"SVG\") { // Don't do SVGSVGElement.\r\n\t\t\ttry {\r\n\t\t\t\tconst element = subtype[1] ? document.createElementNS(\"http://www.w3.org/2000/svg\", (subtype[1] || \"svg\").toLowerCase()) : document.createElement(\"svg\"),\r\n\t\t\t\t\tconstructor = element.constructor;\r\n\r\n\t\t\t\tfor (let attribute in element) {\r\n\t\t\t\t\tconst value = element[attribute];\r\n\r\n\t\t\t\t\tif (isString(attribute)\r\n\t\t\t\t\t\t&& !(attribute[0] === \"o\" && attribute[1] === \"n\")\r\n\t\t\t\t\t\t&& attribute !== attribute.toUpperCase()\r\n\t\t\t\t\t\t&& !rxElement.test(attribute)\r\n\t\t\t\t\t\t&& !(attribute in base)\r\n\t\t\t\t\t\t&& !isFunction(value)) {\r\n\t\t\t\t\t\t// TODO: Should this all be set on the generic SVGElement, it would save space and time, but not as powerful\r\n\t\t\t\t\t\tregisterNormalization([constructor as any, attribute, getAttribute(attribute)]);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t} catch (e) {\r\n\t\t\t\tconsole.error(\"VelocityJS: Error when trying to identify SVG attributes on \" + globals + \".\", e);\r\n\t\t\t}\r\n\t\t}\r\n\t});\r\n}\r\n","///<reference path=\"../normalizations.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic.CSS {\r\n\r\n\t/**\r\n\t * Get/set the width or height.\r\n\t */\r\n\tfunction getDimension(name: string) {\r\n\t\treturn function(element: HTMLorSVGElement, propertyValue?: string): string | void {\r\n\t\t\tif (propertyValue === undefined) {\r\n\t\t\t\t// Firefox throws an error if .getBBox() is called on an SVG that isn't attached to the DOM.\r\n\t\t\t\ttry {\r\n\t\t\t\t\treturn (element as SVGGraphicsElement).getBBox()[name] + \"px\";\r\n\t\t\t\t} catch (e) {\r\n\t\t\t\t\treturn \"0px\";\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\telement.setAttribute(name, propertyValue);\r\n\t\t} as VelocityNormalizationsFn;\r\n\t}\r\n\r\n\tregisterNormalization([SVGElement, \"width\", getDimension(\"width\")]);\r\n\tregisterNormalization([SVGElement, \"height\", getDimension(\"height\")]);\r\n}\r\n","///<reference path=\"normalizations.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\r\n\t/**\r\n\t * Figure out the dimensions for this width / height based on the\r\n\t * potential borders and whether we care about them.\r\n\t */\r\n\texport function augmentDimension(element: HTMLorSVGElement, name: \"width\" | \"height\", wantInner: boolean): number {\r\n\t\tconst isBorderBox = CSS.getPropertyValue(element, \"boxSizing\").toString().toLowerCase() === \"border-box\";\r\n\r\n\t\tif (isBorderBox === wantInner) {\r\n\t\t\t// in box-sizing mode, the CSS width / height accessors already\r\n\t\t\t// give the outerWidth / outerHeight.\r\n\t\t\tconst sides = name === \"width\" ? [\"Left\", \"Right\"] : [\"Top\", \"Bottom\"],\r\n\t\t\t\tfields = [\"padding\" + sides[0], \"padding\" + sides[1], \"border\" + sides[0] + \"Width\", \"border\" + sides[1] + \"Width\"];\r\n\t\t\tlet i: number,\r\n\t\t\t\tvalue: number,\r\n\t\t\t\taugment = 0;\r\n\r\n\t\t\tfor (i = 0; i < fields.length; i++) {\r\n\t\t\t\tvalue = parseFloat(CSS.getPropertyValue(element, fields[i]) as string);\r\n\t\t\t\tif (!isNaN(value)) {\r\n\t\t\t\t\taugment += value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\treturn wantInner ? -augment : augment;\r\n\t\t}\r\n\t\treturn 0;\r\n\t}\r\n\r\n\t/**\r\n\t * Get/set the inner/outer dimension.\r\n\t */\r\n\tfunction getDimension(name: \"width\" | \"height\", wantInner: boolean) {\r\n\t\treturn function(element: HTMLorSVGElement, propertyValue?: string): string | void {\r\n\t\t\tif (propertyValue === undefined) {\r\n\t\t\t\treturn augmentDimension(element, name, wantInner) + \"px\";\r\n\t\t\t}\r\n\t\t\tCSS.setPropertyValue(element, name, (parseFloat(propertyValue) - augmentDimension(element, name, wantInner)) + \"px\");\r\n\t\t} as VelocityNormalizationsFn;\r\n\t}\r\n\r\n\tregisterNormalization([Element, \"innerWidth\", getDimension(\"width\", true)]);\r\n\tregisterNormalization([Element, \"innerHeight\", getDimension(\"height\", true)]);\r\n\tregisterNormalization([Element, \"outerWidth\", getDimension(\"width\", false)]);\r\n\tregisterNormalization([Element, \"outerHeight\", getDimension(\"height\", false)]);\r\n}\r\n","///<reference path=\"normalizations.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\texport const 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,\r\n\t\tlistItemRx = /^(li)$/i,\r\n\t\ttableRowRx = /^(tr)$/i,\r\n\t\ttableRx = /^(table)$/i,\r\n\t\ttableRowGroupRx = /^(tbody)$/i;\r\n\r\n\t/**\r\n\t * Display has an extra value of \"auto\" that works out the correct value\r\n\t * based on the type of element.\r\n\t */\r\n\tfunction display(element: HTMLorSVGElement): string;\r\n\tfunction display(element: HTMLorSVGElement, propertyValue: string): void;\r\n\tfunction display(element: HTMLorSVGElement, propertyValue?: string): string | void {\r\n\t\tconst style = element.style;\r\n\r\n\t\tif (propertyValue === undefined) {\r\n\t\t\treturn CSS.computePropertyValue(element, \"display\");\r\n\t\t}\r\n\t\tif (propertyValue === \"auto\") {\r\n\t\t\tconst nodeName = element && element.nodeName,\r\n\t\t\t\tdata = Data(element);\r\n\r\n\t\t\tif (inlineRx.test(nodeName)) {\r\n\t\t\t\tpropertyValue = \"inline\";\r\n\t\t\t} else if (listItemRx.test(nodeName)) {\r\n\t\t\t\tpropertyValue = \"list-item\";\r\n\t\t\t} else if (tableRowRx.test(nodeName)) {\r\n\t\t\t\tpropertyValue = \"table-row\";\r\n\t\t\t} else if (tableRx.test(nodeName)) {\r\n\t\t\t\tpropertyValue = \"table\";\r\n\t\t\t} else if (tableRowGroupRx.test(nodeName)) {\r\n\t\t\t\tpropertyValue = \"table-row-group\";\r\n\t\t\t} else {\r\n\t\t\t\t// Default to \"block\" when no match is found.\r\n\t\t\t\tpropertyValue = \"block\";\r\n\t\t\t}\r\n\t\t\t// IMPORTANT: We need to do this as getPropertyValue bypasses the\r\n\t\t\t// Normalisation when it exists in the cache.\r\n\t\t\tdata.cache[\"display\"] = propertyValue;\r\n\t\t}\r\n\t\tstyle.display = propertyValue;\r\n\t}\r\n\r\n\tregisterNormalization([Element, \"display\", display]);\r\n}\r\n","///<reference path=\"normalizations.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\t/**\r\n\t * Get the scrollWidth of an element.\r\n\t */\r\n\tfunction clientWidth(element: HTMLorSVGElement): string;\r\n\tfunction clientWidth(element: HTMLorSVGElement, propertyValue: string): void;\r\n\tfunction clientWidth(element: HTMLorSVGElement, propertyValue?: string): string | void {\r\n\t\tif (propertyValue == null) {\r\n\t\t\treturn element.clientWidth + \"px\";\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Get the scrollWidth of an element.\r\n\t */\r\n\tfunction scrollWidth(element: HTMLorSVGElement): string;\r\n\tfunction scrollWidth(element: HTMLorSVGElement, propertyValue: string): void;\r\n\tfunction scrollWidth(element: HTMLorSVGElement, propertyValue?: string): string | void {\r\n\t\tif (propertyValue == null) {\r\n\t\t\treturn element.scrollWidth + \"px\";\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Get the scrollHeight of an element.\r\n\t */\r\n\tfunction clientHeight(element: HTMLorSVGElement): string;\r\n\tfunction clientHeight(element: HTMLorSVGElement, propertyValue: string): void;\r\n\tfunction clientHeight(element: HTMLorSVGElement, propertyValue?: string): string | void {\r\n\t\tif (propertyValue == null) {\r\n\t\t\treturn element.clientHeight + \"px\";\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Get the scrollHeight of an element.\r\n\t */\r\n\tfunction scrollHeight(element: HTMLorSVGElement): string;\r\n\tfunction scrollHeight(element: HTMLorSVGElement, propertyValue: string): void;\r\n\tfunction scrollHeight(element: HTMLorSVGElement, propertyValue?: string): string | void {\r\n\t\tif (propertyValue == null) {\r\n\t\t\treturn element.scrollHeight + \"px\";\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Scroll an element.\r\n\t */\r\n\tfunction scroll(direction: \"Height\", end: \"Top\"): VelocityNormalizationsFn;\r\n\tfunction scroll(direction: \"Width\", end: \"Left\"): VelocityNormalizationsFn;\r\n\tfunction scroll(direction: \"Height\" | \"Width\", end: \"Top\" | \"Left\"): VelocityNormalizationsFn {\r\n\t\treturn function(element: HTMLorSVGElement, propertyValue?: string): string | void {\r\n\t\t\tif (propertyValue == null) {\r\n\t\t\t\t// Make sure we have these values cached.\r\n\t\t\t\tCSS.getPropertyValue(element, \"client\" + direction, null, true);\r\n\t\t\t\tCSS.getPropertyValue(element, \"scroll\" + direction, null, true);\r\n\t\t\t\tCSS.getPropertyValue(element, \"scroll\" + end, null, true);\r\n\t\t\t\treturn element[\"scroll\" + end] + \"px\";\r\n\t\t\t}\r\n\t\t\t//\t\tconsole.log(\"setScrollTop\", propertyValue)\r\n\t\t\tconst value = parseFloat(propertyValue),\r\n\t\t\t\tunit = propertyValue.replace(String(value), \"\");\r\n\r\n\t\t\tswitch (unit) {\r\n\t\t\t\tcase \"\":\r\n\t\t\t\tcase \"px\":\r\n\t\t\t\t\telement[\"scroll\" + end] = value;\r\n\t\t\t\t\tbreak;\r\n\r\n\t\t\t\tcase \"%\":\r\n\t\t\t\t\tlet client = parseFloat(CSS.getPropertyValue(element, \"client\" + direction)),\r\n\t\t\t\t\t\tscroll = parseFloat(CSS.getPropertyValue(element, \"scroll\" + direction));\r\n\r\n\t\t\t\t\t//\t\t\t\tconsole.log(\"setScrollTop percent\", scrollHeight, clientHeight, value, Math.max(0, scrollHeight - clientHeight) * value / 100)\r\n\t\t\t\t\telement[\"scroll\" + end] = Math.max(0, scroll - client) * value / 100;\r\n\t\t\t}\r\n\t\t} as VelocityNormalizationsFn;\r\n\t}\r\n\r\n\tregisterNormalization([HTMLElement, \"scroll\", scroll(\"Height\", \"Top\"), false]);\r\n\tregisterNormalization([HTMLElement, \"scrollTop\", scroll(\"Height\", \"Top\"), false]);\r\n\tregisterNormalization([HTMLElement, \"scrollLeft\", scroll(\"Width\", \"Left\"), false]);\r\n\tregisterNormalization([HTMLElement, \"scrollWidth\", scrollWidth]);\r\n\tregisterNormalization([HTMLElement, \"clientWidth\", clientWidth]);\r\n\tregisterNormalization([HTMLElement, \"scrollHeight\", scrollHeight]);\r\n\tregisterNormalization([HTMLElement, \"clientHeight\", clientHeight]);\r\n}\r\n","///<reference path=\"normalizations.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n * \r\n * This handles all CSS style properties. With browser prefixed properties it\r\n * will register a version that handles setting (and getting) both the prefixed\r\n * and non-prefixed version.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\t/**\r\n\t * An RegExp pattern for the following list of css words using\r\n\t * http://kemio.com.ar/tools/lst-trie-re.php to generate:\r\n\t * \r\n\t * blockSize\r\n\t * borderBottomLeftRadius\r\n\t * borderBottomRightRadius\r\n\t * borderBottomWidth\r\n\t * borderImageOutset\r\n\t * borderImageWidth\r\n\t * borderLeftWidth\r\n\t * borderRadius\r\n\t * borderRightWidth\r\n\t * borderSpacing\r\n\t * borderTopLeftRadius\r\n\t * borderTopRightRadius\r\n\t * borderTopWidth\r\n\t * borderWidth\r\n\t * bottom\r\n\t * columnGap\r\n\t * columnRuleWidth\r\n\t * columnWidth\r\n\t * flexBasis\r\n\t * fontSize\r\n\t * gridColumnGap\r\n\t * gridGap\r\n\t * gridRowGap\r\n\t * height\r\n\t * inlineSize\r\n\t * left\r\n\t * letterSpacing\r\n\t * margin\r\n\t * marginBottom\r\n\t * marginLeft\r\n\t * marginRight\r\n\t * marginTop\r\n\t * maxBlockSize\r\n\t * maxHeight\r\n\t * maxInlineSize\r\n\t * maxWidth\r\n\t * minBlockSize\r\n\t * minHeight\r\n\t * minInlineSize\r\n\t * minWidth\r\n\t * objectPosition\r\n\t * outlineOffset\r\n\t * outlineWidth\r\n\t * padding\r\n\t * paddingBottom\r\n\t * paddingLeft\r\n\t * paddingRight\r\n\t * paddingTop\r\n\t * perspective\r\n\t * right\r\n\t * shapeMargin\r\n\t * strokeDashoffset\r\n\t * strokeWidth\r\n\t * textIndent\r\n\t * top\r\n\t * transformOrigin\r\n\t * width\r\n\t * wordSpacing\r\n\t */\r\n\tconst 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))$/;\r\n\r\n\t/**\r\n\t * Return a Normalisation that can be used to set / get a prefixed style\r\n\t * property.\r\n\t */\r\n\tfunction getSetPrefixed(propertyName: string, unprefixed: string) {\r\n\t\treturn function(element: HTMLorSVGElement, propertyValue?: string): string | void {\r\n\t\t\tif (propertyValue === undefined) {\r\n\t\t\t\treturn CSS.computePropertyValue(element, propertyName) || CSS.computePropertyValue(element, unprefixed);\r\n\t\t\t}\r\n\t\t\telement.style[propertyName] = element.style[unprefixed] = propertyValue;\r\n\t\t} as VelocityNormalizationsFn;\r\n\t}\r\n\r\n\t/**\r\n\t * Return a Normalisation that can be used to set / get a style property.\r\n\t */\r\n\tfunction getSetStyle(propertyName: string) {\r\n\t\treturn function(element: HTMLorSVGElement, propertyValue?: string): string | void {\r\n\t\t\tif (propertyValue === undefined) {\r\n\t\t\t\treturn CSS.computePropertyValue(element, propertyName);\r\n\t\t\t}\r\n\t\t\telement.style[propertyName] = propertyValue;\r\n\t\t} as VelocityNormalizationsFn;\r\n\t}\r\n\r\n\t/**\r\n\t * Vendor prefixes. Chrome / Safari, Firefox, IE / Edge, Opera.\r\n\t */\r\n\tconst rxVendors = /^(webkit|moz|ms|o)[A-Z]/,\r\n\t\tprefixElement = State.prefixElement;\r\n\r\n\tfor (const propertyName in prefixElement.style) {\r\n\t\tif (rxVendors.test(propertyName)) {\r\n\t\t\tlet unprefixed = propertyName.replace(/^[a-z]+([A-Z])/, ($, letter: string) => letter.toLowerCase());\r\n\r\n\t\t\tif (ALL_VENDOR_PREFIXES || isString(prefixElement.style[unprefixed])) {\r\n\t\t\t\tlet addUnit = rxAddPx.test(unprefixed) ? \"px\" : undefined;\r\n\r\n\t\t\t\tregisterNormalization([Element, unprefixed, getSetPrefixed(propertyName, unprefixed), addUnit]);\r\n\t\t\t}\r\n\t\t} else if (!hasNormalization([Element, propertyName])) {\r\n\t\t\tlet addUnit = rxAddPx.test(propertyName) ? \"px\" : undefined;\r\n\r\n\t\t\tregisterNormalization([Element, propertyName, getSetStyle(propertyName), addUnit]);\r\n\t\t}\r\n\t}\r\n}\r\n","///<reference path=\"normalizations.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\r\n\t/**\r\n\t * A fake normalization used to allow the \"tween\" property easy access.\r\n\t */\r\n\tfunction getSetTween(element: HTMLorSVGElement, propertyValue?: string) {\r\n\t\tif (propertyValue === undefined) {\r\n\t\t\treturn \"\";\r\n\t\t}\r\n\t}\r\n\r\n\tregisterNormalization([Element, \"tween\", getSetTween]);\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Call Completion\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\t/**\r\n\t * Call the complete method of an animation in a separate function so it can\r\n\t * benefit from JIT compiling while still having a try/catch block.\r\n\t */\r\n\tfunction callComplete(activeCall: AnimationCall) {\r\n\t\ttry {\r\n\t\t\tconst elements = activeCall.elements;\r\n\r\n\t\t\t(activeCall.options.complete as VelocityCallback).call(elements, elements, activeCall);\r\n\t\t} catch (error) {\r\n\t\t\tsetTimeout(function() {\r\n\t\t\t\tthrow error;\r\n\t\t\t}, 1);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Complete an animation. This might involve restarting (for loop or repeat\r\n\t * options). Once it is finished we also check for any callbacks or Promises\r\n\t * that need updating.\r\n\t */\r\n\texport function completeCall(activeCall: AnimationCall) {\r\n\t\t//\t\tconsole.log(\"complete\", activeCall)\r\n\t\t// TODO: Check if it's not been completed already\r\n\r\n\t\tconst options = activeCall.options,\r\n\t\t\tqueue = getValue(activeCall.queue, options.queue),\r\n\t\t\tisLoop = getValue(activeCall.loop, options.loop, defaults.loop),\r\n\t\t\tisRepeat = getValue(activeCall.repeat, options.repeat, defaults.repeat),\r\n\t\t\tisStopped = activeCall._flags & AnimationFlags.STOPPED;\r\n\r\n\t\tif (!isStopped && (isLoop || isRepeat)) {\r\n\r\n\t\t\t////////////////////\r\n\t\t\t// Option: Loop   //\r\n\t\t\t// Option: Repeat //\r\n\t\t\t////////////////////\r\n\r\n\t\t\tif (isRepeat && isRepeat !== true) {\r\n\t\t\t\tactiveCall.repeat = isRepeat - 1;\r\n\t\t\t} else if (isLoop && isLoop !== true) {\r\n\t\t\t\tactiveCall.loop = isLoop - 1;\r\n\t\t\t\tactiveCall.repeat = getValue(activeCall.repeatAgain, options.repeatAgain, defaults.repeatAgain);\r\n\t\t\t}\r\n\t\t\tif (isLoop) {\r\n\t\t\t\tactiveCall._flags ^= AnimationFlags.REVERSE;\r\n\t\t\t}\r\n\t\t\tif (queue !== false) {\r\n\t\t\t\t// Can't be called when stopped so no need for an extra check.\r\n\t\t\t\tData(activeCall.element).lastFinishList[queue] = activeCall.timeStart + getValue(activeCall.duration, options.duration, defaults.duration);\r\n\t\t\t}\r\n\t\t\tactiveCall.timeStart = activeCall.ellapsedTime = activeCall.percentComplete = 0;\r\n\t\t\tactiveCall._flags &= ~AnimationFlags.STARTED;\r\n\t\t} else {\r\n\t\t\tconst element = activeCall.element,\r\n\t\t\t\tdata = Data(element);\r\n\r\n\t\t\tif (!--data.count && !isStopped) {\r\n\r\n\t\t\t\t////////////////////////\r\n\t\t\t\t// Feature: Classname //\r\n\t\t\t\t////////////////////////\r\n\r\n\t\t\t\tremoveClass(element, State.className);\r\n\t\t\t}\r\n\r\n\t\t\t//////////////////////\r\n\t\t\t// Option: Complete //\r\n\t\t\t//////////////////////\r\n\r\n\t\t\t// If this is the last animation in this list then we can check for\r\n\t\t\t// and complete calls or Promises.\r\n\t\t\t// TODO: When deleting an element we need to adjust these values.\r\n\t\t\tif (options && ++options._completed === options._total) {\r\n\t\t\t\tif (!isStopped && options.complete) {\r\n\t\t\t\t\t// We don't call the complete if the animation is stopped,\r\n\t\t\t\t\t// and we clear the key to prevent it being called again.\r\n\t\t\t\t\tcallComplete(activeCall);\r\n\t\t\t\t\toptions.complete = null;\r\n\t\t\t\t}\r\n\t\t\t\tconst resolver = options._resolver;\r\n\r\n\t\t\t\tif (resolver) {\r\n\t\t\t\t\t// Fulfil the Promise\r\n\t\t\t\t\tresolver(activeCall.elements as any);\r\n\t\t\t\t\tdelete options._resolver;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\t///////////////////\r\n\t\t\t// Option: Queue //\r\n\t\t\t///////////////////\r\n\r\n\t\t\tif (queue !== false) {\r\n\t\t\t\t// We only do clever things with queues...\r\n\t\t\t\tif (!isStopped) {\r\n\t\t\t\t\t// If we're not stopping an animation, we need to remember\r\n\t\t\t\t\t// what time it finished so that the next animation in\r\n\t\t\t\t\t// sequence gets the correct start time.\r\n\t\t\t\t\tdata.lastFinishList[queue] = activeCall.timeStart + getValue(activeCall.duration, options.duration, defaults.duration);\r\n\t\t\t\t}\r\n\t\t\t\t// Start the next animation in sequence, or delete the queue if\r\n\t\t\t\t// this was the last one.\r\n\t\t\t\tdequeue(element, queue);\r\n\t\t\t}\r\n\t\t\t// Cleanup any pointers, and remember the last animation etc.\r\n\t\t\tfreeAnimationCall(activeCall);\r\n\t\t}\r\n\t}\r\n};\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\ninterface Element {\r\n\tvelocityData: ElementData;\r\n}\r\n\r\n/**\r\n * Get (and create) the internal data store for an element.\r\n */\r\nfunction Data(element: HTMLorSVGElement): ElementData {\r\n\t// Use a string member so Uglify doesn't mangle it.\r\n\tconst data = element[\"velocityData\"];\r\n\r\n\tif (data) {\r\n\t\treturn data;\r\n\t}\r\n\tlet types = 0;\r\n\r\n\tfor (let index = 0, constructors = VelocityStatic.constructors; index < constructors.length; index++) {\r\n\t\tif (element instanceof constructors[index]) {\r\n\t\t\ttypes |= 1 << index;\r\n\t\t}\r\n\t}\r\n\t// Do it this way so it errors on incorrect data.\r\n\tlet newData: ElementData = {\r\n\t\ttypes: types,\r\n\t\tcount: 0,\r\n\t\tcomputedStyle: null,\r\n\t\tcache: createEmptyObject(),\r\n\t\tqueueList: createEmptyObject(),\r\n\t\tlastAnimationList: createEmptyObject(),\r\n\t\tlastFinishList: createEmptyObject()\r\n\t};\r\n\tObject.defineProperty(element, \"velocityData\", {\r\n\t\tvalue: newData\r\n\t});\r\n\treturn newData;\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\t/**\r\n\t * Set to true, 1 or 2 (most verbose) to output debug info to console.\r\n\t */\r\n\texport let debug: boolean | 1 | 2 = false;\r\n};\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Velocity option defaults, which can be overriden by the user.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\t// NOTE: Add the variable here, then add the default state in \"reset\" below.\r\n\tlet _cache: boolean,\r\n\t\t_begin: VelocityCallback,\r\n\t\t_complete: VelocityCallback,\r\n\t\t_delay: number,\r\n\t\t_duration: number,\r\n\t\t_easing: VelocityEasingType,\r\n\t\t_fpsLimit: number,\r\n\t\t_loop: number | true,\r\n\t\t_minFrameTime: number,\r\n\t\t_promise: boolean,\r\n\t\t_promiseRejectEmpty: boolean,\r\n\t\t_queue: string | false,\r\n\t\t_repeat: number | true,\r\n\t\t_speed: number,\r\n\t\t_sync: boolean;\r\n\r\n\texport const defaults: StrictVelocityOptions & {reset?: () => void} = {\r\n\t\tmobileHA: true\r\n\t};\r\n\r\n\t// IMPORTANT: Make sure any new defaults get added to the actions/set.ts list\r\n\tObject.defineProperties(defaults, {\r\n\t\treset: {\r\n\t\t\tenumerable: true,\r\n\t\t\tvalue: function() {\r\n\t\t\t\t_cache = DEFAULT_CACHE;\r\n\t\t\t\t_begin = undefined;\r\n\t\t\t\t_complete = undefined;\r\n\t\t\t\t_delay = DEFAULT_DELAY;\r\n\t\t\t\t_duration = DEFAULT_DURATION;\r\n\t\t\t\t_easing = validateEasing(DEFAULT_EASING, DEFAULT_DURATION);\r\n\t\t\t\t_fpsLimit = DEFAULT_FPSLIMIT;\r\n\t\t\t\t_loop = DEFAULT_LOOP;\r\n\t\t\t\t_minFrameTime = FUZZY_MS_PER_SECOND / DEFAULT_FPSLIMIT;\r\n\t\t\t\t_promise = DEFAULT_PROMISE;\r\n\t\t\t\t_promiseRejectEmpty = DEFAULT_PROMISE_REJECT_EMPTY;\r\n\t\t\t\t_queue = DEFAULT_QUEUE;\r\n\t\t\t\t_repeat = DEFAULT_REPEAT;\r\n\t\t\t\t_speed = DEFAULT_SPEED;\r\n\t\t\t\t_sync = DEFAULT_SYNC;\r\n\t\t\t}\r\n\t\t},\r\n\t\tcache: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): boolean {\r\n\t\t\t\treturn _cache;\r\n\t\t\t},\r\n\t\t\tset: function(value: boolean) {\r\n\t\t\t\tvalue = validateCache(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_cache = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\tbegin: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): VelocityCallback {\r\n\t\t\t\treturn _begin;\r\n\t\t\t},\r\n\t\t\tset: function(value: VelocityCallback) {\r\n\t\t\t\tvalue = validateBegin(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_begin = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\tcomplete: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): VelocityCallback {\r\n\t\t\t\treturn _complete;\r\n\t\t\t},\r\n\t\t\tset: function(value: VelocityCallback) {\r\n\t\t\t\tvalue = validateComplete(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_complete = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\tdelay: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): \"fast\" | \"normal\" | \"slow\" | number {\r\n\t\t\t\treturn _delay;\r\n\t\t\t},\r\n\t\t\tset: function(value: \"fast\" | \"normal\" | \"slow\" | number) {\r\n\t\t\t\tvalue = validateDelay(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_delay = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\tduration: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): \"fast\" | \"normal\" | \"slow\" | number {\r\n\t\t\t\treturn _duration;\r\n\t\t\t},\r\n\t\t\tset: function(value: \"fast\" | \"normal\" | \"slow\" | number) {\r\n\t\t\t\tvalue = validateDuration(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_duration = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\teasing: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): VelocityEasingType {\r\n\t\t\t\treturn _easing;\r\n\t\t\t},\r\n\t\t\tset: function(value: VelocityEasingType) {\r\n\t\t\t\tvalue = validateEasing(value, _duration);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_easing = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\tfpsLimit: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): number | false {\r\n\t\t\t\treturn _fpsLimit;\r\n\t\t\t},\r\n\t\t\tset: function(value: number | false) {\r\n\t\t\t\tvalue = validateFpsLimit(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_fpsLimit = value;\r\n\t\t\t\t\t_minFrameTime = FUZZY_MS_PER_SECOND / value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\tloop: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): number | true {\r\n\t\t\t\treturn _loop;\r\n\t\t\t},\r\n\t\t\tset: function(value: number | boolean) {\r\n\t\t\t\tvalue = validateLoop(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_loop = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\tminFrameTime: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): number | false {\r\n\t\t\t\treturn _minFrameTime;\r\n\t\t\t}\r\n\t\t},\r\n\t\tpromise: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): boolean {\r\n\t\t\t\treturn _promise;\r\n\t\t\t},\r\n\t\t\tset: function(value: boolean) {\r\n\t\t\t\tvalue = validatePromise(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_promise = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\tpromiseRejectEmpty: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): boolean {\r\n\t\t\t\treturn _promiseRejectEmpty;\r\n\t\t\t},\r\n\t\t\tset: function(value: boolean) {\r\n\t\t\t\tvalue = validatePromiseRejectEmpty(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_promiseRejectEmpty = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\tqueue: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): string | false {\r\n\t\t\t\treturn _queue;\r\n\t\t\t},\r\n\t\t\tset: function(value: string | false) {\r\n\t\t\t\tvalue = validateQueue(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_queue = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\trepeat: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): number | true {\r\n\t\t\t\treturn _repeat;\r\n\t\t\t},\r\n\t\t\tset: function(value: number | boolean) {\r\n\t\t\t\tvalue = validateRepeat(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_repeat = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\tspeed: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): number {\r\n\t\t\t\treturn _speed;\r\n\t\t\t},\r\n\t\t\tset: function(value: number) {\r\n\t\t\t\tvalue = validateSpeed(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_speed = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t},\r\n\t\tsync: {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function(): boolean {\r\n\t\t\t\treturn _sync;\r\n\t\t\t},\r\n\t\t\tset: function(value: boolean) {\r\n\t\t\t\tvalue = validateSync(value);\r\n\t\t\t\tif (value !== undefined) {\r\n\t\t\t\t\t_sync = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t});\r\n\tdefaults.reset();\r\n};\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Velocity-wide animation time remapping for testing purposes.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\t/**\r\n\t * In mock mode, all animations are forced to complete immediately upon the\r\n\t * next rAF tick. If there are further animations queued then they will each\r\n\t * take one single frame in turn. Loops and repeats will be disabled while\r\n\t * <code>mock = true</code>.\r\n\t */\r\n\texport let mock: boolean = false;\r\n};\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\t/**\r\n\t * Used to patch any object to allow Velocity chaining. In order to chain an\r\n\t * object must either be treatable as an array - with a <code>.length</code>\r\n\t * property, and each member a Node, or a Node directly.\r\n\t * \r\n\t * By default Velocity will try to patch <code>window</code>,\r\n\t * <code>jQuery</code>, <code>Zepto</code>, and several classes that return\r\n\t * Nodes or lists of Nodes.\r\n\t * \r\n\t * @public\r\n\t */\r\n\texport function patch(proto: any, global?: boolean) {\r\n\t\ttry {\r\n\t\t\tdefineProperty(proto, (global ? \"V\" : \"v\") + \"elocity\", VelocityFn);\r\n\t\t} catch (e) {\r\n\t\t\tconsole.warn(\"VelocityJS: Error when trying to add prototype.\", e);\r\n\t\t}\r\n\t}\r\n};\r\n","///<reference path=\"data.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * AnimationCall queue\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\r\n\t/**\r\n\t * Simple queue management. Un-named queue is directly within the element data,\r\n\t * named queue is within an object within it.\r\n\t */\r\n\tfunction animate(animation: AnimationCall) {\r\n\t\tconst prev = State.last;\r\n\r\n\t\tanimation._prev = prev;\r\n\t\tanimation._next = undefined;\r\n\t\tif (prev) {\r\n\t\t\tprev._next = animation;\r\n\t\t} else {\r\n\t\t\tState.first = animation;\r\n\t\t}\r\n\t\tState.last = animation;\r\n\t\tif (!State.firstNew) {\r\n\t\t\tState.firstNew = animation;\r\n\t\t}\r\n\t\tconst element = animation.element,\r\n\t\t\tdata = Data(element);\r\n\r\n\t\tif (!data.count++) {\r\n\r\n\t\t\t////////////////////////\r\n\t\t\t// Feature: Classname //\r\n\t\t\t////////////////////////\r\n\r\n\t\t\taddClass(element, State.className);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Add an item to an animation queue.\r\n\t */\r\n\texport function queue(element: HTMLorSVGElement, animation: AnimationCall, queue: string | false): void {\r\n\t\tconst data = Data(element);\r\n\r\n\t\tif (queue !== false) {\r\n\t\t\t// Store the last animation added so we can use it for the\r\n\t\t\t// beginning of the next one.\r\n\t\t\tdata.lastAnimationList[queue] = animation;\r\n\t\t}\r\n\t\tif (queue === false) {\r\n\t\t\tanimate(animation);\r\n\t\t} else {\r\n\t\t\tif (!isString(queue)) {\r\n\t\t\t\tqueue = \"\";\r\n\t\t\t}\r\n\t\t\tlet last = data.queueList[queue];\r\n\r\n\t\t\tif (!last) {\r\n\t\t\t\tif (last === null) {\r\n\t\t\t\t\tdata.queueList[queue] = animation;\r\n\t\t\t\t} else {\r\n\t\t\t\t\tdata.queueList[queue] = null;\r\n\t\t\t\t\tanimate(animation);\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\twhile (last._next) {\r\n\t\t\t\t\tlast = last._next;\r\n\t\t\t\t}\r\n\t\t\t\tlast._next = animation;\r\n\t\t\t\tanimation._prev = last;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Start the next animation on this element's queue (named or default).\r\n\t *\r\n\t * @returns the next animation that is starting.\r\n\t */\r\n\texport function dequeue(element: HTMLorSVGElement, queue?: string | boolean, skip?: boolean): AnimationCall {\r\n\t\tif (queue !== false) {\r\n\t\t\tif (!isString(queue)) {\r\n\t\t\t\tqueue = \"\";\r\n\t\t\t}\r\n\t\t\tconst data = Data(element),\r\n\t\t\t\tanimation = data.queueList[queue];\r\n\r\n\t\t\tif (animation) {\r\n\t\t\t\tdata.queueList[queue] = animation._next || null;\r\n\t\t\t\tif (!skip) {\r\n\t\t\t\t\tanimate(animation);\r\n\t\t\t\t}\r\n\t\t\t} else if (animation === null) {\r\n\t\t\t\tdelete data.queueList[queue];\r\n\t\t\t}\r\n\t\t\treturn animation;\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Remove an animation from the active animation list. If it has a queue set\r\n\t * then remember it as the last animation for that queue, and free the one\r\n\t * that was previously there. If the animation list is completely empty then\r\n\t * mark us as finished.\r\n\t */\r\n\texport function freeAnimationCall(animation: AnimationCall): void {\r\n\t\tconst next = animation._next,\r\n\t\t\tprev = animation._prev,\r\n\t\t\tqueue = animation.queue == null ? animation.options.queue : animation.queue;\r\n\r\n\t\tif (State.firstNew === animation) {\r\n\t\t\tState.firstNew = next;\r\n\t\t}\r\n\t\tif (State.first === animation) {\r\n\t\t\tState.first = next;\r\n\t\t} else if (prev) {\r\n\t\t\tprev._next = next;\r\n\t\t}\r\n\t\tif (State.last === animation) {\r\n\t\t\tState.last = prev;\r\n\t\t} else if (next) {\r\n\t\t\tnext._prev = prev;\r\n\t\t}\r\n\t\tif (queue) {\r\n\t\t\tconst data = Data(animation.element);\r\n\r\n\t\t\tif (data) {\r\n\t\t\t\tanimation._next = animation._prev = undefined;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\r\n\t/* Container for the user's custom animation redirects that are referenced by name in place of the properties map argument. */\r\n\texport let Redirects = {/* Manually registered by the user. */};\r\n\r\n\t/***********************\r\n\t Packaged Redirects\r\n\t ***********************/\r\n\r\n\t/* slideUp, slideDown */\r\n\t[\"Down\", \"Up\"].forEach(function(direction) {\r\n\t\tRedirects[\"slide\" + direction] = function(element: HTMLorSVGElement, options: VelocityOptions, elementsIndex: number, elementsSize, elements: HTMLorSVGElement[], resolver: (value?: HTMLorSVGElement[] | VelocityResult) => void) {\r\n\t\t\tlet opts = {...options},\r\n\t\t\t\tbegin = opts.begin,\r\n\t\t\t\tcomplete = opts.complete,\r\n\t\t\t\tinlineValues = {},\r\n\t\t\t\tcomputedValues = {\r\n\t\t\t\t\theight: \"\",\r\n\t\t\t\t\tmarginTop: \"\",\r\n\t\t\t\t\tmarginBottom: \"\",\r\n\t\t\t\t\tpaddingTop: \"\",\r\n\t\t\t\t\tpaddingBottom: \"\"\r\n\t\t\t\t};\r\n\r\n\t\t\tif (opts.display === undefined) {\r\n\t\t\t\tlet isInline = inlineRx.test(element.nodeName.toLowerCase());\r\n\r\n\t\t\t\t/* Show the element before slideDown begins and hide the element after slideUp completes. */\r\n\t\t\t\t/* Note: Inline elements cannot have dimensions animated, so they're reverted to inline-block. */\r\n\t\t\t\topts.display = (direction === \"Down\" ? (isInline ? \"inline-block\" : \"block\") : \"none\");\r\n\t\t\t}\r\n\r\n\t\t\topts.begin = function() {\r\n\t\t\t\t/* If the user passed in a begin callback, fire it now. */\r\n\t\t\t\tif (elementsIndex === 0 && begin) {\r\n\t\t\t\t\tbegin.call(elements, elements);\r\n\t\t\t\t}\r\n\r\n\t\t\t\t/* Cache the elements' original vertical dimensional property values so that we can animate back to them. */\r\n\t\t\t\tfor (let property in computedValues) {\r\n\t\t\t\t\tif (!computedValues.hasOwnProperty(property)) {\r\n\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tinlineValues[property] = element.style[property];\r\n\r\n\t\t\t\t\t/* For slideDown, use forcefeeding to animate all vertical properties from 0. For slideUp,\r\n\t\t\t\t\t use forcefeeding to start from computed values and animate down to 0. */\r\n\t\t\t\t\tlet propertyValue = CSS.getPropertyValue(element, property);\r\n\t\t\t\t\tcomputedValues[property] = (direction === \"Down\") ? [propertyValue, 0] : [0, propertyValue];\r\n\t\t\t\t}\r\n\r\n\t\t\t\t/* Force vertical overflow content to clip so that sliding works as expected. */\r\n\t\t\t\t(inlineValues as any).overflow = element.style.overflow;\r\n\t\t\t\telement.style.overflow = \"hidden\";\r\n\t\t\t};\r\n\r\n\t\t\topts.complete = function() {\r\n\t\t\t\t/* Reset element to its pre-slide inline values once its slide animation is complete. */\r\n\t\t\t\tfor (let property in inlineValues) {\r\n\t\t\t\t\tif (inlineValues.hasOwnProperty(property)) {\r\n\t\t\t\t\t\telement.style[property] = inlineValues[property];\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\t/* If the user passed in a complete callback, fire it now. */\r\n\t\t\t\tif (elementsIndex === elementsSize - 1) {\r\n\t\t\t\t\tif (complete) {\r\n\t\t\t\t\t\tcomplete.call(elements, elements);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (resolver) {\r\n\t\t\t\t\t\tresolver(elements);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t};\r\n\r\n\t\t\t(VelocityFn as any)(element, computedValues, opts);\r\n\t\t};\r\n\t});\r\n\r\n\t/* fadeIn, fadeOut */\r\n\t[\"In\", \"Out\"].forEach(function(direction) {\r\n\t\tRedirects[\"fade\" + direction] = function(element: HTMLorSVGElement, options: VelocityOptions, elementsIndex: number, elementsSize, elements: HTMLorSVGElement[], promiseData) {\r\n\t\t\tlet opts = {...options},\r\n\t\t\t\tcomplete = opts.complete,\r\n\t\t\t\tpropertiesMap = {\r\n\t\t\t\t\topacity: (direction === \"In\") ? 1 : 0\r\n\t\t\t\t};\r\n\r\n\t\t\t/* Since redirects are triggered individually for each element in the animated set, avoid repeatedly triggering\r\n\t\t\t callbacks by firing them only when the final element has been reached. */\r\n\t\t\tif (elementsIndex !== 0) {\r\n\t\t\t\topts.begin = null;\r\n\t\t\t}\r\n\t\t\tif (elementsIndex !== elementsSize - 1) {\r\n\t\t\t\topts.complete = null;\r\n\t\t\t} else {\r\n\t\t\t\topts.complete = function() {\r\n\t\t\t\t\tif (complete) {\r\n\t\t\t\t\t\tcomplete.call(elements, elements);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (promiseData) {\r\n\t\t\t\t\t\tpromiseData.resolver(elements);\r\n\t\t\t\t\t}\r\n\t\t\t\t};\r\n\t\t\t}\r\n\r\n\t\t\t/* If a display was passed in, use it. Otherwise, default to \"none\" for fadeOut or the element-specific default for fadeIn. */\r\n\t\t\t/* Note: We allow users to pass in \"null\" to skip display setting altogether. */\r\n\t\t\tif (opts.display === undefined) {\r\n\t\t\t\topts.display = (direction === \"In\" ? \"auto\" : \"none\");\r\n\t\t\t}\r\n\r\n\t\t\t(VelocityFn as any)(this, propertiesMap, opts);\r\n\t\t};\r\n\t});\r\n};\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Effect Registration\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\t/* Animate the expansion/contraction of the elements' parent's height for In/Out effects. */\r\n\tfunction animateParentHeight(elements: HTMLorSVGElement | HTMLorSVGElement[], direction, totalDuration, stagger) {\r\n\t\tlet totalHeightDelta = 0,\r\n\t\t\tparentNode: HTMLorSVGElement;\r\n\r\n\t\t/* Sum the total height (including padding and margin) of all targeted elements. */\r\n\t\t((elements as HTMLorSVGElement).nodeType ? [elements as HTMLorSVGElement] : elements as HTMLorSVGElement[]).forEach(function(element: HTMLorSVGElement, i) {\r\n\t\t\tif (stagger) {\r\n\t\t\t\t/* Increase the totalDuration by the successive delay amounts produced by the stagger option. */\r\n\t\t\t\ttotalDuration += i * stagger;\r\n\t\t\t}\r\n\r\n\t\t\tparentNode = element.parentNode as HTMLorSVGElement;\r\n\r\n\t\t\tlet propertiesToSum = [\"height\", \"paddingTop\", \"paddingBottom\", \"marginTop\", \"marginBottom\"];\r\n\r\n\t\t\t/* If box-sizing is border-box, the height already includes padding and margin */\r\n\t\t\tif (CSS.getPropertyValue(element, \"boxSizing\").toString().toLowerCase() === \"border-box\") {\r\n\t\t\t\tpropertiesToSum = [\"height\"];\r\n\t\t\t}\r\n\r\n\t\t\tpropertiesToSum.forEach(function(property) {\r\n\t\t\t\ttotalHeightDelta += parseFloat(CSS.getPropertyValue(element, property) as string);\r\n\t\t\t});\r\n\t\t});\r\n\r\n\t\t/* Animate the parent element's height adjustment (with a varying duration multiplier for aesthetic benefits). */\r\n\t\t// TODO: Get this typesafe again\r\n\t\t(VelocityFn as any)(\r\n\t\t\tparentNode,\r\n\t\t\t{height: (direction === \"In\" ? \"+\" : \"-\") + \"=\" + totalHeightDelta},\r\n\t\t\t{queue: false, easing: \"ease-in-out\", duration: totalDuration * (direction === \"In\" ? 0.6 : 1)}\r\n\t\t);\r\n\t}\r\n\r\n\t/* Note: RegisterUI is a legacy name. */\r\n\texport function RegisterEffect(effectName: string, properties): Velocity {\r\n\r\n\t\t/* Register a custom redirect for each effect. */\r\n\t\tRedirects[effectName] = function(element, redirectOptions, elementsIndex, elementsSize, elements, resolver: (value?: HTMLorSVGElement[] | VelocityResult) => void, loop) {\r\n\t\t\tlet finalElement = (elementsIndex === elementsSize - 1),\r\n\t\t\t\ttotalDuration = 0;\r\n\r\n\t\t\tloop = loop || properties.loop;\r\n\t\t\tif (typeof properties.defaultDuration === \"function\") {\r\n\t\t\t\tproperties.defaultDuration = properties.defaultDuration.call(elements, elements);\r\n\t\t\t} else {\r\n\t\t\t\tproperties.defaultDuration = parseFloat(properties.defaultDuration);\r\n\t\t\t}\r\n\r\n\t\t\t/* Get the total duration used, so we can share it out with everything that doesn't have a duration */\r\n\t\t\tfor (let callIndex = 0; callIndex < properties.calls.length; callIndex++) {\r\n\t\t\t\tlet durationPercentage = properties.calls[callIndex][1];\r\n\t\t\t\tif (typeof durationPercentage === \"number\") {\r\n\t\t\t\t\ttotalDuration += durationPercentage;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tlet shareDuration = totalDuration >= 1 ? 0 : properties.calls.length ? (1 - totalDuration) / properties.calls.length : 1;\r\n\r\n\t\t\t/* Iterate through each effect's call array. */\r\n\t\t\tfor (let callIndex = 0; callIndex < properties.calls.length; callIndex++) {\r\n\t\t\t\tlet call = properties.calls[callIndex],\r\n\t\t\t\t\tpropertyMap = call[0],\r\n\t\t\t\t\tredirectDuration = 1000,\r\n\t\t\t\t\tdurationPercentage = call[1],\r\n\t\t\t\t\tcallOptions = call[2] || {},\r\n\t\t\t\t\topts: VelocityOptions = {};\r\n\r\n\t\t\t\tif (redirectOptions.duration !== undefined) {\r\n\t\t\t\t\tredirectDuration = redirectOptions.duration;\r\n\t\t\t\t} else if (properties.defaultDuration !== undefined) {\r\n\t\t\t\t\tredirectDuration = properties.defaultDuration;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t/* Assign the whitelisted per-call options. */\r\n\t\t\t\topts.duration = redirectDuration * (typeof durationPercentage === \"number\" ? durationPercentage : shareDuration);\r\n\t\t\t\topts.queue = redirectOptions.queue || \"\";\r\n\t\t\t\topts.easing = callOptions.easing || \"ease\";\r\n\t\t\t\topts.delay = parseFloat(callOptions.delay) || 0;\r\n\t\t\t\topts.loop = !properties.loop && callOptions.loop;\r\n\t\t\t\topts.cache = callOptions.cache || true;\r\n\r\n\t\t\t\t/* Special processing for the first effect call. */\r\n\t\t\t\tif (callIndex === 0) {\r\n\t\t\t\t\t/* If a delay was passed into the redirect, combine it with the first call's delay. */\r\n\t\t\t\t\topts.delay += (parseFloat(redirectOptions.delay) || 0);\r\n\r\n\t\t\t\t\tif (elementsIndex === 0) {\r\n\t\t\t\t\t\topts.begin = function() {\r\n\t\t\t\t\t\t\t/* Only trigger a begin callback on the first effect call with the first element in the set. */\r\n\t\t\t\t\t\t\tif (redirectOptions.begin) {\r\n\t\t\t\t\t\t\t\tredirectOptions.begin.call(elements, elements);\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tlet direction = effectName.match(/(In|Out)$/);\r\n\r\n\t\t\t\t\t\t\t/* Make \"in\" transitioning elements invisible immediately so that there's no FOUC between now\r\n\t\t\t\t\t\t\t and the first RAF tick. */\r\n\t\t\t\t\t\t\tif ((direction && direction[0] === \"In\") && propertyMap.opacity !== undefined) {\r\n\t\t\t\t\t\t\t\t(elements.nodeType ? [elements] : elements).forEach(function(element) {\r\n\t\t\t\t\t\t\t\t\tCSS.setPropertyValue(element, \"opacity\", 0);\r\n\t\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\t/* Only trigger animateParentHeight() if we're using an In/Out transition. */\r\n\t\t\t\t\t\t\tif (redirectOptions.animateParentHeight && direction) {\r\n\t\t\t\t\t\t\t\tanimateParentHeight(elements, direction[0], redirectDuration + (opts.delay as number), redirectOptions.stagger);\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\r\n\t\t\t\t\t/* If the user isn't overriding the display option, default to \"auto\" for \"In\"-suffixed transitions. */\r\n\t\t\t\t\t//\t\t\t\t\tif (redirectOptions.display !== null) {\r\n\t\t\t\t\t//\t\t\t\t\t\tif (redirectOptions.display !== undefined && redirectOptions.display !== \"none\") {\r\n\t\t\t\t\t//\t\t\t\t\t\t\topts.display = redirectOptions.display;\r\n\t\t\t\t\t//\t\t\t\t\t\t} else if (/In$/.test(effectName)) {\r\n\t\t\t\t\t//\t\t\t\t\t\t\t/* Inline elements cannot be subjected to transforms, so we switch them to inline-block. */\r\n\t\t\t\t\t//\t\t\t\t\t\t\tlet defaultDisplay = CSS.Values.getDisplayType(element);\r\n\t\t\t\t\t//\t\t\t\t\t\t\topts.display = (defaultDisplay === \"inline\") ? \"inline-block\" : defaultDisplay;\r\n\t\t\t\t\t//\t\t\t\t\t\t}\r\n\t\t\t\t\t//\t\t\t\t\t}\r\n\r\n\t\t\t\t\tif (redirectOptions.visibility && redirectOptions.visibility !== \"hidden\") {\r\n\t\t\t\t\t\topts.visibility = redirectOptions.visibility;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\t/* Special processing for the last effect call. */\r\n\t\t\t\tif (callIndex === properties.calls.length - 1) {\r\n\t\t\t\t\t/* Append promise resolving onto the user's redirect callback. */\r\n\t\t\t\t\tlet injectFinalCallbacks = function() {\r\n\t\t\t\t\t\tif ((redirectOptions.display === undefined || redirectOptions.display === \"none\") && /Out$/.test(effectName)) {\r\n\t\t\t\t\t\t\t(elements.nodeType ? [elements] : elements).forEach(function(element) {\r\n\t\t\t\t\t\t\t\tCSS.setPropertyValue(element, \"display\", \"none\");\r\n\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tif (redirectOptions.complete) {\r\n\t\t\t\t\t\t\tredirectOptions.complete.call(elements, elements);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tif (resolver) {\r\n\t\t\t\t\t\t\tresolver(elements || element);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\topts.complete = function() {\r\n\t\t\t\t\t\tif (loop) {\r\n\t\t\t\t\t\t\tRedirects[effectName](element, redirectOptions, elementsIndex, elementsSize, elements, resolver, loop === true ? true : Math.max(0, loop - 1));\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tif (properties.reset) {\r\n\t\t\t\t\t\t\tfor (let resetProperty in properties.reset) {\r\n\t\t\t\t\t\t\t\tif (!properties.reset.hasOwnProperty(resetProperty)) {\r\n\t\t\t\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\tlet resetValue = properties.reset[resetProperty];\r\n\r\n\t\t\t\t\t\t\t\t/* Format each non-array value in the reset property map to [ value, value ] so that changes apply\r\n\t\t\t\t\t\t\t\t immediately and DOM querying is avoided (via forcefeeding). */\r\n\t\t\t\t\t\t\t\t/* Note: Don't forcefeed hooks, otherwise their hook roots will be defaulted to their null values. */\r\n\t\t\t\t\t\t\t\t// TODO: Fix this\r\n\t\t\t\t\t\t\t\t//\t\t\t\t\t\t\t\tif (CSS.Hooks.registered[resetProperty] === undefined && (typeof resetValue === \"string\" || typeof resetValue === \"number\")) {\r\n\t\t\t\t\t\t\t\t//\t\t\t\t\t\t\t\t\tproperties.reset[resetProperty] = [properties.reset[resetProperty], properties.reset[resetProperty]];\r\n\t\t\t\t\t\t\t\t//\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\t/* So that the reset values are applied instantly upon the next rAF tick, use a zero duration and parallel queueing. */\r\n\t\t\t\t\t\t\tlet resetOptions: VelocityOptions = {duration: 0, queue: false};\r\n\r\n\t\t\t\t\t\t\t/* Since the reset option uses up the complete callback, we trigger the user's complete callback at the end of ours. */\r\n\t\t\t\t\t\t\tif (finalElement) {\r\n\t\t\t\t\t\t\t\tresetOptions.complete = injectFinalCallbacks;\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\tVelocityFn(element, properties.reset, resetOptions);\r\n\t\t\t\t\t\t\t/* Only trigger the user's complete callback on the last effect call with the last element in the set. */\r\n\t\t\t\t\t\t} else if (finalElement) {\r\n\t\t\t\t\t\t\tinjectFinalCallbacks();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\tif (redirectOptions.visibility === \"hidden\") {\r\n\t\t\t\t\t\topts.visibility = redirectOptions.visibility;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\tVelocityFn(element, propertyMap, opts);\r\n\t\t\t}\r\n\t\t};\r\n\r\n\t\t/* Return the Velocity object so that RegisterUI calls can be chained. */\r\n\t\treturn VelocityFn as any;\r\n\t};\r\n};","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Sequence Running\r\n */\r\n\r\n/**\r\n * Perform a deep copy of an object - also copies children so they're not\r\n * going to be affected by changing original.\r\n */\r\nfunction _deepCopyObject<T, U>(target: T, ...sources: U[]): T & U {\r\n\tif (target == null) { // TypeError if undefined or null\r\n\t\tthrow new TypeError(\"Cannot convert undefined or null to object\");\r\n\t}\r\n\tconst to = Object(target),\r\n\t\thasOwnProperty = Object.prototype.hasOwnProperty;\r\n\tlet source: any;\r\n\r\n\twhile ((source = sources.shift())) {\r\n\t\tif (source != null) {\r\n\t\t\tfor (const key in source) {\r\n\t\t\t\tif (hasOwnProperty.call(source, key)) {\r\n\t\t\t\t\tconst value = source[key];\r\n\r\n\t\t\t\t\tif (Array.isArray(value)) {\r\n\t\t\t\t\t\t_deepCopyObject(to[key] = [], value);\r\n\t\t\t\t\t} else if (isPlainObject(value)) {\r\n\t\t\t\t\t\t_deepCopyObject(to[key] = {}, value);\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tto[key] = 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\t}\r\n\treturn to;\r\n}\r\n\r\nnamespace VelocityStatic {\r\n\t/* Note: Sequence calls must use Velocity's single-object arguments syntax. */\r\n\texport function RunSequence(originalSequence): void {\r\n\t\tlet sequence = _deepCopyObject([], originalSequence);\r\n\r\n\t\tif (sequence.length > 1) {\r\n\t\t\tsequence.reverse().forEach(function(currentCall, i) {\r\n\t\t\t\tlet nextCall = sequence[i + 1];\r\n\r\n\t\t\t\tif (nextCall) {\r\n\t\t\t\t\t/* Parallel sequence calls (indicated via sequenceQueue:false) are triggered\r\n\t\t\t\t\t in the previous call's begin callback. Otherwise, chained calls are normally triggered\r\n\t\t\t\t\t in the previous call's complete callback. */\r\n\t\t\t\t\tlet currentCallOptions = currentCall.o || currentCall.options,\r\n\t\t\t\t\t\tnextCallOptions = nextCall.o || nextCall.options;\r\n\r\n\t\t\t\t\tlet timing = (currentCallOptions && currentCallOptions.sequenceQueue === false) ? \"begin\" : \"complete\",\r\n\t\t\t\t\t\tcallbackOriginal = nextCallOptions && nextCallOptions[timing],\r\n\t\t\t\t\t\toptions = {};\r\n\r\n\t\t\t\t\toptions[timing] = function() {\r\n\t\t\t\t\t\tlet nextCallElements = nextCall.e || nextCall.elements;\r\n\t\t\t\t\t\tlet elements = nextCallElements.nodeType ? [nextCallElements] : nextCallElements;\r\n\r\n\t\t\t\t\t\tif (callbackOriginal) {\r\n\t\t\t\t\t\t\tcallbackOriginal.call(elements, elements);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tVelocityFn(currentCall);\r\n\t\t\t\t\t};\r\n\r\n\t\t\t\t\tif (nextCall.o) {\r\n\t\t\t\t\t\tnextCall.o = {...nextCallOptions, ...options};\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tnextCall.options = {...nextCallOptions, ...options};\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t});\r\n\r\n\t\t\tsequence.reverse();\r\n\t\t}\r\n\r\n\t\tVelocityFn(sequence[0]);\r\n\t};\r\n};\r\n","///<reference path=\"state.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Tick\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\r\n\t/**\r\n\t * Call the begin method of an animation in a separate function so it can\r\n\t * benefit from JIT compiling while still having a try/catch block.\r\n\t */\r\n\texport function callBegin(activeCall: AnimationCall) {\r\n\t\ttry {\r\n\t\t\tconst elements = activeCall.elements;\r\n\r\n\t\t\t(activeCall.options.begin as VelocityCallback).call(elements, elements, activeCall);\r\n\t\t} catch (error) {\r\n\t\t\tsetTimeout(function() {\r\n\t\t\t\tthrow error;\r\n\t\t\t}, 1);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Call the progress method of an animation in a separate function so it can\r\n\t * benefit from JIT compiling while still having a try/catch block.\r\n\t */\r\n\tfunction callProgress(activeCall: AnimationCall, timeCurrent: number) {\r\n\t\ttry {\r\n\t\t\tconst elements = activeCall.elements,\r\n\t\t\t\tpercentComplete = activeCall.percentComplete,\r\n\t\t\t\toptions = activeCall.options,\r\n\t\t\t\ttweenValue = activeCall.tween;\r\n\r\n\t\t\t(activeCall.options.progress as VelocityProgress).call(elements,\r\n\t\t\t\telements,\r\n\t\t\t\tpercentComplete,\r\n\t\t\t\tMath.max(0, activeCall.timeStart + (activeCall.duration != null ? activeCall.duration : options.duration != null ? options.duration : defaults.duration) - timeCurrent),\r\n\t\t\t\ttweenValue !== undefined ? tweenValue : String(percentComplete * 100),\r\n\t\t\t\tactiveCall);\r\n\t\t} catch (error) {\r\n\t\t\tsetTimeout(function() {\r\n\t\t\t\tthrow error;\r\n\t\t\t}, 1);\r\n\t\t}\r\n\t}\r\n\r\n\tlet firstProgress: AnimationCall,\r\n\t\tfirstComplete: AnimationCall;\r\n\r\n\tfunction asyncCallbacks() {\r\n\t\tlet activeCall: AnimationCall,\r\n\t\t\tnextCall: AnimationCall;\r\n\t\t// Callbacks and complete that might read the DOM again.\r\n\r\n\t\t// Progress callback\r\n\t\tfor (activeCall = firstProgress; activeCall; activeCall = nextCall) {\r\n\t\t\tnextCall = activeCall._nextProgress;\r\n\t\t\t// Pass to an external fn with a try/catch block for optimisation\r\n\t\t\tcallProgress(activeCall, lastTick);\r\n\t\t}\r\n\t\t// Complete animations, including complete callback or looping\r\n\t\tfor (activeCall = firstComplete; activeCall; activeCall = nextCall) {\r\n\t\t\tnextCall = activeCall._nextComplete;\r\n\t\t\t/* If this call has finished tweening, pass it to complete() to handle call cleanup. */\r\n\t\t\tcompleteCall(activeCall);\r\n\t\t}\r\n\t}\r\n\r\n\t/**************\r\n\t Timing\r\n\t **************/\r\n\r\n\tconst FRAME_TIME = 1000 / 60,\r\n\t\t/**\r\n\t\t* Shim for window.performance in case it doesn't exist\r\n\t\t*/\r\n\t\tperformance = (function() {\r\n\t\t\tconst perf = window.performance || {} as Performance;\r\n\r\n\t\t\tif (typeof perf.now !== \"function\") {\r\n\t\t\t\tconst nowOffset = perf.timing && perf.timing.navigationStart ? perf.timing.navigationStart : _now();\r\n\r\n\t\t\t\tperf.now = function() {\r\n\t\t\t\t\treturn _now() - nowOffset;\r\n\t\t\t\t};\r\n\t\t\t}\r\n\t\t\treturn perf;\r\n\t\t})(),\r\n\t\t/**\r\n\t\t * Proxy function for when rAF is not available - try to be as accurate\r\n\t\t * as possible with the setTimeout calls, however they are far less\r\n\t\t * accurate than rAF can be - so try not to use normally (unless the tab\r\n\t\t * is in the background).\r\n\t\t */\r\n\t\trAFProxy = function(callback: FrameRequestCallback) {\r\n\t\t\tconsole.log(\"rAFProxy\", Math.max(0, FRAME_TIME - (performance.now() - lastTick)), performance.now(), lastTick, FRAME_TIME)\r\n\t\t\treturn setTimeout(function() {\r\n\t\t\t\tcallback(performance.now());\r\n\t\t\t}, Math.max(0, FRAME_TIME - (performance.now() - lastTick)));\r\n\t\t},\r\n\t\t/* rAF shim. Gist: https://gist.github.com/julianshapiro/9497513 */\r\n\t\trAFShim = window.requestAnimationFrame || rAFProxy;\r\n\t/**\r\n\t * The ticker function being used, either rAF, or a function that\r\n\t * emulates it.\r\n\t */\r\n\tlet ticker: (callback: FrameRequestCallback) => number = document.hidden ? rAFProxy : rAFShim;\r\n\t/**\r\n\t * The time that the last animation frame ran at. Set from tick(), and used\r\n\t * for missing rAF (ie, when not in focus etc).\r\n\t */\r\n\texport let lastTick: number = 0;\r\n\r\n\t/* Inactive browser tabs pause rAF, which results in all active animations immediately sprinting to their completion states when the tab refocuses.\r\n\t To get around this, we dynamically switch rAF to setTimeout (which the browser *doesn't* pause) when the tab loses focus. We skip this for mobile\r\n\t devices to avoid wasting battery power on inactive tabs. */\r\n\t/* Note: Tab focus detection doesn't work on older versions of IE, but that's okay since they don't support rAF to begin with. */\r\n\tif (!State.isMobile && document.hidden !== undefined) {\r\n\t\tdocument.addEventListener(\"visibilitychange\", function updateTicker(event?: Event) {\r\n\t\t\tlet hidden = document.hidden;\r\n\r\n\t\t\tticker = hidden ? rAFProxy : rAFShim;\r\n\t\t\tif (event) {\r\n\t\t\t\tsetTimeout(tick, 2000);\r\n\t\t\t}\r\n\t\t\ttick();\r\n\t\t});\r\n\t}\r\n\r\n\tlet ticking: boolean;\r\n\r\n\t/**\r\n\t * Called on every tick, preferably through rAF. This is reponsible for\r\n\t * initialising any new animations, then starting any that need starting.\r\n\t * Finally it will expand any tweens and set the properties relating to\r\n\t * them. If there are any callbacks relating to the animations then they\r\n\t * will attempt to call at the end (with the exception of \"begin\").\r\n\t */\r\n\texport function tick(timestamp?: number | boolean) {\r\n\t\tif (ticking) {\r\n\t\t\t// Should never happen - but if we've swapped back from hidden to\r\n\t\t\t// visibile then we want to make sure\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tticking = true;\r\n\t\t/* An empty timestamp argument indicates that this is the first tick occurence since ticking was turned on.\r\n\t\t We leverage this metadata to fully ignore the first tick pass since RAF's initial pass is fired whenever\r\n\t\t the browser's next tick sync time occurs, which results in the first elements subjected to Velocity\r\n\t\t calls being animated out of sync with any elements animated immediately thereafter. In short, we ignore\r\n\t\t the first RAF tick pass so that elements being immediately consecutively animated -- instead of simultaneously animated\r\n\t\t by the same Velocity call -- are properly batched into the same initial RAF tick and consequently remain in sync thereafter. */\r\n\t\tif (timestamp) {\r\n\t\t\t/* We normally use RAF's high resolution timestamp but as it can be significantly offset when the browser is\r\n\t\t\t under high stress we give the option for choppiness over allowing the browser to drop huge chunks of frames.\r\n\t\t\t We use performance.now() and shim it if it doesn't exist for when the tab is hidden. */\r\n\t\t\tconst timeCurrent = timestamp && timestamp !== true ? timestamp : performance.now(),\r\n\t\t\t\tdeltaTime = lastTick ? timeCurrent - lastTick : FRAME_TIME,\r\n\t\t\t\tdefaultSpeed = defaults.speed,\r\n\t\t\t\tdefaultEasing = defaults.easing,\r\n\t\t\t\tdefaultDuration = defaults.duration;\r\n\t\t\tlet activeCall: AnimationCall,\r\n\t\t\t\tnextCall: AnimationCall,\r\n\t\t\t\tlastProgress: AnimationCall,\r\n\t\t\t\tlastComplete: AnimationCall;\r\n\r\n\t\t\tfirstProgress = null;\r\n\t\t\tfirstComplete = null;\r\n\t\t\tif (deltaTime >= defaults.minFrameTime || !lastTick) {\r\n\t\t\t\tlastTick = timeCurrent;\r\n\r\n\t\t\t\t/********************\r\n\t\t\t\t Call Iteration\r\n\t\t\t\t ********************/\r\n\r\n\t\t\t\t// Expand any tweens that might need it.\r\n\t\t\t\twhile ((activeCall = State.firstNew)) {\r\n\t\t\t\t\tvalidateTweens(activeCall);\r\n\t\t\t\t}\r\n\t\t\t\t// Iterate through each active call.\r\n\t\t\t\tfor (activeCall = State.first; activeCall && activeCall !== State.firstNew; activeCall = activeCall._next) {\r\n\t\t\t\t\tconst element = activeCall.element;\r\n\t\t\t\t\tlet data: ElementData;\r\n\r\n\t\t\t\t\t// Check to see if this element has been deleted midway\r\n\t\t\t\t\t// through the animation. If it's gone then end this\r\n\t\t\t\t\t// animation.\r\n\t\t\t\t\tif (!element.parentNode || !(data = Data(element))) {\r\n\t\t\t\t\t\t// TODO: Remove safely - decrease count, delete data, remove from arrays\r\n\t\t\t\t\t\tfreeAnimationCall(activeCall);\r\n\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t}\r\n\t\t\t\t\t// Don't bother getting until we can use these.\r\n\t\t\t\t\tconst options = activeCall.options,\r\n\t\t\t\t\t\tflags = activeCall._flags;\r\n\t\t\t\t\tlet timeStart = activeCall.timeStart;\r\n\r\n\t\t\t\t\t// If this is the first time that this call has been\r\n\t\t\t\t\t// processed by tick() then we assign timeStart now so that\r\n\t\t\t\t\t// it's value is as close to the real animation start time\r\n\t\t\t\t\t// as possible.\r\n\t\t\t\t\tif (!timeStart) {\r\n\t\t\t\t\t\tconst queue = activeCall.queue != null ? activeCall.queue : options.queue;\r\n\r\n\t\t\t\t\t\ttimeStart = timeCurrent - deltaTime;\r\n\t\t\t\t\t\tif (queue !== false) {\r\n\t\t\t\t\t\t\ttimeStart = Math.max(timeStart, data.lastFinishList[queue] || 0);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tactiveCall.timeStart = timeStart;\r\n\t\t\t\t\t}\r\n\t\t\t\t\t// If this animation is paused then skip processing unless\r\n\t\t\t\t\t// it has been set to resume.\r\n\t\t\t\t\tif (flags & AnimationFlags.PAUSED) {\r\n\t\t\t\t\t\t// Update the time start to accomodate the paused\r\n\t\t\t\t\t\t// completion amount.\r\n\t\t\t\t\t\tactiveCall.timeStart += deltaTime;\r\n\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t}\r\n\t\t\t\t\t// Check if this animation is ready - if it's synced then it\r\n\t\t\t\t\t// needs to wait for all other animations in the sync\r\n\t\t\t\t\tif (!(flags & AnimationFlags.READY)) {\r\n\t\t\t\t\t\tactiveCall._flags |= AnimationFlags.READY;\r\n\t\t\t\t\t\toptions._ready++;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\t// Need to split the loop, as ready sync animations must all get\r\n\t\t\t\t// the same start time.\r\n\t\t\t\tfor (activeCall = State.first; activeCall && activeCall !== State.firstNew; activeCall = nextCall) {\r\n\t\t\t\t\tconst flags = activeCall._flags;\r\n\r\n\t\t\t\t\tnextCall = activeCall._next;\r\n\t\t\t\t\tif (!(flags & AnimationFlags.READY) || (flags & AnimationFlags.PAUSED)) {\r\n\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tconst options = activeCall.options;\r\n\r\n\t\t\t\t\tif ((flags & AnimationFlags.SYNC) && options._ready < options._total) {\r\n\t\t\t\t\t\tactiveCall.timeStart += deltaTime;\r\n\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tconst speed = activeCall.speed != null ? activeCall.speed : options.speed != null ? options.speed : defaultSpeed;\r\n\t\t\t\t\tlet timeStart = activeCall.timeStart;\r\n\r\n\t\t\t\t\t// Don't bother getting until we can use these.\r\n\t\t\t\t\tif (!(flags & AnimationFlags.STARTED)) {\r\n\t\t\t\t\t\tconst delay = activeCall.delay != null ? activeCall.delay : options.delay;\r\n\r\n\t\t\t\t\t\t// Make sure anything we've delayed doesn't start\r\n\t\t\t\t\t\t// animating yet, there might still be an active delay\r\n\t\t\t\t\t\t// after something has been un-paused\r\n\t\t\t\t\t\tif (delay) {\r\n\t\t\t\t\t\t\tif (timeStart + (delay / speed) > timeCurrent) {\r\n\t\t\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\tactiveCall.timeStart = timeStart += delay / (delay > 0 ? speed : 1);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tactiveCall._flags |= AnimationFlags.STARTED;\r\n\t\t\t\t\t\t// The begin callback is fired once per call, not once\r\n\t\t\t\t\t\t// per element, and is passed the full raw DOM element\r\n\t\t\t\t\t\t// set as both its context and its first argument.\r\n\t\t\t\t\t\tif (options._started++ === 0) {\r\n\t\t\t\t\t\t\toptions._first = activeCall;\r\n\t\t\t\t\t\t\tif (options.begin) {\r\n\t\t\t\t\t\t\t\t// Pass to an external fn with a try/catch block for optimisation\r\n\t\t\t\t\t\t\t\tcallBegin(activeCall);\r\n\t\t\t\t\t\t\t\t// Only called once, even if reversed or repeated\r\n\t\t\t\t\t\t\t\toptions.begin = undefined;\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\tif (speed !== 1) {\r\n\t\t\t\t\t\t// On the first frame we may have a shorter delta\r\n\t\t\t\t\t\tconst delta = Math.min(deltaTime, timeCurrent - timeStart);\r\n\t\t\t\t\t\tactiveCall.timeStart = timeStart += delta * (1 - speed);\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tif (options._first === activeCall && options.progress) {\r\n\t\t\t\t\t\tactiveCall._nextProgress = undefined;\r\n\t\t\t\t\t\tif (lastProgress) {\r\n\t\t\t\t\t\t\tlastProgress._nextProgress = lastProgress = activeCall;\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tfirstProgress = lastProgress = activeCall;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tconst activeEasing = activeCall.easing != null ? activeCall.easing : options.easing != null ? options.easing : defaultEasing,\r\n\t\t\t\t\t\tmillisecondsEllapsed = activeCall.ellapsedTime = timeCurrent - timeStart,\r\n\t\t\t\t\t\tduration = activeCall.duration != null ? activeCall.duration : options.duration != null ? options.duration : defaultDuration,\r\n\t\t\t\t\t\tpercentComplete = activeCall.percentComplete = mock ? 1 : Math.min(millisecondsEllapsed / duration, 1),\r\n\t\t\t\t\t\ttweens = activeCall.tweens,\r\n\t\t\t\t\t\treverse = flags & AnimationFlags.REVERSE;\r\n\r\n\t\t\t\t\tif (percentComplete === 1) {\r\n\t\t\t\t\t\tactiveCall._nextComplete = undefined;\r\n\t\t\t\t\t\tif (lastComplete) {\r\n\t\t\t\t\t\t\tlastComplete._nextComplete = lastComplete = activeCall;\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tfirstComplete = lastComplete = activeCall;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tfor (const property in tweens) {\r\n\t\t\t\t\t\t// For every element, iterate through each property.\r\n\t\t\t\t\t\tconst tween = tweens[property],\r\n\t\t\t\t\t\t\teasing = tween.easing || activeEasing,\r\n\t\t\t\t\t\t\tpattern = tween.pattern;\r\n\t\t\t\t\t\tlet currentValue = \"\",\r\n\t\t\t\t\t\t\ti = 0;\r\n\r\n\t\t\t\t\t\tif (pattern) {\r\n\t\t\t\t\t\t\tfor (; i < pattern.length; i++) {\r\n\t\t\t\t\t\t\t\tconst startValue = tween.start[i];\r\n\r\n\t\t\t\t\t\t\t\tif (startValue == null) {\r\n\t\t\t\t\t\t\t\t\tcurrentValue += pattern[i];\r\n\t\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\t\t// All easings must deal with numbers except for\r\n\t\t\t\t\t\t\t\t\t// our internal ones\r\n\t\t\t\t\t\t\t\t\tconst result = easing(reverse ? 1 - percentComplete : percentComplete, startValue as number, tween.end[i] as number, property)\r\n\r\n\t\t\t\t\t\t\t\t\tcurrentValue += pattern[i] === true ? Math.round(result) : result;\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\tif (property !== \"tween\") {\r\n\t\t\t\t\t\t\t\t// 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\r\n\t\t\t\t\t\t\t\tCSS.setPropertyValue(activeCall.element, property, currentValue, tween.fn);\r\n\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\t// Skip the fake 'tween' property as that is only\r\n\t\t\t\t\t\t\t\t// passed into the progress callback.\r\n\t\t\t\t\t\t\t\tactiveCall.tween = currentValue;\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tconsole.warn(\"VelocityJS: Missing pattern:\", property, JSON.stringify(tween[property]))\r\n\t\t\t\t\t\t\tdelete tweens[property];\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\tif (firstProgress || firstComplete) {\r\n\t\t\t\t\tsetTimeout(asyncCallbacks, 1);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (State.first) {\r\n\t\t\tState.isTicking = true;\r\n\t\t\tticker(tick);\r\n\t\t} else {\r\n\t\t\tState.isTicking = false;\r\n\t\t\tlastTick = 0;\r\n\t\t}\r\n\t\tticking = false;\r\n\t}\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Use rAF high resolution timestamp when available.\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\texport let timestamp: boolean = true;\r\n};\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Tweens\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\tconst rxHex = /^#([A-f\\d]{3}){1,2}$/i;\r\n\tlet commands = new Map<string, (value: any, element: HTMLorSVGElement, elements: HTMLorSVGElement[], elementArrayIndex: number, propertyName: string, tween: VelocityTween) => string>();\r\n\r\n\tcommands.set(\"function\", function(value, element, elements, elementArrayIndex, propertyName, tween) {\r\n\t\treturn (value as any as VelocityPropertyValueFn).call(element, elementArrayIndex, elements.length);\r\n\t})\r\n\tcommands.set(\"number\", function(value, element, elements, elementArrayIndex, propertyName, tween) {\r\n\t\treturn value + getNormalizationUnit(tween.fn);\r\n\t});\r\n\tcommands.set(\"string\", function(value, element, elements, elementArrayIndex, propertyName, tween) {\r\n\t\treturn CSS.fixColors(value);\r\n\t});\r\n\tcommands.set(\"undefined\", function(value, element, elements, elementArrayIndex, propertyName, tween) {\r\n\t\treturn CSS.fixColors(CSS.getPropertyValue(element, propertyName, tween.fn) || \"\");\r\n\t});\r\n\r\n\t/**\r\n\t * Expand a VelocityProperty argument into a valid sparse Tween array. This\r\n\t * pre-allocates the array as it is then the correct size and slightly\r\n\t * faster to access.\r\n\t */\r\n\texport function expandProperties(animation: AnimationCall, properties: VelocityProperties) {\r\n\t\tconst tweens = animation.tweens = createEmptyObject(),\r\n\t\t\telements = animation.elements,\r\n\t\t\telement = animation.element,\r\n\t\t\telementArrayIndex = elements.indexOf(element),\r\n\t\t\tdata = Data(element),\r\n\t\t\tqueue = getValue(animation.queue, animation.options.queue),\r\n\t\t\tduration = getValue(animation.options.duration, defaults.duration);\r\n\r\n\t\tfor (const property in properties) {\r\n\t\t\tconst propertyName = CSS.camelCase(property);\r\n\t\t\tlet valueData = properties[property],\r\n\t\t\t\tfn = getNormalization(element, propertyName);\r\n\r\n\t\t\tif (!fn && propertyName !== \"tween\") {\r\n\t\t\t\tif (debug) {\r\n\t\t\t\t\tconsole.log(\"Skipping [\" + property + \"] due to a lack of browser support.\");\r\n\t\t\t\t}\r\n\t\t\t\tcontinue;\r\n\t\t\t}\r\n\t\t\tif (valueData == null) {\r\n\t\t\t\tif (debug) {\r\n\t\t\t\t\tconsole.log(\"Skipping [\" + property + \"] due to no value supplied.\");\r\n\t\t\t\t}\r\n\t\t\t\tcontinue;\r\n\t\t\t}\r\n\t\t\tconst tween: VelocityTween = tweens[propertyName] = createEmptyObject() as any;\r\n\t\t\tlet endValue: string,\r\n\t\t\t\tstartValue: string;\r\n\r\n\t\t\ttween.fn = fn;\r\n\t\t\tif (isFunction(valueData)) {\r\n\t\t\t\t// If we have a function as the main argument then resolve\r\n\t\t\t\t// it first, in case it returns an array that needs to be\r\n\t\t\t\t// split.\r\n\t\t\t\tvalueData = (valueData as VelocityPropertyFn).call(element, elementArrayIndex, elements.length, elements);\r\n\t\t\t}\r\n\t\t\tif (Array.isArray(valueData)) {\r\n\t\t\t\t// valueData is an array in the form of\r\n\t\t\t\t// [ endValue, [, easing] [, startValue] ]\r\n\t\t\t\tconst arr1 = valueData[1],\r\n\t\t\t\t\tarr2 = valueData[2];\r\n\r\n\t\t\t\tendValue = valueData[0] as any;\r\n\t\t\t\tif ((isString(arr1) && (/^[\\d-]/.test(arr1) || rxHex.test(arr1))) || isFunction(arr1) || isNumber(arr1)) {\r\n\t\t\t\t\tstartValue = arr1 as any;\r\n\t\t\t\t} else if ((isString(arr1) && Easing.Easings[arr1]) || Array.isArray(arr1)) {\r\n\t\t\t\t\ttween.easing = arr1 as any;\r\n\t\t\t\t\tstartValue = arr2 as any;\r\n\t\t\t\t} else {\r\n\t\t\t\t\tstartValue = arr1 || arr2 as any;\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tendValue = valueData as any;\r\n\t\t\t}\r\n\t\t\ttween.end = commands.get(typeof endValue)(endValue, element, elements, elementArrayIndex, propertyName, tween) as any;\r\n\t\t\tif (startValue != null || (queue === false || data.queueList[queue] === undefined)) {\r\n\t\t\t\ttween.start = commands.get(typeof startValue)(startValue, element, elements, elementArrayIndex, propertyName, tween) as any;\r\n\t\t\t}\r\n\t\t\texplodeTween(propertyName, tween, duration, !!startValue);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Convert a string-based tween with start and end strings, into a pattern\r\n\t * based tween with arrays.\r\n\t */\r\n\tfunction explodeTween(propertyName: string, tween: VelocityTween, duration: number, isForcefeed?: boolean) {\r\n\t\tconst endValue: string = tween.end as any as string;\r\n\t\tlet startValue: string = tween.start as any as string;\r\n\r\n\t\tif (!isString(endValue) || !isString(startValue)) {\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tlet runAgain = false; // Can only be set once if the Start value doesn't match the End value and it's not forcefed\r\n\t\tdo {\r\n\t\t\trunAgain = false;\r\n\t\t\tconst arrayStart: (string | number)[] = tween.start = [null],\r\n\t\t\t\tarrayEnd: (string | number)[] = tween.end = [null],\r\n\t\t\t\tpattern: (string | boolean)[] = tween.pattern = [\"\"];\r\n\t\t\tlet easing = tween.easing as any,\r\n\t\t\t\tindexStart = 0, // index in startValue\r\n\t\t\t\tindexEnd = 0, // index in endValue\r\n\t\t\t\tinCalc = 0, // Keep track of being inside a \"calc()\" so we don't duplicate it\r\n\t\t\t\tinRGB = 0, // Keep track of being inside an RGB as we can't use fractional values\r\n\t\t\t\tinRGBA = 0, // Keep track of being inside an RGBA as we must pass fractional for the alpha channel\r\n\t\t\t\tisStringValue: boolean;\r\n\r\n\t\t\t// TODO: Relative Values\r\n\r\n\t\t\t/* Operator logic must be performed last since it requires unit-normalized start and end values. */\r\n\t\t\t/* Note: Relative *percent values* do not behave how most people think; while one would expect \"+=50%\"\r\n\t\t\t to increase the property 1.5x its current value, it in fact increases the percent units in absolute terms:\r\n\t\t\t 50 points is added on top of the current % value. */\r\n\t\t\t//\t\t\t\t\tswitch (operator as any as string) {\r\n\t\t\t//\t\t\t\t\t\tcase \"+\":\r\n\t\t\t//\t\t\t\t\t\t\tendValue = startValue + endValue;\r\n\t\t\t//\t\t\t\t\t\t\tbreak;\r\n\t\t\t//\r\n\t\t\t//\t\t\t\t\t\tcase \"-\":\r\n\t\t\t//\t\t\t\t\t\t\tendValue = startValue - endValue;\r\n\t\t\t//\t\t\t\t\t\t\tbreak;\r\n\t\t\t//\r\n\t\t\t//\t\t\t\t\t\tcase \"*\":\r\n\t\t\t//\t\t\t\t\t\t\tendValue = startValue * endValue;\r\n\t\t\t//\t\t\t\t\t\t\tbreak;\r\n\t\t\t//\r\n\t\t\t//\t\t\t\t\t\tcase \"/\":\r\n\t\t\t//\t\t\t\t\t\t\tendValue = startValue / endValue;\r\n\t\t\t//\t\t\t\t\t\t\tbreak;\r\n\t\t\t//\t\t\t\t\t}\r\n\r\n\t\t\t// TODO: Leading from a calc value\r\n\t\t\twhile (indexStart < startValue.length && indexEnd < endValue.length) {\r\n\t\t\t\tlet charStart = startValue[indexStart],\r\n\t\t\t\t\tcharEnd = endValue[indexEnd];\r\n\r\n\t\t\t\t// If they're both numbers, then parse them as a whole\r\n\t\t\t\tif (TWEEN_NUMBER_REGEX.test(charStart) && TWEEN_NUMBER_REGEX.test(charEnd)) {\r\n\t\t\t\t\tlet tempStart = charStart, // temporary character buffer\r\n\t\t\t\t\t\ttempEnd = charEnd, // temporary character buffer\r\n\t\t\t\t\t\tdotStart = \".\", // Make sure we can only ever match a single dot in a decimal\r\n\t\t\t\t\t\tdotEnd = \".\"; // Make sure we can only ever match a single dot in a decimal\r\n\r\n\t\t\t\t\twhile (++indexStart < startValue.length) {\r\n\t\t\t\t\t\tcharStart = startValue[indexStart];\r\n\t\t\t\t\t\tif (charStart === dotStart) {\r\n\t\t\t\t\t\t\tdotStart = \"..\"; // Can never match two characters\r\n\t\t\t\t\t\t} else if (!isNumberWhenParsed(charStart)) {\r\n\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\ttempStart += charStart;\r\n\t\t\t\t\t}\r\n\t\t\t\t\twhile (++indexEnd < endValue.length) {\r\n\t\t\t\t\t\tcharEnd = endValue[indexEnd];\r\n\t\t\t\t\t\tif (charEnd === dotEnd) {\r\n\t\t\t\t\t\t\tdotEnd = \"..\"; // Can never match two characters\r\n\t\t\t\t\t\t} else if (!isNumberWhenParsed(charEnd)) {\r\n\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\ttempEnd += charEnd;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tlet unitStart = CSS.getUnit(startValue, indexStart), // temporary unit type\r\n\t\t\t\t\t\tunitEnd = CSS.getUnit(endValue, indexEnd); // temporary unit type\r\n\r\n\t\t\t\t\tindexStart += unitStart.length;\r\n\t\t\t\t\tindexEnd += unitEnd.length;\r\n\t\t\t\t\tif (unitEnd.length === 0) {\r\n\t\t\t\t\t\t// This order as it's most common for the user supplied\r\n\t\t\t\t\t\t// value to be a number.\r\n\t\t\t\t\t\tunitEnd = unitStart;\r\n\t\t\t\t\t} else if (unitStart.length === 0) {\r\n\t\t\t\t\t\tunitStart = unitEnd;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (unitStart === unitEnd) {\r\n\t\t\t\t\t\t// Same units\r\n\t\t\t\t\t\tif (tempStart === tempEnd) {\r\n\t\t\t\t\t\t\t// Same numbers, so just copy over\r\n\t\t\t\t\t\t\tpattern[pattern.length - 1] += tempStart + unitStart;\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tpattern.push(inRGB ? true : false, unitStart);\r\n\t\t\t\t\t\t\tarrayStart.push(parseFloat(tempStart), null);\r\n\t\t\t\t\t\t\tarrayEnd.push(parseFloat(tempEnd), null);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\t// Different units, so put into a \"calc(from + to)\" and\r\n\t\t\t\t\t\t// animate each side to/from zero. setPropertyValue will\r\n\t\t\t\t\t\t// look out for the final \"calc(0 + \" prefix and remove\r\n\t\t\t\t\t\t// it from the value when it finds it.\r\n\t\t\t\t\t\tpattern[pattern.length - 1] += inCalc ? \"+ (\" : \"calc(\";\r\n\t\t\t\t\t\tpattern.push(false, unitStart + \" + \", false, unitEnd + \")\");\r\n\t\t\t\t\t\tarrayStart.push(parseFloat(tempStart) || 0, null, 0, null);\r\n\t\t\t\t\t\tarrayEnd.push(0, null, parseFloat(tempEnd) || 0, null);\r\n\t\t\t\t\t}\r\n\t\t\t\t} else if (charStart === charEnd) {\r\n\t\t\t\t\tpattern[pattern.length - 1] += charStart;\r\n\t\t\t\t\tindexStart++;\r\n\t\t\t\t\tindexEnd++;\r\n\t\t\t\t\t// Keep track of being inside a calc()\r\n\t\t\t\t\tif (inCalc === 0 && charStart === \"c\"\r\n\t\t\t\t\t\t|| inCalc === 1 && charStart === \"a\"\r\n\t\t\t\t\t\t|| inCalc === 2 && charStart === \"l\"\r\n\t\t\t\t\t\t|| inCalc === 3 && charStart === \"c\"\r\n\t\t\t\t\t\t|| inCalc >= 4 && charStart === \"(\"\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\tinCalc++;\r\n\t\t\t\t\t} else if ((inCalc && inCalc < 5)\r\n\t\t\t\t\t\t|| inCalc >= 4 && charStart === \")\" && --inCalc < 5) {\r\n\t\t\t\t\t\tinCalc = 0;\r\n\t\t\t\t\t}\r\n\t\t\t\t\t// Keep track of being inside an rgb() / rgba()\r\n\t\t\t\t\t// The opacity must not be rounded.\r\n\t\t\t\t\tif (inRGB === 0 && charStart === \"r\"\r\n\t\t\t\t\t\t|| inRGB === 1 && charStart === \"g\"\r\n\t\t\t\t\t\t|| inRGB === 2 && charStart === \"b\"\r\n\t\t\t\t\t\t|| inRGB === 3 && charStart === \"a\"\r\n\t\t\t\t\t\t|| inRGB >= 3 && charStart === \"(\"\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\tif (inRGB === 3 && charStart === \"a\") {\r\n\t\t\t\t\t\t\tinRGBA = 1;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tinRGB++;\r\n\t\t\t\t\t} else if (inRGBA && charStart === \",\") {\r\n\t\t\t\t\t\tif (++inRGBA > 3) {\r\n\t\t\t\t\t\t\tinRGB = inRGBA = 0;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} else if ((inRGBA && inRGB < (inRGBA ? 5 : 4))\r\n\t\t\t\t\t\t|| inRGB >= (inRGBA ? 4 : 3) && charStart === \")\" && --inRGB < (inRGBA ? 5 : 4)) {\r\n\t\t\t\t\t\tinRGB = inRGBA = 0;\r\n\t\t\t\t\t}\r\n\t\t\t\t} else if (charStart || charEnd) {\r\n\t\t\t\t\t// Different letters, so we're going to push them into start\r\n\t\t\t\t\t// and end until the next word\r\n\t\t\t\t\tisStringValue = true;\r\n\t\t\t\t\tif (!isString(arrayStart[arrayStart.length - 1])) {\r\n\t\t\t\t\t\tif (pattern.length === 1 && !pattern[0]) {\r\n\t\t\t\t\t\t\tarrayStart[0] = arrayEnd[0] = \"\";\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tpattern.push(\"\");\r\n\t\t\t\t\t\t\tarrayStart.push(\"\");\r\n\t\t\t\t\t\t\tarrayEnd.push(\"\");\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\twhile (indexStart < startValue.length) {\r\n\t\t\t\t\t\tcharStart = startValue[indexStart++];\r\n\t\t\t\t\t\tif (charStart === \" \" || TWEEN_NUMBER_REGEX.test(charStart)) {\r\n\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tarrayStart[arrayStart.length - 1] += charStart;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\twhile (indexEnd < endValue.length) {\r\n\t\t\t\t\t\tcharEnd = endValue[indexEnd++];\r\n\t\t\t\t\t\tif (charEnd === \" \" || TWEEN_NUMBER_REGEX.test(charEnd)) {\r\n\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tarrayEnd[arrayEnd.length - 1] += charEnd;\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\tif (!isForcefeed && (indexStart === startValue.length) !== (indexEnd === endValue.length)) {\r\n\t\t\t\t\t// This little piece will take a startValue, split out the\r\n\t\t\t\t\t// various numbers in it, then copy the endValue into the\r\n\t\t\t\t\t// startValue while replacing the numbers in it to match the\r\n\t\t\t\t\t// original start numbers as a repeating sequence.\r\n\t\t\t\t\t// Finally this function will run again with the new\r\n\t\t\t\t\t// startValue and a now matching pattern.\r\n\t\t\t\t\tlet startNumbers = startValue.match(/\\d\\.?\\d*/g) || [\"0\"],\r\n\t\t\t\t\t\tcount = startNumbers.length,\r\n\t\t\t\t\t\tindex = 0;\r\n\r\n\t\t\t\t\tstartValue = endValue.replace(/\\d+\\.?\\d*/g, function() {\r\n\t\t\t\t\t\treturn startNumbers[index++ % count];\r\n\t\t\t\t\t});\r\n\t\t\t\t\trunAgain = isForcefeed = true;\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (!runAgain) {\r\n\t\t\t\t// TODO: These two would be slightly better to not add the array indices in the first place\r\n\t\t\t\tif (pattern[0] === \"\" && arrayEnd[0] == null) {\r\n\t\t\t\t\tpattern.shift();\r\n\t\t\t\t\tarrayStart.shift();\r\n\t\t\t\t\tarrayEnd.shift();\r\n\t\t\t\t}\r\n\t\t\t\tif (pattern[pattern.length] === \"\" && arrayEnd[arrayEnd.length] == null) {\r\n\t\t\t\t\tpattern.pop();\r\n\t\t\t\t\tarrayStart.pop();\r\n\t\t\t\t\tarrayEnd.pop();\r\n\t\t\t\t}\r\n\t\t\t\tif (indexStart < startValue.length || indexEnd < endValue.length) {\r\n\t\t\t\t\t// NOTE: We should never be able to reach this code unless a\r\n\t\t\t\t\t// bad forcefed value is supplied.\r\n\t\t\t\t\tconsole.error(\"Velocity: Trying to pattern match mis-matched strings \" + propertyName + \":[\\\"\" + endValue + \"\\\", \\\"\" + startValue + \"\\\"]\");\r\n\t\t\t\t}\r\n\t\t\t\tif (debug) {\r\n\t\t\t\t\tconsole.log(\"Velocity: Pattern found:\", pattern, \" -> \", arrayStart, arrayEnd, \"[\" + startValue + \",\" + endValue + \"]\");\r\n\t\t\t\t}\r\n\t\t\t\tif (propertyName === \"display\") {\r\n\t\t\t\t\tif (!/^(at-start|at-end|during)$/.test(easing)) {\r\n\t\t\t\t\t\teasing = endValue === \"none\" ? \"at-end\" : \"at-start\";\r\n\t\t\t\t\t}\r\n\t\t\t\t} else if (propertyName === \"visibility\") {\r\n\t\t\t\t\tif (!/^(at-start|at-end|during)$/.test(easing)) {\r\n\t\t\t\t\t\teasing = endValue === \"hidden\" ? \"at-end\" : \"at-start\";\r\n\t\t\t\t\t}\r\n\t\t\t\t} else if (isStringValue\r\n\t\t\t\t\t&& easing !== \"at-start\" && easing !== \"during\" && easing !== \"at-end\"\r\n\t\t\t\t\t&& easing !== Easing.Easings[\"at-Start\"] && easing !== Easing.Easings[\"during\"] && easing !== Easing.Easings[\"at-end\"]) {\r\n\t\t\t\t\tconsole.warn(\"Velocity: String easings must use one of 'at-start', 'during' or 'at-end': {\" + propertyName + \": [\\\"\" + endValue + \"\\\", \" + easing + \", \\\"\" + startValue + \"\\\"]}\");\r\n\t\t\t\t\teasing = \"at-start\";\r\n\t\t\t\t}\r\n\t\t\t\ttween.easing = validateEasing(easing, duration);\r\n\t\t\t}\r\n\t\t\t// This can only run a second time once - if going from automatic startValue to \"fixed\" pattern from endValue with startValue numbers\r\n\t\t} while (runAgain);\r\n\t}\r\n\r\n\t/**\r\n\t * Expand all queued animations that haven't gone yet\r\n\t *\r\n\t * This will automatically expand the properties map for any recently added\r\n\t * animations so that the start and end values are correct.\r\n\t */\r\n\texport function validateTweens(activeCall: AnimationCall) {\r\n\t\t// This might be called on an already-ready animation\r\n\t\tif (State.firstNew === activeCall) {\r\n\t\t\tState.firstNew = activeCall._next;\r\n\t\t}\r\n\t\t// Check if we're actually already ready\r\n\t\tif (activeCall._flags & AnimationFlags.EXPANDED) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tlet element = activeCall.element,\r\n\t\t\ttweens = activeCall.tweens,\r\n\t\t\tduration = getValue(activeCall.options.duration, defaults.duration);\r\n\r\n\t\tfor (const propertyName in tweens) {\r\n\t\t\tconst tween = tweens[propertyName];\r\n\r\n\t\t\tif (tween.start == null) {\r\n\t\t\t\t// Get the start value as it's not been passed in\r\n\t\t\t\tconst startValue = CSS.getPropertyValue(activeCall.element, propertyName);\r\n\r\n\t\t\t\tif (isString(startValue)) {\r\n\t\t\t\t\ttween.start = CSS.fixColors(startValue) as any;\r\n\t\t\t\t\texplodeTween(propertyName, tween, duration);\r\n\t\t\t\t} else if (!Array.isArray(startValue)) {\r\n\t\t\t\t\tconsole.warn(\"bad type\", tween, propertyName, startValue)\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (debug) {\r\n\t\t\t\tconsole.log(\"tweensContainer (\" + propertyName + \"): \" + JSON.stringify(tween), element);\r\n\t\t\t}\r\n\t\t}\r\n\t\tactiveCall._flags |= AnimationFlags.EXPANDED;\r\n\t}\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Validation functions used for various types of data that can be supplied.\r\n * All errors are reported in the non-minified version for development. If a\r\n * validation fails then it should return <code>undefined</code>.\r\n */\r\n\r\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 */\r\nfunction parseDuration(duration: \"fast\" | \"normal\" | \"slow\" | number, def?: \"fast\" | \"normal\" | \"slow\" | number): number {\r\n\tif (isNumber(duration)) {\r\n\t\treturn duration;\r\n\t}\r\n\tif (isString(duration)) {\r\n\t\treturn Duration[duration.toLowerCase()] || parseFloat(duration.replace(\"ms\", \"\").replace(\"s\", \"000\"));\r\n\t}\r\n\treturn def == null ? undefined : parseDuration(def);\r\n}\r\n\r\n/**\r\n * Validate a <code>cache</code> option.\r\n * @private\r\n */\r\nfunction validateCache(value: boolean): boolean {\r\n\tif (isBoolean(value)) {\r\n\t\treturn value;\r\n\t}\r\n\tif (value != null) {\r\n\t\tconsole.warn(\"VelocityJS: Trying to set 'cache' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>begin</code> option.\r\n * @private\r\n */\r\nfunction validateBegin(value: VelocityCallback): VelocityCallback {\r\n\tif (isFunction(value)) {\r\n\t\treturn value;\r\n\t}\r\n\tif (value != null) {\r\n\t\tconsole.warn(\"VelocityJS: Trying to set 'begin' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>complete</code> option.\r\n * @private\r\n */\r\nfunction validateComplete(value: VelocityCallback, noError?: true): VelocityCallback {\r\n\tif (isFunction(value)) {\r\n\t\treturn value;\r\n\t}\r\n\tif (value != null && !noError) {\r\n\t\tconsole.warn(\"VelocityJS: Trying to set 'complete' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>delay</code> option.\r\n * @private\r\n */\r\nfunction validateDelay(value: \"fast\" | \"normal\" | \"slow\" | number): number {\r\n\tconst parsed = parseDuration(value);\r\n\r\n\tif (!isNaN(parsed)) {\r\n\t\treturn parsed;\r\n\t}\r\n\tif (value != null) {\r\n\t\tconsole.error(\"VelocityJS: Trying to set 'delay' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>duration</code> option.\r\n * @private\r\n */\r\nfunction validateDuration(value: \"fast\" | \"normal\" | \"slow\" | number, noError?: true): number {\r\n\tconst parsed = parseDuration(value);\r\n\r\n\tif (!isNaN(parsed) && parsed >= 0) {\r\n\t\treturn parsed;\r\n\t}\r\n\tif (value != null && !noError) {\r\n\t\tconsole.error(\"VelocityJS: Trying to set 'duration' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>easing</code> option.\r\n * @private\r\n */\r\nfunction validateEasing(value: VelocityEasingType, duration: number, noError?: true): VelocityEasingFn {\r\n\tconst Easing = VelocityStatic.Easing;\r\n\r\n\tif (isString(value)) {\r\n\t\t// Named easing\r\n\t\treturn Easing.Easings[value];\r\n\t}\r\n\tif (isFunction(value)) {\r\n\t\treturn value;\r\n\t}\r\n\tif (Array.isArray(value)) {\r\n\t\tif (value.length === 1) {\r\n\t\t\t// Steps\r\n\t\t\treturn Easing.generateStep(value[0]);\r\n\t\t}\r\n\t\tif (value.length === 2) {\r\n\t\t\t// springRK4 must be passed the animation's duration.\r\n\t\t\t// Note: If the springRK4 array contains non-numbers,\r\n\t\t\t// generateSpringRK4() returns an easing function generated with\r\n\t\t\t// default tension and friction values.\r\n\t\t\treturn Easing.generateSpringRK4(value[0], value[1], duration);\r\n\t\t}\r\n\t\tif (value.length === 4) {\r\n\t\t\t// Note: If the bezier array contains non-numbers, generateBezier()\r\n\t\t\t// returns undefined.\r\n\t\t\treturn Easing.generateBezier.apply(null, value) || false;\r\n\t\t}\r\n\t}\r\n\tif (value != null && !noError) {\r\n\t\tconsole.error(\"VelocityJS: Trying to set 'easing' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>fpsLimit</code> option.\r\n * @private\r\n */\r\nfunction validateFpsLimit(value: number | false): number {\r\n\tif (value === false) {\r\n\t\treturn 0;\r\n\t} else {\r\n\t\tconst parsed = parseInt(value as any, 10);\r\n\r\n\t\tif (!isNaN(parsed) && parsed >= 0) {\r\n\t\t\treturn Math.min(parsed, 60);\r\n\t\t}\r\n\t}\r\n\tif (value != null) {\r\n\t\tconsole.warn(\"VelocityJS: Trying to set 'fpsLimit' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n\r\n/**\r\n * Validate a <code>loop</code> option.\r\n * @private\r\n */\r\nfunction validateLoop(value: number | boolean): number | true {\r\n\tif (value === false) {\r\n\t\treturn 0;\r\n\t} else if (value === true) {\r\n\t\treturn true;\r\n\t} else {\r\n\t\tconst parsed = parseInt(value as any, 10);\r\n\r\n\t\tif (!isNaN(parsed) && parsed >= 0) {\r\n\t\t\treturn parsed;\r\n\t\t}\r\n\t}\r\n\tif (value != null) {\r\n\t\tconsole.warn(\"VelocityJS: Trying to set 'loop' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>progress</code> option.\r\n * @private\r\n */\r\nfunction validateProgress(value: VelocityProgress): VelocityProgress {\r\n\tif (isFunction(value)) {\r\n\t\treturn value;\r\n\t}\r\n\tif (value != null) {\r\n\t\tconsole.warn(\"VelocityJS: Trying to set 'progress' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>promise</code> option.\r\n * @private\r\n */\r\nfunction validatePromise(value: boolean): boolean {\r\n\tif (isBoolean(value)) {\r\n\t\treturn value;\r\n\t}\r\n\tif (value != null) {\r\n\t\tconsole.warn(\"VelocityJS: Trying to set 'promise' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>promiseRejectEmpty</code> option.\r\n * @private\r\n */\r\nfunction validatePromiseRejectEmpty(value: boolean): boolean {\r\n\tif (isBoolean(value)) {\r\n\t\treturn value;\r\n\t}\r\n\tif (value != null) {\r\n\t\tconsole.warn(\"VelocityJS: Trying to set 'promiseRejectEmpty' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>queue</code> option.\r\n * @private\r\n */\r\nfunction validateQueue(value: string | false, noError?: true): string | false {\r\n\tif (value === false || isString(value)) {\r\n\t\treturn value;\r\n\t}\r\n\tif (value != null && !noError) {\r\n\t\tconsole.warn(\"VelocityJS: Trying to set 'queue' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>repeat</code> option.\r\n * @private\r\n */\r\nfunction validateRepeat(value: number | boolean): number | true {\r\n\tif (value === false) {\r\n\t\treturn 0;\r\n\t} else if (value === true) {\r\n\t\treturn true;\r\n\t} else {\r\n\t\tconst parsed = parseInt(value as any, 10);\r\n\r\n\t\tif (!isNaN(parsed) && parsed >= 0) {\r\n\t\t\treturn parsed;\r\n\t\t}\r\n\t}\r\n\tif (value != null) {\r\n\t\tconsole.warn(\"VelocityJS: Trying to set 'repeat' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>speed</code> option.\r\n * @private\r\n */\r\nfunction validateSpeed(value: number): number {\r\n\tif (isNumber(value)) {\r\n\t\treturn value;\r\n\t}\r\n\tif (value != null) {\r\n\t\tconsole.error(\"VelocityJS: Trying to set 'speed' to an invalid value:\", value);\r\n\t}\r\n}\r\n\r\n/**\r\n * Validate a <code>sync</code> option.\r\n * @private\r\n */\r\nfunction validateSync(value: boolean): boolean {\r\n\tif (isBoolean(value)) {\r\n\t\treturn value;\r\n\t}\r\n\tif (value != null) {\r\n\t\tconsole.error(\"VelocityJS: Trying to set 'sync' to an invalid value:\", value);\r\n\t}\r\n}\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n * \r\n * Velocity version (should grab from package.json during build).\r\n */\r\n\r\nnamespace VelocityStatic {\r\n\texport let version = \"2.0.2\";\r\n};\r\n","/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n *\r\n * Core \"Velocity\" function.\r\n */\r\n\r\ninterface Document {\r\n\tdocumentMode: any; // IE\r\n}\r\n\r\n/**\r\n * The main Velocity function. Acts as a gateway to everything else.\r\n */\r\nfunction VelocityFn(options: VelocityObjectArgs): VelocityResult;\r\nfunction VelocityFn(elements: VelocityElements, propertyMap: string | VelocityProperties, options?: VelocityOptions): VelocityResult;\r\nfunction VelocityFn(elements: VelocityElements, propertyMap: string | VelocityProperties, duration?: number | \"fast\" | \"normal\" | \"slow\", complete?: () => void): VelocityResult;\r\nfunction VelocityFn(elements: VelocityElements, propertyMap: string | VelocityProperties, complete?: () => void): VelocityResult;\r\nfunction VelocityFn(elements: VelocityElements, propertyMap: string | VelocityProperties, easing?: string | number[], complete?: () => void): VelocityResult;\r\nfunction VelocityFn(elements: VelocityElements, propertyMap: string | VelocityProperties, duration?: number | \"fast\" | \"normal\" | \"slow\", easing?: string | number[], complete?: () => void): VelocityResult;\r\nfunction VelocityFn(this: VelocityElements, propertyMap: string | VelocityProperties, duration?: number | \"fast\" | \"normal\" | \"slow\", complete?: () => void): VelocityResult;\r\nfunction VelocityFn(this: VelocityElements, propertyMap: string | VelocityProperties, complete?: () => void): VelocityResult;\r\nfunction VelocityFn(this: VelocityElements, propertyMap: string | VelocityProperties, easing?: string | number[], complete?: () => void): VelocityResult;\r\nfunction VelocityFn(this: VelocityElements, propertyMap: string | VelocityProperties, duration?: number | \"fast\" | \"normal\" | \"slow\", easing?: string | number[], complete?: () => void): VelocityResult;\r\nfunction VelocityFn(this: VelocityElements | void, ...__args: any[]): VelocityResult {\r\n\tconst\r\n\t\t/**\r\n\t\t * A shortcut to the default options.\r\n\t\t */\r\n\t\tdefaults = VelocityStatic.defaults,\r\n\t\t/**\r\n\t\t * Shortcut to arguments for file size.\r\n\t\t */\r\n\t\t_arguments = arguments,\r\n\t\t/**\r\n\t\t * Cache of the first argument - this is used often enough to be saved.\r\n\t\t */\r\n\t\targs0 = _arguments[0] as VelocityObjectArgs,\r\n\t\t/**\r\n\t\t * To allow for expressive CoffeeScript code, Velocity supports an\r\n\t\t * alternative syntax in which \"elements\" (or \"e\"), \"properties\" (or\r\n\t\t * \"p\"), and \"options\" (or \"o\") objects are defined on a container\r\n\t\t * object that's passed in as Velocity's sole argument.\r\n\t\t *\r\n\t\t * Note: Some browsers automatically populate arguments with a\r\n\t\t * \"properties\" object. We detect it by checking for its default\r\n\t\t * \"names\" property.\r\n\t\t */\r\n\t\t// TODO: Confirm which browsers - if <=IE8 the we can drop completely\r\n\t\tsyntacticSugar = isPlainObject(args0) && (args0.p || ((isPlainObject(args0.properties) && !(args0.properties as any).names) || isString(args0.properties)));\r\n\tlet\r\n\t\t/**\r\n\t\t *  When Velocity is called via the utility function (Velocity()),\r\n\t\t * elements are explicitly passed in as the first parameter. Thus,\r\n\t\t * argument positioning varies.\r\n\t\t */\r\n\t\targumentIndex: number = 0,\r\n\t\t/**\r\n\t\t * The list of elements, extended with Promise and Velocity.\r\n\t\t */\r\n\t\telements: VelocityResult,\r\n\t\t/**\r\n\t\t * The properties being animated. This can be a string, in which case it\r\n\t\t * is either a function for these elements, or it is a \"named\" animation\r\n\t\t * sequence to use instead. Named sequences start with either \"callout.\"\r\n\t\t * or \"transition.\". When used as a callout the values will be reset\r\n\t\t * after finishing. When used as a transtition then there is no special\r\n\t\t * handling after finishing.\r\n\t\t */\r\n\t\tpropertiesMap: string | VelocityProperties,\r\n\t\t/**\r\n\t\t * Options supplied, this will be mapped and validated into\r\n\t\t * <code>options</code>.\r\n\t\t */\r\n\t\toptionsMap: VelocityOptions,\r\n\t\t/**\r\n\t\t * If called via a chain then this contains the <b>last</b> calls\r\n\t\t * animations. If this does not have a value then any access to the\r\n\t\t * element's animations needs to be to the currently-running ones.\r\n\t\t */\r\n\t\tanimations: AnimationCall[],\r\n\t\t/**\r\n\t\t * The promise that is returned.\r\n\t\t */\r\n\t\tpromise: Promise<VelocityResult>,\r\n\t\t// Used when the animation is finished\r\n\t\tresolver: (value?: VelocityResult) => void,\r\n\t\t// Used when there was an issue with one or more of the Velocity arguments\r\n\t\trejecter: (reason: any) => void;\r\n\r\n\t//console.log(\"Velocity\", _arguments)\r\n\t// First get the elements, and the animations connected to the last call if\r\n\t// this is chained.\r\n\t// TODO: Clean this up a bit\r\n\t// TODO: Throw error if the chain is called with elements as the first argument. isVelocityResult(this) && ( (isNode(arg0) || isWrapped(arg0)) && arg0 == this)\r\n\tif (isNode(this)) {\r\n\t\t// This is from a chain such as document.getElementById(\"\").velocity(...)\r\n\t\telements = [this as HTMLorSVGElement] as VelocityResult;\r\n\t} else if (isWrapped(this)) {\r\n\t\t// This might be a chain from something else, but if chained from a\r\n\t\t// previous Velocity() call then grab the animations it's related to.\r\n\t\telements = Object.assign([], this as HTMLorSVGElement[]) as VelocityResult;\r\n\t\tif (isVelocityResult(this)) {\r\n\t\t\tanimations = (this as VelocityResult).velocity.animations;\r\n\t\t}\r\n\t} else if (syntacticSugar) {\r\n\t\telements = Object.assign([], args0.elements || args0.e) as VelocityResult;\r\n\t\targumentIndex++;\r\n\t} else if (isNode(args0)) {\r\n\t\telements = Object.assign([], [args0]) as VelocityResult;\r\n\t\targumentIndex++;\r\n\t} else if (isWrapped(args0)) {\r\n\t\telements = Object.assign([], args0) as VelocityResult;\r\n\t\targumentIndex++;\r\n\t}\r\n\t// Allow elements to be chained.\r\n\tif (elements) {\r\n\t\tdefineProperty(elements, \"velocity\", VelocityFn.bind(elements));\r\n\t\tif (animations) {\r\n\t\t\tdefineProperty(elements.velocity, \"animations\", animations);\r\n\t\t}\r\n\t}\r\n\t// Next get the propertiesMap and options.\r\n\tif (syntacticSugar) {\r\n\t\tpropertiesMap = getValue(args0.properties, args0.p);\r\n\t} else {\r\n\t\t// TODO: Should be possible to call Velocity(\"pauseAll\") - currently not possible\r\n\t\tpropertiesMap = _arguments[argumentIndex++] as string | VelocityProperties;\r\n\t}\r\n\t// Get any options map passed in as arguments first, expand any direct\r\n\t// options if possible.\r\n\tconst isReverse = propertiesMap === \"reverse\",\r\n\t\tisAction = !isReverse && isString(propertiesMap),\r\n\t\topts = syntacticSugar ? getValue(args0.options, args0.o) : _arguments[argumentIndex];\r\n\r\n\tif (isPlainObject(opts)) {\r\n\t\toptionsMap = opts;\r\n\t}\r\n\t// Create the promise if supported and wanted.\r\n\tif (Promise && getValue(optionsMap && optionsMap.promise, defaults.promise)) {\r\n\t\tpromise = new Promise(function(_resolve, _reject) {\r\n\t\t\trejecter = _reject;\r\n\t\t\t// IMPORTANT:\r\n\t\t\t// If a resolver tries to run on a Promise then it will wait until\r\n\t\t\t// that Promise resolves - but in this case we're running on our own\r\n\t\t\t// Promise, so need to make sure it's not seen as one. Setting these\r\n\t\t\t// values to <code>undefined</code> for the duration of the resolve.\r\n\t\t\t// Due to being an async call, they should be back to \"normal\"\r\n\t\t\t// before the <code>.then()</code> function gets called.\r\n\t\t\tresolver = function(args: VelocityResult) {\r\n\t\t\t\tif (isVelocityResult(args)) {\r\n\t\t\t\t\tconst _then = args && args.then;\r\n\r\n\t\t\t\t\tif (_then) {\r\n\t\t\t\t\t\targs.then = undefined; // Preserving enumeration etc\r\n\t\t\t\t\t}\r\n\t\t\t\t\t_resolve(args);\r\n\t\t\t\t\tif (_then) {\r\n\t\t\t\t\t\targs.then = _then;\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\t_resolve(args);\r\n\t\t\t\t}\r\n\t\t\t};\r\n\t\t});\r\n\t\tif (elements) {\r\n\t\t\tdefineProperty(elements, \"then\", promise.then.bind(promise));\r\n\t\t\tdefineProperty(elements, \"catch\", promise.catch.bind(promise));\r\n\t\t\tif ((promise as any).finally) {\r\n\t\t\t\t// Semi-standard\r\n\t\t\t\tdefineProperty(elements, \"finally\", (promise as any).finally.bind(promise));\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\tconst promiseRejectEmpty: boolean = getValue(optionsMap && optionsMap.promiseRejectEmpty, defaults.promiseRejectEmpty);\r\n\r\n\tif (promise) {\r\n\t\tif (!elements && !isAction) {\r\n\t\t\tif (promiseRejectEmpty) {\r\n\t\t\t\trejecter(\"Velocity: No elements supplied, if that is deliberate then pass `promiseRejectEmpty:false` as an option. Aborting.\");\r\n\t\t\t} else {\r\n\t\t\t\tresolver();\r\n\t\t\t}\r\n\t\t} else if (!propertiesMap) {\r\n\t\t\tif (promiseRejectEmpty) {\r\n\t\t\t\trejecter(\"Velocity: No properties supplied, if that is deliberate then pass `promiseRejectEmpty:false` as an option. Aborting.\");\r\n\t\t\t} else {\r\n\t\t\t\tresolver();\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\tif ((!elements && !isAction) || !propertiesMap) {\r\n\t\treturn promise as any;\r\n\t}\r\n\r\n\t// NOTE: Can't use isAction here due to type inference - there are callbacks\r\n\t// between so the type isn't considered safe.\r\n\tif (isAction) {\r\n\t\tconst args: any[] = [],\r\n\t\t\tpromiseHandler: VelocityPromise = promise && {\r\n\t\t\t\t_promise: promise,\r\n\t\t\t\t_resolver: resolver,\r\n\t\t\t\t_rejecter: rejecter\r\n\t\t\t};\r\n\r\n\t\twhile (argumentIndex < _arguments.length) {\r\n\t\t\targs.push(_arguments[argumentIndex++]);\r\n\t\t}\r\n\r\n\t\t// Velocity's behavior is categorized into \"actions\". If a string is\r\n\t\t// passed in instead of a propertiesMap then that will call a function\r\n\t\t// to do something special to the animation linked.\r\n\t\t// There is one special case - \"reverse\" - which is handled differently,\r\n\t\t// by being stored on the animation and then expanded when the animation\r\n\t\t// starts.\r\n\t\tconst action = (propertiesMap as string).replace(/\\..*$/, \"\"),\r\n\t\t\tcallback = VelocityStatic.Actions[action] || VelocityStatic.Actions[\"default\"];\r\n\r\n\t\tif (callback) {\r\n\t\t\tconst result = callback(args, elements, promiseHandler, propertiesMap as string);\r\n\r\n\t\t\tif (result !== undefined) {\r\n\t\t\t\treturn result;\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tconsole.warn(\"VelocityJS: Unknown action:\", propertiesMap);\r\n\t\t}\r\n\t} else if (isPlainObject(propertiesMap) || isReverse) {\r\n\t\t/**\r\n\t\t * The options for this set of animations.\r\n\t\t */\r\n\t\tconst options: StrictVelocityOptions = {};\r\n\t\tlet isSync = defaults.sync;\r\n\r\n\t\t// Private options first - set as non-enumerable, and starting with an\r\n\t\t// underscore so we can filter them out.\r\n\t\tif (promise) {\r\n\t\t\tdefineProperty(options, \"_promise\", promise);\r\n\t\t\tdefineProperty(options, \"_rejecter\", rejecter);\r\n\t\t\tdefineProperty(options, \"_resolver\", resolver);\r\n\t\t}\r\n\t\tdefineProperty(options, \"_ready\", 0);\r\n\t\tdefineProperty(options, \"_started\", 0);\r\n\t\tdefineProperty(options, \"_completed\", 0);\r\n\t\tdefineProperty(options, \"_total\", 0);\r\n\r\n\t\t// Now check the optionsMap\r\n\t\tif (isPlainObject(optionsMap)) {\r\n\t\t\toptions.duration = getValue(validateDuration(optionsMap.duration), defaults.duration);\r\n\t\t\toptions.delay = getValue(validateDelay(optionsMap.delay), defaults.delay);\r\n\t\t\t// Need the extra fallback here in case it supplies an invalid\r\n\t\t\t// easing that we need to overrride with the default.\r\n\t\t\toptions.easing = validateEasing(getValue(optionsMap.easing, defaults.easing), options.duration) || validateEasing(defaults.easing, options.duration);\r\n\t\t\toptions.loop = getValue(validateLoop(optionsMap.loop), defaults.loop);\r\n\t\t\toptions.repeat = options.repeatAgain = getValue(validateRepeat(optionsMap.repeat), defaults.repeat);\r\n\t\t\tif (optionsMap.speed != null) {\r\n\t\t\t\toptions.speed = getValue(validateSpeed(optionsMap.speed), 1);\r\n\t\t\t}\r\n\t\t\tif (isBoolean(optionsMap.promise)) {\r\n\t\t\t\toptions.promise = optionsMap.promise;\r\n\t\t\t}\r\n\t\t\toptions.queue = getValue(validateQueue(optionsMap.queue), defaults.queue);\r\n\t\t\tif (optionsMap.mobileHA && !VelocityStatic.State.isGingerbread) {\r\n\t\t\t\t/* When set to true, and if this is a mobile device, mobileHA automatically enables hardware acceleration (via a null transform hack)\r\n\t\t\t\t on animating elements. HA is removed from the element at the completion of its animation. */\r\n\t\t\t\t/* 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. */\r\n\t\t\t\t/* Note: You can read more about the use of mobileHA in Velocity's documentation: VelocityJS.org/#mobileHA. */\r\n\t\t\t\toptions.mobileHA = true;\r\n\t\t\t}\r\n\t\t\tif (!isReverse) {\r\n\t\t\t\tif (optionsMap.display != null) {\r\n\t\t\t\t\t(propertiesMap as VelocityProperties).display = optionsMap.display as string;\r\n\t\t\t\t\tconsole.error(\"Deprecated 'options.display' used, this is now a property:\", optionsMap.display);\r\n\t\t\t\t}\r\n\t\t\t\tif (optionsMap.visibility != null) {\r\n\t\t\t\t\t(propertiesMap as VelocityProperties).visibility = optionsMap.visibility as string;\r\n\t\t\t\t\tconsole.error(\"Deprecated 'options.visibility' used, this is now a property:\", optionsMap.visibility);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t// TODO: Allow functional options for different options per element\r\n\t\t\tconst optionsBegin = validateBegin(optionsMap.begin),\r\n\t\t\t\toptionsComplete = validateComplete(optionsMap.complete),\r\n\t\t\t\toptionsProgress = validateProgress(optionsMap.progress),\r\n\t\t\t\toptionsSync = validateSync(optionsMap.sync);\r\n\r\n\t\t\tif (optionsBegin != null) {\r\n\t\t\t\toptions.begin = optionsBegin;\r\n\t\t\t}\r\n\t\t\tif (optionsComplete != null) {\r\n\t\t\t\toptions.complete = optionsComplete;\r\n\t\t\t}\r\n\t\t\tif (optionsProgress != null) {\r\n\t\t\t\toptions.progress = optionsProgress;\r\n\t\t\t}\r\n\t\t\tif (optionsSync != null) {\r\n\t\t\t\tisSync = optionsSync;\r\n\t\t\t}\r\n\t\t} else if (!syntacticSugar) {\r\n\t\t\t// Expand any direct options if possible.\r\n\t\t\tconst duration = validateDuration(_arguments[argumentIndex], true);\r\n\t\t\tlet offset = 0;\r\n\r\n\t\t\tif (duration !== undefined) {\r\n\t\t\t\toffset++;\r\n\t\t\t\toptions.duration = duration;\r\n\t\t\t}\r\n\t\t\tif (!isFunction(_arguments[argumentIndex + offset])) {\r\n\t\t\t\t// Despite coming before Complete, we can't pass a fn easing\r\n\t\t\t\tconst easing = validateEasing(_arguments[argumentIndex + offset], getValue(options && validateDuration(options.duration), defaults.duration) as number, true);\r\n\r\n\t\t\t\tif (easing !== undefined) {\r\n\t\t\t\t\toffset++;\r\n\t\t\t\t\toptions.easing = easing;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tconst complete = validateComplete(_arguments[argumentIndex + offset], true);\r\n\r\n\t\t\tif (complete !== undefined) {\r\n\t\t\t\toptions.complete = complete;\r\n\t\t\t}\r\n\t\t\toptions.loop = defaults.loop;\r\n\t\t\toptions.repeat = options.repeatAgain = defaults.repeat;\r\n\t\t}\r\n\r\n\t\tif (isReverse && options.queue === false) {\r\n\t\t\tthrow new Error(\"VelocityJS: Cannot reverse a queue:false animation.\");\r\n\t\t}\r\n\r\n\t\t/* When a set of elements is targeted by a Velocity call, the set is broken up and each element has the current Velocity call individually queued onto it.\r\n\t\t In this way, each element's existing queue is respected; some elements may already be animating and accordingly should not have this current Velocity call triggered immediately. */\r\n\t\t/* In each queue, tween data is processed for each animating property then pushed onto the call-wide calls array. When the last element in the set has had its tweens processed,\r\n\t\t the call array is pushed to VelocityStatic.State.calls for live processing by the requestAnimationFrame tick. */\r\n\r\n\t\tconst rootAnimation: AnimationCall = {\r\n\t\t\t_prev: undefined,\r\n\t\t\t_next: undefined,\r\n\t\t\t_flags: isSync ? AnimationFlags.SYNC : 0,\r\n\t\t\toptions: options,\r\n\t\t\tpercentComplete: 0,\r\n\t\t\t//element: element,\r\n\t\t\telements: elements,\r\n\t\t\tellapsedTime: 0,\r\n\t\t\ttimeStart: 0\r\n\t\t};\r\n\r\n\t\tanimations = [];\r\n\t\tfor (let index = 0; index < elements.length; index++) {\r\n\t\t\tconst element = elements[index];\r\n\t\t\tlet flags = 0;\r\n\r\n\t\t\tif (isNode(element)) { // TODO: This needs to check for valid animation targets, not just Elements\r\n\t\t\t\tif (isReverse) {\r\n\t\t\t\t\tconst lastAnimation = Data(element).lastAnimationList[options.queue as string];\r\n\r\n\t\t\t\t\tpropertiesMap = lastAnimation && lastAnimation.tweens;\r\n\t\t\t\t\tif (!propertiesMap) {\r\n\t\t\t\t\t\tconsole.error(\"VelocityJS: Attempting to reverse an animation on an element with no previous animation:\", element);\r\n\t\t\t\t\t\tcontinue;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tflags |= AnimationFlags.REVERSE & ~(lastAnimation._flags & AnimationFlags.REVERSE);\r\n\t\t\t\t}\r\n\t\t\t\tconst tweens = createEmptyObject(),\r\n\t\t\t\t\tanimation: AnimationCall = Object.assign({\r\n\t\t\t\t\t\telement: element,\r\n\t\t\t\t\t\ttweens: tweens\r\n\t\t\t\t\t}, rootAnimation);\r\n\r\n\t\t\t\toptions._total++;\r\n\t\t\t\tanimation._flags |= flags;\r\n\t\t\t\tanimations.push(animation);\r\n\t\t\t\tif (isReverse) {\r\n\t\t\t\t\t// In this case we're using the previous animation, so\r\n\t\t\t\t\t// it will be expanded correctly when that one runs.\r\n\t\t\t\t\tanimation.tweens = propertiesMap as any;\r\n\t\t\t\t} else {\r\n\t\t\t\t\tVelocityStatic.expandProperties(animation, propertiesMap);\r\n\t\t\t\t}\r\n\t\t\t\tVelocityStatic.queue(element, animation, options.queue);\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (VelocityStatic.State.isTicking === false) {\r\n\t\t\t// If the animation tick isn't running, start it. (Velocity shuts it\r\n\t\t\t// off when there are no active calls to process.)\r\n\t\t\tVelocityStatic.tick();\r\n\t\t}\r\n\t\tif (animations) {\r\n\t\t\tdefineProperty(elements.velocity, \"animations\", animations);\r\n\t\t}\r\n\t}\r\n\t/***************\r\n\t Chaining\r\n\t ***************/\r\n\r\n\t/* Return the elements back to the call chain, with wrapped elements taking precedence in case Velocity was called via the $.fn. extension. */\r\n\treturn elements || promise as any;\r\n};\r\n\r\n\r\n/***************\r\n Summary\r\n ***************/\r\n\r\n/*\r\n - CSS: CSS stack that works independently from the rest of Velocity.\r\n - animate(): Core animation method that iterates over the targeted elements and queues the incoming call onto each element individually.\r\n - Pre-Queueing: Prepare the element for animation by instantiating its data cache and processing the call's options.\r\n - Queueing: The logic that runs once the call has reached its point of execution in the element's queue stack.\r\n Most logic is placed here to avoid risking it becoming stale (if the element's properties have changed).\r\n - Pushing: Consolidation of the tween data followed by its push onto the global in-progress calls container.\r\n - tick(): The single requestAnimationFrame loop responsible for tweening all in-progress calls.\r\n - completeCall(): Handles the cleanup process for each Velocity call.\r\n */\r\n\r\n/*********************\r\n Helper Functions\r\n *********************/\r\n\r\n/* IE detection. Gist: https://gist.github.com/julianshapiro/9098609 */\r\nvar IE = (function() {\r\n\tif (document.documentMode) {\r\n\t\treturn document.documentMode;\r\n\t} else {\r\n\t\tfor (let i = 7; i > 4; i--) {\r\n\t\t\tlet div = document.createElement(\"div\");\r\n\r\n\t\t\tdiv.innerHTML = \"<!--[if IE \" + i + \"]><span></span><![endif]-->\";\r\n\t\t\tif (div.getElementsByTagName(\"span\").length) {\r\n\t\t\t\tdiv = null;\r\n\t\t\t\treturn i;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\treturn undefined;\r\n})();\r\n\r\n/******************\r\n Unsupported\r\n ******************/\r\n\r\nif (IE <= 8) {\r\n\tthrow new Error(\"VelocityJS cannot run on Internet Explorer 8 or earlier\");\r\n}\r\n\r\n/******************\r\n Frameworks\r\n ******************/\r\n\r\ninterface Window {\r\n\tjQuery: {fn?: any};\r\n\tZepto: {fn?: any};\r\n\tVelocity: any;\r\n}\r\n\r\nif (window === this) {\r\n\t/*\r\n\t * Both jQuery and Zepto allow their $.fn object to be extended to allow\r\n\t * wrapped elements to be subjected to plugin calls. If either framework is\r\n\t * loaded, register a \"velocity\" extension pointing to Velocity's core\r\n\t * animate() method. Velocity also registers itself onto a global container\r\n\t * (window.jQuery || window.Zepto || window) so that certain features are\r\n\t * accessible beyond just a per-element scope. Accordingly, Velocity can\r\n\t * both act on wrapped DOM elements and stand alone for targeting raw DOM\r\n\t * elements.\r\n\t */\r\n\tconst patch = VelocityStatic.patch,\r\n\t\tjQuery = window.jQuery,\r\n\t\tZepto = window.Zepto;\r\n\r\n\tpatch(window, true);\r\n\tpatch(Element && Element.prototype);\r\n\tpatch(NodeList && NodeList.prototype);\r\n\tpatch(HTMLCollection && HTMLCollection.prototype);\r\n\r\n\tpatch(jQuery, true);\r\n\tpatch(jQuery && jQuery.fn);\r\n\r\n\tpatch(Zepto, true);\r\n\tpatch(Zepto && Zepto.fn);\r\n}\r\n\r\n/******************\r\n Known Issues\r\n ******************/\r\n\r\n/* The CSS spec mandates that the translateX/Y/Z transforms are %-relative to the element itself -- not its parent.\r\n Velocity, however, doesn't make this distinction. Thus, converting to or from the % unit with these subproperties\r\n will produce an inaccurate conversion value. The same issue exists with the cx/cy attributes of SVG circles and ellipses. */\r\n","///<reference path=\"../index.d.ts\" />\r\n///<reference path=\"constants.ts\" />\r\n///<reference path=\"types.ts\" />\r\n///<reference path=\"utility.ts\" />\r\n///<reference path=\"Velocity/_all.d.ts\" />\r\n///<reference path=\"core.ts\" />\r\n/*\r\n * VelocityJS.org (C) 2014-2017 Julian Shapiro.\r\n *\r\n * Licensed under the MIT license. See LICENSE file in the project root for details.\r\n * \r\n * Merge the VelocityStatic namespace onto the Velocity function for external\r\n * use. This is done as a read-only way. Any attempt to change these values will\r\n * be allowed.\r\n */\r\nfor (const key in VelocityStatic) {\r\n\tlet value = VelocityStatic[key];\r\n\r\n\tif (isString(value) || isNumber(value) || isBoolean(value)) {\r\n\t\tObject.defineProperty(VelocityFn, key, {\r\n\t\t\tenumerable: PUBLIC_MEMBERS.indexOf(key) >= 0,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn VelocityStatic[key];\r\n\t\t\t},\r\n\t\t\tset: function(value?: any) {\r\n\t\t\t\tVelocityStatic[key] = value;\r\n\t\t\t}\r\n\t\t});\r\n\t} else {\r\n\t\tObject.defineProperty(VelocityFn, key, {\r\n\t\t\tenumerable: PUBLIC_MEMBERS.indexOf(key) >= 0,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn VelocityStatic[key];\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n}\r\n\r\n// console.log(\"Velocity keys\", Object.keys(VelocityStatic));\r\n"]}