{"version":3,"sources":["ixp-runtime.js"],"names":["window","document","undefined","_","apply","func","thisArg","args","length","call","arrayEach","array","iteratee","index","arrayIncludes","value","baseIndexOf","baseFindIndex","predicate","fromIndex","fromRight","strictIndexOf","baseIsNaN","baseTimes","n","result","Array","baseUnary","countHolders","placeholder","getValue","object","key","overArg","transform","arg","replaceHolders","resIndex","PLACEHOLDER","lodash","baseLodash","LazyWrapper","this","__wrapped__","__actions__","__dir__","__filtered__","__iteratees__","__takeCount__","MAX_ARRAY_LENGTH","__views__","arrayLikeKeys","inherited","isArr","isArray","isArg","isArguments","isBuff","isBuffer","isType","isTypedArray","skipIndexes","String","hasOwnProperty","isIndex","push","assignValue","objValue","eq","baseAssignValue","baseAssign","source","copyObject","keys","defineProperty","configurable","enumerable","writable","baseDelay","wait","TypeError","FUNC_ERROR_TEXT","setTimeout","baseGetTag","undefinedTag","nullTag","symToStringTag","Object","getRawTag","objectToString","baseIsArguments","isObjectLike","argsTag","baseIsNative","isObject","isMasked","pattern","isFunction","reIsNative","reIsHostCtor","test","toSource","baseIsTypedArray","isLength","typedArrayTags","baseKeys","isPrototype","nativeKeys","baseKeysIn","nativeKeysIn","isProto","baseRest","start","setToString","overRest","identity","composeArgs","partials","holders","isCurried","argsIndex","argsLength","holdersLength","leftIndex","leftLength","rangeLength","nativeMax","isUncurried","composeArgsRight","holdersIndex","rightIndex","rightLength","offset","copyArray","props","customizer","isNew","newValue","createAssigner","assigner","sources","guard","isIterateeCall","createBind","bitmask","wrapper","fn","root","Ctor","isBind","arguments","WRAP_BIND_FLAG","createCtor","thisBinding","baseCreate","prototype","createCurry","arity","getHolder","createRecurry","createHybrid","partialsRight","holdersRight","argPos","ary","holdersCount","newHolders","isBindKey","reorder","isFlip","reverse","isAry","WRAP_ARY_FLAG","WRAP_BIND_KEY_FLAG","WRAP_CURRY_FLAG","WRAP_CURRY_RIGHT_FLAG","WRAP_FLIP_FLAG","createPartial","wrapFunc","isCurry","newHoldersRight","newPartials","newPartialsRight","WRAP_PARTIAL_FLAG","WRAP_PARTIAL_RIGHT_FLAG","WRAP_CURRY_BOUND_FLAG","newData","isLaziable","setData","setWrapToString","createWrap","toInteger","data","getData","mergeData","setter","baseSetData","getFuncName","name","realNames","otherFunc","getNative","isOwn","tag","unmasked","e","nativeObjectToString","getWrapDetails","match","reWrapDetails","split","reSplitDetails","insertWrapDetails","details","lastIndex","join","replace","reWrapComment","type","MAX_SAFE_INTEGER","reIsUint","isArrayLike","funcName","other","maskSrcKey","constructor","proto","objectProto","srcBitmask","newBitmask","isCommon","isCombo","WRAP_REARG_FLAG","nativeMin","otherArgs","indexes","arrLength","oldArray","reference","updateWrapDetails","shortOut","count","lastCalled","stamp","nativeNow","remaining","HOT_SPAN","HOT_COUNT","funcToString","wrapFlags","pair","sort","debounce","options","invokeFunc","time","lastArgs","lastThis","lastInvokeTime","leadingEdge","timerId","timerExpired","leading","remainingWait","timeSinceLastCall","lastCallTime","timeSinceLastInvoke","timeWaiting","maxing","maxWait","shouldInvoke","now","trailingEdge","trailing","cancel","clearTimeout","flush","debounced","isInvoking","toNumber","throttle","funcTag","genTag","asyncTag","proxyTag","isString","stringTag","isSymbol","symbolTag","toFinite","INFINITY","sign","MAX_INTEGER","remainder","NAN","valueOf","reTrim","isBinary","reIsBinary","reIsOctal","freeParseInt","slice","reIsBadHex","create","properties","keysIn","constant","noop","stubFalse","VERSION","arrayTag","boolTag","dateTag","errorTag","mapTag","numberTag","objectTag","regexpTag","setTag","weakMapTag","arrayBufferTag","dataViewTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reRegExpChar","parseInt","freeGlobal","global","freeSelf","self","Function","freeExports","exports","nodeType","freeModule","module","moduleExports","freeProcess","process","nodeUtil","types","require","binding","nodeIsTypedArray","funcProto","coreJsData","toString","uid","exec","IE_PROTO","RegExp","Buffer","Symbol","objectCreate","propertyIsEnumerable","toStringTag","nativeIsBuffer","Math","max","min","Date","WeakMap","metaMap","set","baseSetToString","string","get","bind","defer","delay","partial","assign","assignIn","defaults","propsIndex","propsLength","extend","methodName","define","amd","$$utils$$objectOrFunction","x","$$utils$$isFunction","$$utils$$isMaybeThenable","$$utils$$F","$$asap$$useNextTick","nextTick","$$asap$$flush","$$asap$$useMutationObserver","iterations","observer","$$asap$$BrowserMutationObserver","node","createTextNode","observe","characterData","$$asap$$useMessageChannel","channel","MessageChannel","port1","onmessage","port2","postMessage","$$asap$$useSetTimeout","i","$$asap$$len","callback","$$asap$$queue","$$$internal$$noop","$$$internal$$selfFullfillment","$$$internal$$cannotReturnOwn","$$$internal$$getThen","promise","then","error","$$$internal$$GET_THEN_ERROR","$$$internal$$tryThen","fulfillmentHandler","rejectionHandler","$$$internal$$handleForeignThenable","thenable","$$asap$$default","sealed","$$$internal$$resolve","$$$internal$$fulfill","reason","$$$internal$$reject","_label","$$$internal$$handleOwnThenable","_state","$$$internal$$FULFILLED","_result","$$$internal$$REJECTED","$$$internal$$subscribe","$$$internal$$handleMaybeThenable","maybeThenable","$$$internal$$publishRejection","_onerror","$$$internal$$publish","$$$internal$$PENDING","_subscribers","parent","child","onFulfillment","onRejection","subscribers","settled","detail","$$$internal$$invokeCallback","$$$internal$$ErrorObject","$$$internal$$tryCatch","$$$internal$$TRY_CATCH_ERROR","succeeded","failed","hasCallback","$$$internal$$initializePromise","resolver","$$$enumerator$$Enumerator","Constructor","input","abortOnReject","label","_instanceConstructor","_abortOnReject","_validateInput","_input","_remaining","_init","_enumerate","_validationError","$$es6$promise$promise$$needsResolver","$$es6$promise$promise$$needsNew","$$es6$promise$promise$$Promise","_id","$$es6$promise$promise$$counter","$$utils$$_isArray","$$asap$$scheduleFlush","$$utils$$isArray","getTime","o","Error","$$asap$$browserGlobal","MutationObserver","WebKitMutationObserver","$$asap$$isWorker","Uint8ClampedArray","importScripts","$$$enumerator$$default","_eachEntry","entry","c","_settledAt","_willSettleAt","resolve","_makeResult","state","enumerator","$$promise$all$$default","entries","$$promise$race$$default","$$promise$resolve$$default","$$promise$reject$$default","$$es6$promise$promise$$default","all","race","reject","catch","$$es6$promise$polyfill$$default","local","es6PromiseSupport","Promise","r","es6$promise$umd$$ES6Promise","polyfill","ES6Promise","consoleOverride","overrideFn","con","assert","clear","debug","dir","dirxml","exception","group","groupCollapsed","groupEnd","info","log","markTimeline","profile","profileEnd","table","timeEnd","timeStamp","trace","warn","console","inStudio","LIVEBALL","inStudioLabs","App","features","labs","ixp","runtime","interactionsConfig","BULK_SIZE","AJAX_INTERVAL","interactionManager","readyQueue","isReady","ready","context","requestAnimationFrame","constants","screenSizes","xs","maxWidth","sm","minWidth","md","lg","flags","parseQueryString","qs","pl","search","decode","s","decodeURIComponent","ex","query","location","substring","queryString","isHttps","protocol","https","inDebug","studio","app","paths","cdnUrls","http","trimFrontSlash","str","trimEndSlash","trimSlashes","path","len","part","concat","getCdnPath","cdnPath","newPath","dependencies","components","componentDeps","modules","loading","_modules","_loading","compareVersions","v1","v2","v1Split","v2Split","num1","Number","num2","getSortedInstancesInfo","instances","getVersion","infos","instance","version","i1","i2","loadScript","url","script","createElement","head","getElementsByTagName","loaded","load","onreadystatechange","readyState","onload","onerror","src","appendChild","moduleLocator","defineOpts","requireOpts","findInstances","getInstanceVersion","minVer","maxVer","upToVersion","checkVersion","moduleLoader","doneFn","done","sync","found","getInstanceExport","err","fail","toLowerCase","loader","jQueryUrl","jQuery","v1_11","$","noConflict","jquery","$promise","initInteractionManager","events","subscriptions","_subscriptions","triggerEvents","listeners","ev","a1","a2","a3","l","ctx","on","once","me","off","names","namesLen","j","listenersLen","event","trigger","sender","filtered","promiseQueue","getRespondentId","compositeIdParts","id","ajax","config","async","JSON","stringify","dataType","contentType","cache","success","proxy","always","queue","next","cancellationError","$ajax","findElementByIxpAnchor","anchor","querySelectorAll","el","anchorMatch","els","attrSelector","getAttribute","attr","runScriptlet","scriptletId","ee","token","tokenId","runIntegration","integrationId","isScreenSizeXS","innerWidth","isScreenSizeSM","isScreenSizeMD","isScreenSizeLG","isHiddenByCSS","element","hasClass","convert","random","encodeURIComponent","getParentComponentData","$el","$parents","parents","parentData","each","$parent","getScrollToOffsetTop","scrollAdjustment","stickyStatuses","sendCommand","stickyStatus","sticksTo","isSticking","scrollTop","height","scrollToCore","$target","resolvePromise","onScrolled","visibility","recalculate","top","preventOffset","inViewport","isInViewport","speed","stop","scrollingEl","scrollingElement","documentElement","animate","duration","easing","scrollTo","anchorOrElement","targetEl","updateUrlHash","markAsConverted","getOffsetTop","resolveCompletionPromise","completionPromise","hash","newTarget","promiseChain","preventDefault","parentComponents","promises","results","resultLen","uploadInteractions","interactions","model","setModel","parseDataField","dataField","indexOf","field","parse","separator","triggerDataEvents","instanceId","saving","df","sd","saved","eventName","validation","current","failedValue","updateDataModel","saveDataCore","response","xhr","status","responseText","responseStatus","save","submit","dataToSave","requestType","urlSlug","isBulkSave","fields","fieldId","metadata","method","toUpperCase","respondentId","dom","listenerMap","passiveSupported","addEventListener","eventNames","attachEvent","passive","removeEventListener","detachEvent","isSvgElement","nodeName","getClassName","className","baseVal","addClass","removeClass","elementClassName","isSvg","readyBound","callbackQueue","registerOrRunCallback","DOMReadyCallback","shift","DOMContentLoaded","DOMReady","body","bindReady","toplevel","frameElement","doScroll","doScrollCheck","preventAnimations","visStates","visCssMap","scrollPrefix","css","awareness","inOnce","seen","microthemes","states","shown","hidden","entering","leaving","visPrefix","recalculating","change","awarenessDelay","awarenessSelector","parallax","parallaxSelector","getBoundingClientRect","rect","width","left","bottom","right","viewport","scrollLeft","round","ceil","windowHeight","innerHeight","clientHeight","windowWidth","clientWidth","tolerance","getComputedStyle","getPropertyValue","direction","inView","divisor","heightDivided","edge","appRoot","scrollAwareElements","parallaxElements","getScrollAwareElements","getParallaxElements","regex","getElements","inCalculateVisibility","inCalculateParallax","lastScrollTop","animationEndEvents","getScrollTop","isNaN","pageYOffset","clientTop","calculateVisibility","delta","force","vae","currentState","splice","onAnimationEnd","target","backgroundImageRegex","getNormalizedBackgroundPosition","pos","style","backgroundPosition","backgroundPositionX","backgroundPositionY","getParallaxImageDimensions","pe","backgroundImage","img","Image","calculateParallaxWithImageDimensions","y","calculateParallax","bgPos","charAt","parseFloat","calculate","reset","updateScreenResolution","screenResolution","screen","parallaxRegex","scrollAwareRegex","intervalId","setInterval","vent","clearInterval","recalcTimeout","subscribe","classes","interaction","triggerAttrSelector","runAction","action","targetAndName","lastIndexOf","stopPolling","onActionTrigger","$trigger","eventType","actions","$document","evt","scrollToHash","onHasChanging","onHashChange","hashMatch","nativeAnchorSupport","remove","ensureScrollToElement","anchors","sendBeacon","XMLHttpRequest","ActiveXObject","open","withCredentials","setRequestHeader","responseType","Blob","send","navigator"],"mappings":"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","file":"ixp-runtime.min.js","sourcesContent":["(function(window, document, undefined) {\n    /**\n     * @license\n     * Lodash (Custom Build) <https://lodash.com/>\n     * Build: `lodash include=\"assign,bind,create,debounce,defaults,defer,delay,keys,partial,throttle,extend,identity,isArguments,isArray,isFunction,isObject,isString,noop,now\" iife=\"var _ = (function() { %output% return lodash; }.call(this));\" --output lodash-1571398373585.build.js --development`\n     * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\n     * Released under MIT license <https://lodash.com/license>\n     * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n     * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n     */\n    var _ = (function() {\n        /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n        var undefined;\n\n        /** Used as the semantic version number. */\n        var VERSION = '4.17.21';\n\n        /** Error message constants. */\n        var FUNC_ERROR_TEXT = 'Expected a function';\n\n        /** Used as the internal argument placeholder. */\n        var PLACEHOLDER = '__lodash_placeholder__';\n\n        /** Used to compose bitmasks for function metadata. */\n        var WRAP_BIND_FLAG = 1,\n            WRAP_BIND_KEY_FLAG = 2,\n            WRAP_CURRY_BOUND_FLAG = 4,\n            WRAP_CURRY_FLAG = 8,\n            WRAP_CURRY_RIGHT_FLAG = 16,\n            WRAP_PARTIAL_FLAG = 32,\n            WRAP_PARTIAL_RIGHT_FLAG = 64,\n            WRAP_ARY_FLAG = 128,\n            WRAP_REARG_FLAG = 256,\n            WRAP_FLIP_FLAG = 512;\n\n        /** Used to detect hot functions by number of calls within a span of milliseconds. */\n        var HOT_COUNT = 800,\n            HOT_SPAN = 16;\n\n        /** Used as references for various `Number` constants. */\n        var INFINITY = 1 / 0,\n            MAX_SAFE_INTEGER = 9007199254740991,\n            MAX_INTEGER = 1.7976931348623157e+308,\n            NAN = 0 / 0;\n\n        /** Used as references for the maximum length and index of an array. */\n        var MAX_ARRAY_LENGTH = 4294967295;\n\n        /** Used to associate wrap methods with their bit flags. */\n        var wrapFlags = [\n            ['ary', WRAP_ARY_FLAG],\n            ['bind', WRAP_BIND_FLAG],\n            ['bindKey', WRAP_BIND_KEY_FLAG],\n            ['curry', WRAP_CURRY_FLAG],\n            ['curryRight', WRAP_CURRY_RIGHT_FLAG],\n            ['flip', WRAP_FLIP_FLAG],\n            ['partial', WRAP_PARTIAL_FLAG],\n            ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],\n            ['rearg', WRAP_REARG_FLAG]\n        ];\n\n        /** `Object#toString` result references. */\n        var argsTag = '[object Arguments]',\n            arrayTag = '[object Array]',\n            asyncTag = '[object AsyncFunction]',\n            boolTag = '[object Boolean]',\n            dateTag = '[object Date]',\n            errorTag = '[object Error]',\n            funcTag = '[object Function]',\n            genTag = '[object GeneratorFunction]',\n            mapTag = '[object Map]',\n            numberTag = '[object Number]',\n            nullTag = '[object Null]',\n            objectTag = '[object Object]',\n            proxyTag = '[object Proxy]',\n            regexpTag = '[object RegExp]',\n            setTag = '[object Set]',\n            stringTag = '[object String]',\n            symbolTag = '[object Symbol]',\n            undefinedTag = '[object Undefined]',\n            weakMapTag = '[object WeakMap]';\n\n        var arrayBufferTag = '[object ArrayBuffer]',\n            dataViewTag = '[object DataView]',\n            float32Tag = '[object Float32Array]',\n            float64Tag = '[object Float64Array]',\n            int8Tag = '[object Int8Array]',\n            int16Tag = '[object Int16Array]',\n            int32Tag = '[object Int32Array]',\n            uint8Tag = '[object Uint8Array]',\n            uint8ClampedTag = '[object Uint8ClampedArray]',\n            uint16Tag = '[object Uint16Array]',\n            uint32Tag = '[object Uint32Array]';\n\n        /**\n         * Used to match `RegExp`\n         * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n         */\n        var reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n        /** Used to match leading and trailing whitespace. */\n        var reTrim = /^\\s+|\\s+$/g;\n\n        /** Used to match wrap detail comments. */\n        var reWrapComment = /\\{(?:\\n\\/\\* \\[wrapped with .+\\] \\*\\/)?\\n?/,\n            reWrapDetails = /\\{\\n\\/\\* \\[wrapped with (.+)\\] \\*/,\n            reSplitDetails = /,? & /;\n\n        /** Used to detect bad signed hexadecimal string values. */\n        var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n        /** Used to detect binary string values. */\n        var reIsBinary = /^0b[01]+$/i;\n\n        /** Used to detect host constructors (Safari). */\n        var reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n        /** Used to detect octal string values. */\n        var reIsOctal = /^0o[0-7]+$/i;\n\n        /** Used to detect unsigned integer values. */\n        var reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n        /** Used to identify `toStringTag` values of typed arrays. */\n        var typedArrayTags = {};\n        typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\n            typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\n                typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\n                    typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\n                        typedArrayTags[uint32Tag] = true;\n        typedArrayTags[argsTag] = typedArrayTags[arrayTag] =\n            typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\n                typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\n                    typedArrayTags[errorTag] = typedArrayTags[funcTag] =\n                        typedArrayTags[mapTag] = typedArrayTags[numberTag] =\n                            typedArrayTags[objectTag] = typedArrayTags[regexpTag] =\n                                typedArrayTags[setTag] = typedArrayTags[stringTag] =\n                                    typedArrayTags[weakMapTag] = false;\n\n        /** Built-in method references without a dependency on `root`. */\n        var freeParseInt = parseInt;\n\n        /** Detect free variable `global` from Node.js. */\n        var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n        /** Detect free variable `self`. */\n        var freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n        /** Used as a reference to the global object. */\n        var root = freeGlobal || freeSelf || Function('return this')();\n\n        /** Detect free variable `exports`. */\n        var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n        /** Detect free variable `module`. */\n        var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n        /** Detect the popular CommonJS extension `module.exports`. */\n        var moduleExports = freeModule && freeModule.exports === freeExports;\n\n        /** Detect free variable `process` from Node.js. */\n        var freeProcess = moduleExports && freeGlobal.process;\n\n        /** Used to access faster Node.js helpers. */\n        var nodeUtil = (function() {\n            try {\n                // Use `util.types` for Node.js 10+.\n                var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n                if (types) {\n                    return types;\n                }\n\n                // Legacy `process.binding('util')` for Node.js < 10.\n                return freeProcess && freeProcess.binding && freeProcess.binding('util');\n            } catch (e) {}\n        }());\n\n        /* Node.js helper references. */\n        var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n        /*--------------------------------------------------------------------------*/\n\n        /**\n         * A faster alternative to `Function#apply`, this function invokes `func`\n         * with the `this` binding of `thisArg` and the arguments of `args`.\n         *\n         * @private\n         * @param {Function} func The function to invoke.\n         * @param {*} thisArg The `this` binding of `func`.\n         * @param {Array} args The arguments to invoke `func` with.\n         * @returns {*} Returns the result of `func`.\n         */\n        function apply(func, thisArg, args) {\n            switch (args.length) {\n                case 0: return func.call(thisArg);\n                case 1: return func.call(thisArg, args[0]);\n                case 2: return func.call(thisArg, args[0], args[1]);\n                case 3: return func.call(thisArg, args[0], args[1], args[2]);\n            }\n            return func.apply(thisArg, args);\n        }\n\n        /**\n         * A specialized version of `_.forEach` for arrays without support for\n         * iteratee shorthands.\n         *\n         * @private\n         * @param {Array} [array] The array to iterate over.\n         * @param {Function} iteratee The function invoked per iteration.\n         * @returns {Array} Returns `array`.\n         */\n        function arrayEach(array, iteratee) {\n            var index = -1,\n                length = array == null ? 0 : array.length;\n\n            while (++index < length) {\n                if (iteratee(array[index], index, array) === false) {\n                    break;\n                }\n            }\n            return array;\n        }\n\n        /**\n         * A specialized version of `_.includes` for arrays without support for\n         * specifying an index to search from.\n         *\n         * @private\n         * @param {Array} [array] The array to inspect.\n         * @param {*} target The value to search for.\n         * @returns {boolean} Returns `true` if `target` is found, else `false`.\n         */\n        function arrayIncludes(array, value) {\n            var length = array == null ? 0 : array.length;\n            return !!length && baseIndexOf(array, value, 0) > -1;\n        }\n\n        /**\n         * The base implementation of `_.findIndex` and `_.findLastIndex` without\n         * support for iteratee shorthands.\n         *\n         * @private\n         * @param {Array} array The array to inspect.\n         * @param {Function} predicate The function invoked per iteration.\n         * @param {number} fromIndex The index to search from.\n         * @param {boolean} [fromRight] Specify iterating from right to left.\n         * @returns {number} Returns the index of the matched value, else `-1`.\n         */\n        function baseFindIndex(array, predicate, fromIndex, fromRight) {\n            var length = array.length,\n                index = fromIndex + (fromRight ? 1 : -1);\n\n            while ((fromRight ? index-- : ++index < length)) {\n                if (predicate(array[index], index, array)) {\n                    return index;\n                }\n            }\n            return -1;\n        }\n\n        /**\n         * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n         *\n         * @private\n         * @param {Array} array The array to inspect.\n         * @param {*} value The value to search for.\n         * @param {number} fromIndex The index to search from.\n         * @returns {number} Returns the index of the matched value, else `-1`.\n         */\n        function baseIndexOf(array, value, fromIndex) {\n            return value === value\n                ? strictIndexOf(array, value, fromIndex)\n                : baseFindIndex(array, baseIsNaN, fromIndex);\n        }\n\n        /**\n         * The base implementation of `_.isNaN` without support for number objects.\n         *\n         * @private\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n         */\n        function baseIsNaN(value) {\n            return value !== value;\n        }\n\n        /**\n         * The base implementation of `_.times` without support for iteratee shorthands\n         * or max array length checks.\n         *\n         * @private\n         * @param {number} n The number of times to invoke `iteratee`.\n         * @param {Function} iteratee The function invoked per iteration.\n         * @returns {Array} Returns the array of results.\n         */\n        function baseTimes(n, iteratee) {\n            var index = -1,\n                result = Array(n);\n\n            while (++index < n) {\n                result[index] = iteratee(index);\n            }\n            return result;\n        }\n\n        /**\n         * The base implementation of `_.unary` without support for storing metadata.\n         *\n         * @private\n         * @param {Function} func The function to cap arguments for.\n         * @returns {Function} Returns the new capped function.\n         */\n        function baseUnary(func) {\n            return function(value) {\n                return func(value);\n            };\n        }\n\n        /**\n         * Gets the number of `placeholder` occurrences in `array`.\n         *\n         * @private\n         * @param {Array} array The array to inspect.\n         * @param {*} placeholder The placeholder to search for.\n         * @returns {number} Returns the placeholder count.\n         */\n        function countHolders(array, placeholder) {\n            var length = array.length,\n                result = 0;\n\n            while (length--) {\n                if (array[length] === placeholder) {\n                    ++result;\n                }\n            }\n            return result;\n        }\n\n        /**\n         * Gets the value at `key` of `object`.\n         *\n         * @private\n         * @param {Object} [object] The object to query.\n         * @param {string} key The key of the property to get.\n         * @returns {*} Returns the property value.\n         */\n        function getValue(object, key) {\n            return object == null ? undefined : object[key];\n        }\n\n        /**\n         * Creates a unary function that invokes `func` with its argument transformed.\n         *\n         * @private\n         * @param {Function} func The function to wrap.\n         * @param {Function} transform The argument transform.\n         * @returns {Function} Returns the new function.\n         */\n        function overArg(func, transform) {\n            return function(arg) {\n                return func(transform(arg));\n            };\n        }\n\n        /**\n         * Replaces all `placeholder` elements in `array` with an internal placeholder\n         * and returns an array of their indexes.\n         *\n         * @private\n         * @param {Array} array The array to modify.\n         * @param {*} placeholder The placeholder to replace.\n         * @returns {Array} Returns the new array of placeholder indexes.\n         */\n        function replaceHolders(array, placeholder) {\n            var index = -1,\n                length = array.length,\n                resIndex = 0,\n                result = [];\n\n            while (++index < length) {\n                var value = array[index];\n                if (value === placeholder || value === PLACEHOLDER) {\n                    array[index] = PLACEHOLDER;\n                    result[resIndex++] = index;\n                }\n            }\n            return result;\n        }\n\n        /**\n         * A specialized version of `_.indexOf` which performs strict equality\n         * comparisons of values, i.e. `===`.\n         *\n         * @private\n         * @param {Array} array The array to inspect.\n         * @param {*} value The value to search for.\n         * @param {number} fromIndex The index to search from.\n         * @returns {number} Returns the index of the matched value, else `-1`.\n         */\n        function strictIndexOf(array, value, fromIndex) {\n            var index = fromIndex - 1,\n                length = array.length;\n\n            while (++index < length) {\n                if (array[index] === value) {\n                    return index;\n                }\n            }\n            return -1;\n        }\n\n        /*--------------------------------------------------------------------------*/\n\n        /** Used for built-in method references. */\n        var funcProto = Function.prototype,\n            objectProto = Object.prototype;\n\n        /** Used to detect overreaching core-js shims. */\n        var coreJsData = root['__core-js_shared__'];\n\n        /** Used to resolve the decompiled source of functions. */\n        var funcToString = funcProto.toString;\n\n        /** Used to check objects for own properties. */\n        var hasOwnProperty = objectProto.hasOwnProperty;\n\n        /** Used to detect methods masquerading as native. */\n        var maskSrcKey = (function() {\n            var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n            return uid ? ('Symbol(src)_1.' + uid) : '';\n        }());\n\n        /**\n         * Used to resolve the\n         * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n         * of values.\n         */\n        var nativeObjectToString = objectProto.toString;\n\n        /** Used to detect if a method is native. */\n        var reIsNative = RegExp('^' +\n            funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n                .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n        );\n\n        /** Built-in value references. */\n        var Buffer = moduleExports ? root.Buffer : undefined,\n            Symbol = root.Symbol,\n            objectCreate = Object.create,\n            propertyIsEnumerable = objectProto.propertyIsEnumerable,\n            symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n        var defineProperty = (function() {\n            try {\n                var func = getNative(Object, 'defineProperty');\n                func({}, '', {});\n                return func;\n            } catch (e) {}\n        }());\n\n        /* Built-in method references for those with the same name as other `lodash` methods. */\n        var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n            nativeKeys = overArg(Object.keys, Object),\n            nativeMax = Math.max,\n            nativeMin = Math.min,\n            nativeNow = Date.now;\n\n        /* Built-in method references that are verified to be native. */\n        var WeakMap = getNative(root, 'WeakMap');\n\n        /** Used to store function metadata. */\n        var metaMap = WeakMap && new WeakMap;\n\n        /** Used to lookup unminified function names. */\n        var realNames = {};\n\n        /*------------------------------------------------------------------------*/\n\n        /**\n         * Creates a `lodash` object which wraps `value` to enable implicit method\n         * chain sequences. Methods that operate on and return arrays, collections,\n         * and functions can be chained together. Methods that retrieve a single value\n         * or may return a primitive value will automatically end the chain sequence\n         * and return the unwrapped value. Otherwise, the value must be unwrapped\n         * with `_#value`.\n         *\n         * Explicit chain sequences, which must be unwrapped with `_#value`, may be\n         * enabled using `_.chain`.\n         *\n         * The execution of chained methods is lazy, that is, it's deferred until\n         * `_#value` is implicitly or explicitly called.\n         *\n         * Lazy evaluation allows several methods to support shortcut fusion.\n         * Shortcut fusion is an optimization to merge iteratee calls; this avoids\n         * the creation of intermediate arrays and can greatly reduce the number of\n         * iteratee executions. Sections of a chain sequence qualify for shortcut\n         * fusion if the section is applied to an array and iteratees accept only\n         * one argument. The heuristic for whether a section qualifies for shortcut\n         * fusion is subject to change.\n         *\n         * Chaining is supported in custom builds as long as the `_#value` method is\n         * directly or indirectly included in the build.\n         *\n         * In addition to lodash methods, wrappers have `Array` and `String` methods.\n         *\n         * The wrapper `Array` methods are:\n         * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`\n         *\n         * The wrapper `String` methods are:\n         * `replace` and `split`\n         *\n         * The wrapper methods that support shortcut fusion are:\n         * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,\n         * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,\n         * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`\n         *\n         * The chainable wrapper methods are:\n         * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,\n         * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,\n         * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,\n         * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,\n         * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,\n         * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,\n         * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,\n         * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,\n         * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,\n         * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,\n         * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,\n         * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,\n         * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,\n         * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,\n         * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,\n         * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,\n         * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,\n         * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,\n         * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,\n         * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,\n         * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,\n         * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,\n         * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,\n         * `zipObject`, `zipObjectDeep`, and `zipWith`\n         *\n         * The wrapper methods that are **not** chainable by default are:\n         * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,\n         * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,\n         * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,\n         * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,\n         * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,\n         * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,\n         * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,\n         * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,\n         * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,\n         * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,\n         * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,\n         * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,\n         * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,\n         * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,\n         * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,\n         * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,\n         * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,\n         * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,\n         * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,\n         * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,\n         * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,\n         * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,\n         * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,\n         * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,\n         * `upperFirst`, `value`, and `words`\n         *\n         * @name _\n         * @constructor\n         * @category Seq\n         * @param {*} value The value to wrap in a `lodash` instance.\n         * @returns {Object} Returns the new `lodash` wrapper instance.\n         * @example\n         *\n         * function square(n) {\n         *   return n * n;\n         * }\n         *\n         * var wrapped = _([1, 2, 3]);\n         *\n         * // Returns an unwrapped value.\n         * wrapped.reduce(_.add);\n         * // => 6\n         *\n         * // Returns a wrapped value.\n         * var squares = wrapped.map(square);\n         *\n         * _.isArray(squares);\n         * // => false\n         *\n         * _.isArray(squares.value());\n         * // => true\n         */\n        function lodash() {\n            // No operation performed.\n        }\n\n        /**\n         * The base implementation of `_.create` without support for assigning\n         * properties to the created object.\n         *\n         * @private\n         * @param {Object} proto The object to inherit from.\n         * @returns {Object} Returns the new object.\n         */\n        var baseCreate = (function() {\n            function object() {}\n            return function(proto) {\n                if (!isObject(proto)) {\n                    return {};\n                }\n                if (objectCreate) {\n                    return objectCreate(proto);\n                }\n                object.prototype = proto;\n                var result = new object;\n                object.prototype = undefined;\n                return result;\n            };\n        }());\n\n        /**\n         * The function whose prototype chain sequence wrappers inherit from.\n         *\n         * @private\n         */\n        function baseLodash() {\n            // No operation performed.\n        }\n\n        /*------------------------------------------------------------------------*/\n\n        /**\n         * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.\n         *\n         * @private\n         * @constructor\n         * @param {*} value The value to wrap.\n         */\n        function LazyWrapper(value) {\n            this.__wrapped__ = value;\n            this.__actions__ = [];\n            this.__dir__ = 1;\n            this.__filtered__ = false;\n            this.__iteratees__ = [];\n            this.__takeCount__ = MAX_ARRAY_LENGTH;\n            this.__views__ = [];\n        }\n\n        // Ensure `LazyWrapper` is an instance of `baseLodash`.\n        LazyWrapper.prototype = baseCreate(baseLodash.prototype);\n        LazyWrapper.prototype.constructor = LazyWrapper;\n\n        /*------------------------------------------------------------------------*/\n\n        /**\n         * Creates an array of the enumerable property names of the array-like `value`.\n         *\n         * @private\n         * @param {*} value The value to query.\n         * @param {boolean} inherited Specify returning inherited property names.\n         * @returns {Array} Returns the array of property names.\n         */\n        function arrayLikeKeys(value, inherited) {\n            var isArr = isArray(value),\n                isArg = !isArr && isArguments(value),\n                isBuff = !isArr && !isArg && isBuffer(value),\n                isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n                skipIndexes = isArr || isArg || isBuff || isType,\n                result = skipIndexes ? baseTimes(value.length, String) : [],\n                length = result.length;\n\n            for (var key in value) {\n                if ((inherited || hasOwnProperty.call(value, key)) &&\n                    !(skipIndexes && (\n                        // Safari 9 has enumerable `arguments.length` in strict mode.\n                        key == 'length' ||\n                        // Node.js 0.10 has enumerable non-index properties on buffers.\n                        (isBuff && (key == 'offset' || key == 'parent')) ||\n                        // PhantomJS 2 has enumerable non-index properties on typed arrays.\n                        (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n                        // Skip index properties.\n                        isIndex(key, length)\n                    ))) {\n                    result.push(key);\n                }\n            }\n            return result;\n        }\n\n        /**\n         * Assigns `value` to `key` of `object` if the existing value is not equivalent\n         * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n         * for equality comparisons.\n         *\n         * @private\n         * @param {Object} object The object to modify.\n         * @param {string} key The key of the property to assign.\n         * @param {*} value The value to assign.\n         */\n        function assignValue(object, key, value) {\n            var objValue = object[key];\n            if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n                (value === undefined && !(key in object))) {\n                baseAssignValue(object, key, value);\n            }\n        }\n\n        /**\n         * The base implementation of `_.assign` without support for multiple sources\n         * or `customizer` functions.\n         *\n         * @private\n         * @param {Object} object The destination object.\n         * @param {Object} source The source object.\n         * @returns {Object} Returns `object`.\n         */\n        function baseAssign(object, source) {\n            return object && copyObject(source, keys(source), object);\n        }\n\n        /**\n         * The base implementation of `assignValue` and `assignMergeValue` without\n         * value checks.\n         *\n         * @private\n         * @param {Object} object The object to modify.\n         * @param {string} key The key of the property to assign.\n         * @param {*} value The value to assign.\n         */\n        function baseAssignValue(object, key, value) {\n            if (key == '__proto__' && defineProperty) {\n                defineProperty(object, key, {\n                    'configurable': true,\n                    'enumerable': true,\n                    'value': value,\n                    'writable': true\n                });\n            } else {\n                object[key] = value;\n            }\n        }\n\n        /**\n         * The base implementation of `_.delay` and `_.defer` which accepts `args`\n         * to provide to `func`.\n         *\n         * @private\n         * @param {Function} func The function to delay.\n         * @param {number} wait The number of milliseconds to delay invocation.\n         * @param {Array} args The arguments to provide to `func`.\n         * @returns {number|Object} Returns the timer id or timeout object.\n         */\n        function baseDelay(func, wait, args) {\n            if (typeof func != 'function') {\n                throw new TypeError(FUNC_ERROR_TEXT);\n            }\n            return setTimeout(function() { func.apply(undefined, args); }, wait);\n        }\n\n        /**\n         * The base implementation of `getTag` without fallbacks for buggy environments.\n         *\n         * @private\n         * @param {*} value The value to query.\n         * @returns {string} Returns the `toStringTag`.\n         */\n        function baseGetTag(value) {\n            if (value == null) {\n                return value === undefined ? undefinedTag : nullTag;\n            }\n            return (symToStringTag && symToStringTag in Object(value))\n                ? getRawTag(value)\n                : objectToString(value);\n        }\n\n        /**\n         * The base implementation of `_.isArguments`.\n         *\n         * @private\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n         */\n        function baseIsArguments(value) {\n            return isObjectLike(value) && baseGetTag(value) == argsTag;\n        }\n\n        /**\n         * The base implementation of `_.isNative` without bad shim checks.\n         *\n         * @private\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is a native function,\n         *  else `false`.\n         */\n        function baseIsNative(value) {\n            if (!isObject(value) || isMasked(value)) {\n                return false;\n            }\n            var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n            return pattern.test(toSource(value));\n        }\n\n        /**\n         * The base implementation of `_.isTypedArray` without Node.js optimizations.\n         *\n         * @private\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n         */\n        function baseIsTypedArray(value) {\n            return isObjectLike(value) &&\n                isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n        }\n\n        /**\n         * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n         *\n         * @private\n         * @param {Object} object The object to query.\n         * @returns {Array} Returns the array of property names.\n         */\n        function baseKeys(object) {\n            if (!isPrototype(object)) {\n                return nativeKeys(object);\n            }\n            var result = [];\n            for (var key in Object(object)) {\n                if (hasOwnProperty.call(object, key) && key != 'constructor') {\n                    result.push(key);\n                }\n            }\n            return result;\n        }\n\n        /**\n         * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n         *\n         * @private\n         * @param {Object} object The object to query.\n         * @returns {Array} Returns the array of property names.\n         */\n        function baseKeysIn(object) {\n            if (!isObject(object)) {\n                return nativeKeysIn(object);\n            }\n            var isProto = isPrototype(object),\n                result = [];\n\n            for (var key in object) {\n                if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n                    result.push(key);\n                }\n            }\n            return result;\n        }\n\n        /**\n         * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n         *\n         * @private\n         * @param {Function} func The function to apply a rest parameter to.\n         * @param {number} [start=func.length-1] The start position of the rest parameter.\n         * @returns {Function} Returns the new function.\n         */\n        function baseRest(func, start) {\n            return setToString(overRest(func, start, identity), func + '');\n        }\n\n        /**\n         * The base implementation of `setData` without support for hot loop shorting.\n         *\n         * @private\n         * @param {Function} func The function to associate metadata with.\n         * @param {*} data The metadata.\n         * @returns {Function} Returns `func`.\n         */\n        var baseSetData = !metaMap ? identity : function(func, data) {\n            metaMap.set(func, data);\n            return func;\n        };\n\n        /**\n         * The base implementation of `setToString` without support for hot loop shorting.\n         *\n         * @private\n         * @param {Function} func The function to modify.\n         * @param {Function} string The `toString` result.\n         * @returns {Function} Returns `func`.\n         */\n        var baseSetToString = !defineProperty ? identity : function(func, string) {\n            return defineProperty(func, 'toString', {\n                'configurable': true,\n                'enumerable': false,\n                'value': constant(string),\n                'writable': true\n            });\n        };\n\n        /**\n         * Creates an array that is the composition of partially applied arguments,\n         * placeholders, and provided arguments into a single array of arguments.\n         *\n         * @private\n         * @param {Array} args The provided arguments.\n         * @param {Array} partials The arguments to prepend to those provided.\n         * @param {Array} holders The `partials` placeholder indexes.\n         * @params {boolean} [isCurried] Specify composing for a curried function.\n         * @returns {Array} Returns the new array of composed arguments.\n         */\n        function composeArgs(args, partials, holders, isCurried) {\n            var argsIndex = -1,\n                argsLength = args.length,\n                holdersLength = holders.length,\n                leftIndex = -1,\n                leftLength = partials.length,\n                rangeLength = nativeMax(argsLength - holdersLength, 0),\n                result = Array(leftLength + rangeLength),\n                isUncurried = !isCurried;\n\n            while (++leftIndex < leftLength) {\n                result[leftIndex] = partials[leftIndex];\n            }\n            while (++argsIndex < holdersLength) {\n                if (isUncurried || argsIndex < argsLength) {\n                    result[holders[argsIndex]] = args[argsIndex];\n                }\n            }\n            while (rangeLength--) {\n                result[leftIndex++] = args[argsIndex++];\n            }\n            return result;\n        }\n\n        /**\n         * This function is like `composeArgs` except that the arguments composition\n         * is tailored for `_.partialRight`.\n         *\n         * @private\n         * @param {Array} args The provided arguments.\n         * @param {Array} partials The arguments to append to those provided.\n         * @param {Array} holders The `partials` placeholder indexes.\n         * @params {boolean} [isCurried] Specify composing for a curried function.\n         * @returns {Array} Returns the new array of composed arguments.\n         */\n        function composeArgsRight(args, partials, holders, isCurried) {\n            var argsIndex = -1,\n                argsLength = args.length,\n                holdersIndex = -1,\n                holdersLength = holders.length,\n                rightIndex = -1,\n                rightLength = partials.length,\n                rangeLength = nativeMax(argsLength - holdersLength, 0),\n                result = Array(rangeLength + rightLength),\n                isUncurried = !isCurried;\n\n            while (++argsIndex < rangeLength) {\n                result[argsIndex] = args[argsIndex];\n            }\n            var offset = argsIndex;\n            while (++rightIndex < rightLength) {\n                result[offset + rightIndex] = partials[rightIndex];\n            }\n            while (++holdersIndex < holdersLength) {\n                if (isUncurried || argsIndex < argsLength) {\n                    result[offset + holders[holdersIndex]] = args[argsIndex++];\n                }\n            }\n            return result;\n        }\n\n        /**\n         * Copies the values of `source` to `array`.\n         *\n         * @private\n         * @param {Array} source The array to copy values from.\n         * @param {Array} [array=[]] The array to copy values to.\n         * @returns {Array} Returns `array`.\n         */\n        function copyArray(source, array) {\n            var index = -1,\n                length = source.length;\n\n            array || (array = Array(length));\n            while (++index < length) {\n                array[index] = source[index];\n            }\n            return array;\n        }\n\n        /**\n         * Copies properties of `source` to `object`.\n         *\n         * @private\n         * @param {Object} source The object to copy properties from.\n         * @param {Array} props The property identifiers to copy.\n         * @param {Object} [object={}] The object to copy properties to.\n         * @param {Function} [customizer] The function to customize copied values.\n         * @returns {Object} Returns `object`.\n         */\n        function copyObject(source, props, object, customizer) {\n            var isNew = !object;\n            object || (object = {});\n\n            var index = -1,\n                length = props.length;\n\n            while (++index < length) {\n                var key = props[index];\n\n                var newValue = customizer\n                    ? customizer(object[key], source[key], key, object, source)\n                    : undefined;\n\n                if (newValue === undefined) {\n                    newValue = source[key];\n                }\n                if (isNew) {\n                    baseAssignValue(object, key, newValue);\n                } else {\n                    assignValue(object, key, newValue);\n                }\n            }\n            return object;\n        }\n\n        /**\n         * Creates a function like `_.assign`.\n         *\n         * @private\n         * @param {Function} assigner The function to assign values.\n         * @returns {Function} Returns the new assigner function.\n         */\n        function createAssigner(assigner) {\n            return baseRest(function(object, sources) {\n                var index = -1,\n                    length = sources.length,\n                    customizer = length > 1 ? sources[length - 1] : undefined,\n                    guard = length > 2 ? sources[2] : undefined;\n\n                customizer = (assigner.length > 3 && typeof customizer == 'function')\n                    ? (length--, customizer)\n                    : undefined;\n\n                if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n                    customizer = length < 3 ? undefined : customizer;\n                    length = 1;\n                }\n                object = Object(object);\n                while (++index < length) {\n                    var source = sources[index];\n                    if (source) {\n                        assigner(object, source, index, customizer);\n                    }\n                }\n                return object;\n            });\n        }\n\n        /**\n         * Creates a function that wraps `func` to invoke it with the optional `this`\n         * binding of `thisArg`.\n         *\n         * @private\n         * @param {Function} func The function to wrap.\n         * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n         * @param {*} [thisArg] The `this` binding of `func`.\n         * @returns {Function} Returns the new wrapped function.\n         */\n        function createBind(func, bitmask, thisArg) {\n            var isBind = bitmask & WRAP_BIND_FLAG,\n                Ctor = createCtor(func);\n\n            function wrapper() {\n                var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n                return fn.apply(isBind ? thisArg : this, arguments);\n            }\n            return wrapper;\n        }\n\n        /**\n         * Creates a function that produces an instance of `Ctor` regardless of\n         * whether it was invoked as part of a `new` expression or by `call` or `apply`.\n         *\n         * @private\n         * @param {Function} Ctor The constructor to wrap.\n         * @returns {Function} Returns the new wrapped function.\n         */\n        function createCtor(Ctor) {\n            return function() {\n                // Use a `switch` statement to work with class constructors. See\n                // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist\n                // for more details.\n                var args = arguments;\n                switch (args.length) {\n                    case 0: return new Ctor;\n                    case 1: return new Ctor(args[0]);\n                    case 2: return new Ctor(args[0], args[1]);\n                    case 3: return new Ctor(args[0], args[1], args[2]);\n                    case 4: return new Ctor(args[0], args[1], args[2], args[3]);\n                    case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);\n                    case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);\n                    case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n                }\n                var thisBinding = baseCreate(Ctor.prototype),\n                    result = Ctor.apply(thisBinding, args);\n\n                // Mimic the constructor's `return` behavior.\n                // See https://es5.github.io/#x13.2.2 for more details.\n                return isObject(result) ? result : thisBinding;\n            };\n        }\n\n        /**\n         * Creates a function that wraps `func` to enable currying.\n         *\n         * @private\n         * @param {Function} func The function to wrap.\n         * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n         * @param {number} arity The arity of `func`.\n         * @returns {Function} Returns the new wrapped function.\n         */\n        function createCurry(func, bitmask, arity) {\n            var Ctor = createCtor(func);\n\n            function wrapper() {\n                var length = arguments.length,\n                    args = Array(length),\n                    index = length,\n                    placeholder = getHolder(wrapper);\n\n                while (index--) {\n                    args[index] = arguments[index];\n                }\n                var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)\n                    ? []\n                    : replaceHolders(args, placeholder);\n\n                length -= holders.length;\n                if (length < arity) {\n                    return createRecurry(\n                        func, bitmask, createHybrid, wrapper.placeholder, undefined,\n                        args, holders, undefined, undefined, arity - length);\n                }\n                var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n                return apply(fn, this, args);\n            }\n            return wrapper;\n        }\n\n        /**\n         * Creates a function that wraps `func` to invoke it with optional `this`\n         * binding of `thisArg`, partial application, and currying.\n         *\n         * @private\n         * @param {Function|string} func The function or method name to wrap.\n         * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n         * @param {*} [thisArg] The `this` binding of `func`.\n         * @param {Array} [partials] The arguments to prepend to those provided to\n         *  the new function.\n         * @param {Array} [holders] The `partials` placeholder indexes.\n         * @param {Array} [partialsRight] The arguments to append to those provided\n         *  to the new function.\n         * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.\n         * @param {Array} [argPos] The argument positions of the new function.\n         * @param {number} [ary] The arity cap of `func`.\n         * @param {number} [arity] The arity of `func`.\n         * @returns {Function} Returns the new wrapped function.\n         */\n        function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {\n            var isAry = bitmask & WRAP_ARY_FLAG,\n                isBind = bitmask & WRAP_BIND_FLAG,\n                isBindKey = bitmask & WRAP_BIND_KEY_FLAG,\n                isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),\n                isFlip = bitmask & WRAP_FLIP_FLAG,\n                Ctor = isBindKey ? undefined : createCtor(func);\n\n            function wrapper() {\n                var length = arguments.length,\n                    args = Array(length),\n                    index = length;\n\n                while (index--) {\n                    args[index] = arguments[index];\n                }\n                if (isCurried) {\n                    var placeholder = getHolder(wrapper),\n                        holdersCount = countHolders(args, placeholder);\n                }\n                if (partials) {\n                    args = composeArgs(args, partials, holders, isCurried);\n                }\n                if (partialsRight) {\n                    args = composeArgsRight(args, partialsRight, holdersRight, isCurried);\n                }\n                length -= holdersCount;\n                if (isCurried && length < arity) {\n                    var newHolders = replaceHolders(args, placeholder);\n                    return createRecurry(\n                        func, bitmask, createHybrid, wrapper.placeholder, thisArg,\n                        args, newHolders, argPos, ary, arity - length\n                    );\n                }\n                var thisBinding = isBind ? thisArg : this,\n                    fn = isBindKey ? thisBinding[func] : func;\n\n                length = args.length;\n                if (argPos) {\n                    args = reorder(args, argPos);\n                } else if (isFlip && length > 1) {\n                    args.reverse();\n                }\n                if (isAry && ary < length) {\n                    args.length = ary;\n                }\n                if (this && this !== root && this instanceof wrapper) {\n                    fn = Ctor || createCtor(fn);\n                }\n                return fn.apply(thisBinding, args);\n            }\n            return wrapper;\n        }\n\n        /**\n         * Creates a function that wraps `func` to invoke it with the `this` binding\n         * of `thisArg` and `partials` prepended to the arguments it receives.\n         *\n         * @private\n         * @param {Function} func The function to wrap.\n         * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n         * @param {*} thisArg The `this` binding of `func`.\n         * @param {Array} partials The arguments to prepend to those provided to\n         *  the new function.\n         * @returns {Function} Returns the new wrapped function.\n         */\n        function createPartial(func, bitmask, thisArg, partials) {\n            var isBind = bitmask & WRAP_BIND_FLAG,\n                Ctor = createCtor(func);\n\n            function wrapper() {\n                var argsIndex = -1,\n                    argsLength = arguments.length,\n                    leftIndex = -1,\n                    leftLength = partials.length,\n                    args = Array(leftLength + argsLength),\n                    fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n\n                while (++leftIndex < leftLength) {\n                    args[leftIndex] = partials[leftIndex];\n                }\n                while (argsLength--) {\n                    args[leftIndex++] = arguments[++argsIndex];\n                }\n                return apply(fn, isBind ? thisArg : this, args);\n            }\n            return wrapper;\n        }\n\n        /**\n         * Creates a function that wraps `func` to continue currying.\n         *\n         * @private\n         * @param {Function} func The function to wrap.\n         * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n         * @param {Function} wrapFunc The function to create the `func` wrapper.\n         * @param {*} placeholder The placeholder value.\n         * @param {*} [thisArg] The `this` binding of `func`.\n         * @param {Array} [partials] The arguments to prepend to those provided to\n         *  the new function.\n         * @param {Array} [holders] The `partials` placeholder indexes.\n         * @param {Array} [argPos] The argument positions of the new function.\n         * @param {number} [ary] The arity cap of `func`.\n         * @param {number} [arity] The arity of `func`.\n         * @returns {Function} Returns the new wrapped function.\n         */\n        function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {\n            var isCurry = bitmask & WRAP_CURRY_FLAG,\n                newHolders = isCurry ? holders : undefined,\n                newHoldersRight = isCurry ? undefined : holders,\n                newPartials = isCurry ? partials : undefined,\n                newPartialsRight = isCurry ? undefined : partials;\n\n            bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);\n            bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);\n\n            if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {\n                bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);\n            }\n            var newData = [\n                func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,\n                newHoldersRight, argPos, ary, arity\n            ];\n\n            var result = wrapFunc.apply(undefined, newData);\n            if (isLaziable(func)) {\n                setData(result, newData);\n            }\n            result.placeholder = placeholder;\n            return setWrapToString(result, func, bitmask);\n        }\n\n        /**\n         * Creates a function that either curries or invokes `func` with optional\n         * `this` binding and partially applied arguments.\n         *\n         * @private\n         * @param {Function|string} func The function or method name to wrap.\n         * @param {number} bitmask The bitmask flags.\n         *    1 - `_.bind`\n         *    2 - `_.bindKey`\n         *    4 - `_.curry` or `_.curryRight` of a bound function\n         *    8 - `_.curry`\n         *   16 - `_.curryRight`\n         *   32 - `_.partial`\n         *   64 - `_.partialRight`\n         *  128 - `_.rearg`\n         *  256 - `_.ary`\n         *  512 - `_.flip`\n         * @param {*} [thisArg] The `this` binding of `func`.\n         * @param {Array} [partials] The arguments to be partially applied.\n         * @param {Array} [holders] The `partials` placeholder indexes.\n         * @param {Array} [argPos] The argument positions of the new function.\n         * @param {number} [ary] The arity cap of `func`.\n         * @param {number} [arity] The arity of `func`.\n         * @returns {Function} Returns the new wrapped function.\n         */\n        function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {\n            var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;\n            if (!isBindKey && typeof func != 'function') {\n                throw new TypeError(FUNC_ERROR_TEXT);\n            }\n            var length = partials ? partials.length : 0;\n            if (!length) {\n                bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);\n                partials = holders = undefined;\n            }\n            ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);\n            arity = arity === undefined ? arity : toInteger(arity);\n            length -= holders ? holders.length : 0;\n\n            if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {\n                var partialsRight = partials,\n                    holdersRight = holders;\n\n                partials = holders = undefined;\n            }\n            var data = isBindKey ? undefined : getData(func);\n\n            var newData = [\n                func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,\n                argPos, ary, arity\n            ];\n\n            if (data) {\n                mergeData(newData, data);\n            }\n            func = newData[0];\n            bitmask = newData[1];\n            thisArg = newData[2];\n            partials = newData[3];\n            holders = newData[4];\n            arity = newData[9] = newData[9] === undefined\n                ? (isBindKey ? 0 : func.length)\n                : nativeMax(newData[9] - length, 0);\n\n            if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {\n                bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);\n            }\n            if (!bitmask || bitmask == WRAP_BIND_FLAG) {\n                var result = createBind(func, bitmask, thisArg);\n            } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {\n                result = createCurry(func, bitmask, arity);\n            } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {\n                result = createPartial(func, bitmask, thisArg, partials);\n            } else {\n                result = createHybrid.apply(undefined, newData);\n            }\n            var setter = data ? baseSetData : setData;\n            return setWrapToString(setter(result, newData), func, bitmask);\n        }\n\n        /**\n         * Gets metadata for `func`.\n         *\n         * @private\n         * @param {Function} func The function to query.\n         * @returns {*} Returns the metadata for `func`.\n         */\n        var getData = !metaMap ? noop : function(func) {\n            return metaMap.get(func);\n        };\n\n        /**\n         * Gets the name of `func`.\n         *\n         * @private\n         * @param {Function} func The function to query.\n         * @returns {string} Returns the function name.\n         */\n        function getFuncName(func) {\n            var result = (func.name + ''),\n                array = realNames[result],\n                length = hasOwnProperty.call(realNames, result) ? array.length : 0;\n\n            while (length--) {\n                var data = array[length],\n                    otherFunc = data.func;\n                if (otherFunc == null || otherFunc == func) {\n                    return data.name;\n                }\n            }\n            return result;\n        }\n\n        /**\n         * Gets the argument placeholder value for `func`.\n         *\n         * @private\n         * @param {Function} func The function to inspect.\n         * @returns {*} Returns the placeholder value.\n         */\n        function getHolder(func) {\n            var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;\n            return object.placeholder;\n        }\n\n        /**\n         * Gets the native function at `key` of `object`.\n         *\n         * @private\n         * @param {Object} object The object to query.\n         * @param {string} key The key of the method to get.\n         * @returns {*} Returns the function if it's native, else `undefined`.\n         */\n        function getNative(object, key) {\n            var value = getValue(object, key);\n            return baseIsNative(value) ? value : undefined;\n        }\n\n        /**\n         * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n         *\n         * @private\n         * @param {*} value The value to query.\n         * @returns {string} Returns the raw `toStringTag`.\n         */\n        function getRawTag(value) {\n            var isOwn = hasOwnProperty.call(value, symToStringTag),\n                tag = value[symToStringTag];\n\n            try {\n                value[symToStringTag] = undefined;\n                var unmasked = true;\n            } catch (e) {}\n\n            var result = nativeObjectToString.call(value);\n            if (unmasked) {\n                if (isOwn) {\n                    value[symToStringTag] = tag;\n                } else {\n                    delete value[symToStringTag];\n                }\n            }\n            return result;\n        }\n\n        /**\n         * Extracts wrapper details from the `source` body comment.\n         *\n         * @private\n         * @param {string} source The source to inspect.\n         * @returns {Array} Returns the wrapper details.\n         */\n        function getWrapDetails(source) {\n            var match = source.match(reWrapDetails);\n            return match ? match[1].split(reSplitDetails) : [];\n        }\n\n        /**\n         * Inserts wrapper `details` in a comment at the top of the `source` body.\n         *\n         * @private\n         * @param {string} source The source to modify.\n         * @returns {Array} details The details to insert.\n         * @returns {string} Returns the modified source.\n         */\n        function insertWrapDetails(source, details) {\n            var length = details.length;\n            if (!length) {\n                return source;\n            }\n            var lastIndex = length - 1;\n            details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];\n            details = details.join(length > 2 ? ', ' : ' ');\n            return source.replace(reWrapComment, '{\\n/* [wrapped with ' + details + '] */\\n');\n        }\n\n        /**\n         * Checks if `value` is a valid array-like index.\n         *\n         * @private\n         * @param {*} value The value to check.\n         * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n         * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n         */\n        function isIndex(value, length) {\n            var type = typeof value;\n            length = length == null ? MAX_SAFE_INTEGER : length;\n\n            return !!length &&\n                (type == 'number' ||\n                    (type != 'symbol' && reIsUint.test(value))) &&\n                (value > -1 && value % 1 == 0 && value < length);\n        }\n\n        /**\n         * Checks if the given arguments are from an iteratee call.\n         *\n         * @private\n         * @param {*} value The potential iteratee value argument.\n         * @param {*} index The potential iteratee index or key argument.\n         * @param {*} object The potential iteratee object argument.\n         * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n         *  else `false`.\n         */\n        function isIterateeCall(value, index, object) {\n            if (!isObject(object)) {\n                return false;\n            }\n            var type = typeof index;\n            if (type == 'number'\n                ? (isArrayLike(object) && isIndex(index, object.length))\n                : (type == 'string' && index in object)\n            ) {\n                return eq(object[index], value);\n            }\n            return false;\n        }\n\n        /**\n         * Checks if `func` has a lazy counterpart.\n         *\n         * @private\n         * @param {Function} func The function to check.\n         * @returns {boolean} Returns `true` if `func` has a lazy counterpart,\n         *  else `false`.\n         */\n        function isLaziable(func) {\n            var funcName = getFuncName(func),\n                other = lodash[funcName];\n\n            if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {\n                return false;\n            }\n            if (func === other) {\n                return true;\n            }\n            var data = getData(other);\n            return !!data && func === data[0];\n        }\n\n        /**\n         * Checks if `func` has its source masked.\n         *\n         * @private\n         * @param {Function} func The function to check.\n         * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n         */\n        function isMasked(func) {\n            return !!maskSrcKey && (maskSrcKey in func);\n        }\n\n        /**\n         * Checks if `value` is likely a prototype object.\n         *\n         * @private\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n         */\n        function isPrototype(value) {\n            var Ctor = value && value.constructor,\n                proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n            return value === proto;\n        }\n\n        /**\n         * Merges the function metadata of `source` into `data`.\n         *\n         * Merging metadata reduces the number of wrappers used to invoke a function.\n         * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`\n         * may be applied regardless of execution order. Methods like `_.ary` and\n         * `_.rearg` modify function arguments, making the order in which they are\n         * executed important, preventing the merging of metadata. However, we make\n         * an exception for a safe combined case where curried functions have `_.ary`\n         * and or `_.rearg` applied.\n         *\n         * @private\n         * @param {Array} data The destination metadata.\n         * @param {Array} source The source metadata.\n         * @returns {Array} Returns `data`.\n         */\n        function mergeData(data, source) {\n            var bitmask = data[1],\n                srcBitmask = source[1],\n                newBitmask = bitmask | srcBitmask,\n                isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);\n\n            var isCombo =\n                ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||\n                ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||\n                ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));\n\n            // Exit early if metadata can't be merged.\n            if (!(isCommon || isCombo)) {\n                return data;\n            }\n            // Use source `thisArg` if available.\n            if (srcBitmask & WRAP_BIND_FLAG) {\n                data[2] = source[2];\n                // Set when currying a bound function.\n                newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;\n            }\n            // Compose partial arguments.\n            var value = source[3];\n            if (value) {\n                var partials = data[3];\n                data[3] = partials ? composeArgs(partials, value, source[4]) : value;\n                data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];\n            }\n            // Compose partial right arguments.\n            value = source[5];\n            if (value) {\n                partials = data[5];\n                data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;\n                data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];\n            }\n            // Use source `argPos` if available.\n            value = source[7];\n            if (value) {\n                data[7] = value;\n            }\n            // Use source `ary` if it's smaller.\n            if (srcBitmask & WRAP_ARY_FLAG) {\n                data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);\n            }\n            // Use source `arity` if one is not provided.\n            if (data[9] == null) {\n                data[9] = source[9];\n            }\n            // Use source `func` and merge bitmasks.\n            data[0] = source[0];\n            data[1] = newBitmask;\n\n            return data;\n        }\n\n        /**\n         * This function is like\n         * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n         * except that it includes inherited enumerable properties.\n         *\n         * @private\n         * @param {Object} object The object to query.\n         * @returns {Array} Returns the array of property names.\n         */\n        function nativeKeysIn(object) {\n            var result = [];\n            if (object != null) {\n                for (var key in Object(object)) {\n                    result.push(key);\n                }\n            }\n            return result;\n        }\n\n        /**\n         * Converts `value` to a string using `Object.prototype.toString`.\n         *\n         * @private\n         * @param {*} value The value to convert.\n         * @returns {string} Returns the converted string.\n         */\n        function objectToString(value) {\n            return nativeObjectToString.call(value);\n        }\n\n        /**\n         * A specialized version of `baseRest` which transforms the rest array.\n         *\n         * @private\n         * @param {Function} func The function to apply a rest parameter to.\n         * @param {number} [start=func.length-1] The start position of the rest parameter.\n         * @param {Function} transform The rest array transform.\n         * @returns {Function} Returns the new function.\n         */\n        function overRest(func, start, transform) {\n            start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n            return function() {\n                var args = arguments,\n                    index = -1,\n                    length = nativeMax(args.length - start, 0),\n                    array = Array(length);\n\n                while (++index < length) {\n                    array[index] = args[start + index];\n                }\n                index = -1;\n                var otherArgs = Array(start + 1);\n                while (++index < start) {\n                    otherArgs[index] = args[index];\n                }\n                otherArgs[start] = transform(array);\n                return apply(func, this, otherArgs);\n            };\n        }\n\n        /**\n         * Reorder `array` according to the specified indexes where the element at\n         * the first index is assigned as the first element, the element at\n         * the second index is assigned as the second element, and so on.\n         *\n         * @private\n         * @param {Array} array The array to reorder.\n         * @param {Array} indexes The arranged array indexes.\n         * @returns {Array} Returns `array`.\n         */\n        function reorder(array, indexes) {\n            var arrLength = array.length,\n                length = nativeMin(indexes.length, arrLength),\n                oldArray = copyArray(array);\n\n            while (length--) {\n                var index = indexes[length];\n                array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;\n            }\n            return array;\n        }\n\n        /**\n         * Sets metadata for `func`.\n         *\n         * **Note:** If this function becomes hot, i.e. is invoked a lot in a short\n         * period of time, it will trip its breaker and transition to an identity\n         * function to avoid garbage collection pauses in V8. See\n         * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)\n         * for more details.\n         *\n         * @private\n         * @param {Function} func The function to associate metadata with.\n         * @param {*} data The metadata.\n         * @returns {Function} Returns `func`.\n         */\n        var setData = shortOut(baseSetData);\n\n        /**\n         * Sets the `toString` method of `func` to return `string`.\n         *\n         * @private\n         * @param {Function} func The function to modify.\n         * @param {Function} string The `toString` result.\n         * @returns {Function} Returns `func`.\n         */\n        var setToString = shortOut(baseSetToString);\n\n        /**\n         * Sets the `toString` method of `wrapper` to mimic the source of `reference`\n         * with wrapper details in a comment at the top of the source body.\n         *\n         * @private\n         * @param {Function} wrapper The function to modify.\n         * @param {Function} reference The reference function.\n         * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n         * @returns {Function} Returns `wrapper`.\n         */\n        function setWrapToString(wrapper, reference, bitmask) {\n            var source = (reference + '');\n            return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));\n        }\n\n        /**\n         * Creates a function that'll short out and invoke `identity` instead\n         * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n         * milliseconds.\n         *\n         * @private\n         * @param {Function} func The function to restrict.\n         * @returns {Function} Returns the new shortable function.\n         */\n        function shortOut(func) {\n            var count = 0,\n                lastCalled = 0;\n\n            return function() {\n                var stamp = nativeNow(),\n                    remaining = HOT_SPAN - (stamp - lastCalled);\n\n                lastCalled = stamp;\n                if (remaining > 0) {\n                    if (++count >= HOT_COUNT) {\n                        return arguments[0];\n                    }\n                } else {\n                    count = 0;\n                }\n                return func.apply(undefined, arguments);\n            };\n        }\n\n        /**\n         * Converts `func` to its source code.\n         *\n         * @private\n         * @param {Function} func The function to convert.\n         * @returns {string} Returns the source code.\n         */\n        function toSource(func) {\n            if (func != null) {\n                try {\n                    return funcToString.call(func);\n                } catch (e) {}\n                try {\n                    return (func + '');\n                } catch (e) {}\n            }\n            return '';\n        }\n\n        /**\n         * Updates wrapper `details` based on `bitmask` flags.\n         *\n         * @private\n         * @returns {Array} details The details to modify.\n         * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n         * @returns {Array} Returns `details`.\n         */\n        function updateWrapDetails(details, bitmask) {\n            arrayEach(wrapFlags, function(pair) {\n                var value = '_.' + pair[0];\n                if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {\n                    details.push(value);\n                }\n            });\n            return details.sort();\n        }\n\n        /*------------------------------------------------------------------------*/\n\n        /**\n         * Gets the timestamp of the number of milliseconds that have elapsed since\n         * the Unix epoch (1 January 1970 00:00:00 UTC).\n         *\n         * @static\n         * @memberOf _\n         * @since 2.4.0\n         * @category Date\n         * @returns {number} Returns the timestamp.\n         * @example\n         *\n         * _.defer(function(stamp) {\n         *   console.log(_.now() - stamp);\n         * }, _.now());\n         * // => Logs the number of milliseconds it took for the deferred invocation.\n         */\n        var now = function() {\n            return root.Date.now();\n        };\n\n        /*------------------------------------------------------------------------*/\n\n        /**\n         * Creates a function that invokes `func` with the `this` binding of `thisArg`\n         * and `partials` prepended to the arguments it receives.\n         *\n         * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,\n         * may be used as a placeholder for partially applied arguments.\n         *\n         * **Note:** Unlike native `Function#bind`, this method doesn't set the \"length\"\n         * property of bound functions.\n         *\n         * @static\n         * @memberOf _\n         * @since 0.1.0\n         * @category Function\n         * @param {Function} func The function to bind.\n         * @param {*} thisArg The `this` binding of `func`.\n         * @param {...*} [partials] The arguments to be partially applied.\n         * @returns {Function} Returns the new bound function.\n         * @example\n         *\n         * function greet(greeting, punctuation) {\n         *   return greeting + ' ' + this.user + punctuation;\n         * }\n         *\n         * var object = { 'user': 'fred' };\n         *\n         * var bound = _.bind(greet, object, 'hi');\n         * bound('!');\n         * // => 'hi fred!'\n         *\n         * // Bound with placeholders.\n         * var bound = _.bind(greet, object, _, '!');\n         * bound('hi');\n         * // => 'hi fred!'\n         */\n        var bind = baseRest(function(func, thisArg, partials) {\n            var bitmask = WRAP_BIND_FLAG;\n            if (partials.length) {\n                var holders = replaceHolders(partials, getHolder(bind));\n                bitmask |= WRAP_PARTIAL_FLAG;\n            }\n            return createWrap(func, bitmask, thisArg, partials, holders);\n        });\n\n        /**\n         * Creates a debounced function that delays invoking `func` until after `wait`\n         * milliseconds have elapsed since the last time the debounced function was\n         * invoked. The debounced function comes with a `cancel` method to cancel\n         * delayed `func` invocations and a `flush` method to immediately invoke them.\n         * Provide `options` to indicate whether `func` should be invoked on the\n         * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n         * with the last arguments provided to the debounced function. Subsequent\n         * calls to the debounced function return the result of the last `func`\n         * invocation.\n         *\n         * **Note:** If `leading` and `trailing` options are `true`, `func` is\n         * invoked on the trailing edge of the timeout only if the debounced function\n         * is invoked more than once during the `wait` timeout.\n         *\n         * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n         * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n         *\n         * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n         * for details over the differences between `_.debounce` and `_.throttle`.\n         *\n         * @static\n         * @memberOf _\n         * @since 0.1.0\n         * @category Function\n         * @param {Function} func The function to debounce.\n         * @param {number} [wait=0] The number of milliseconds to delay.\n         * @param {Object} [options={}] The options object.\n         * @param {boolean} [options.leading=false]\n         *  Specify invoking on the leading edge of the timeout.\n         * @param {number} [options.maxWait]\n         *  The maximum time `func` is allowed to be delayed before it's invoked.\n         * @param {boolean} [options.trailing=true]\n         *  Specify invoking on the trailing edge of the timeout.\n         * @returns {Function} Returns the new debounced function.\n         * @example\n         *\n         * // Avoid costly calculations while the window size is in flux.\n         * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n         *\n         * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n         * jQuery(element).on('click', _.debounce(sendMail, 300, {\n         *   'leading': true,\n         *   'trailing': false\n         * }));\n         *\n         * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n         * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n         * var source = new EventSource('/stream');\n         * jQuery(source).on('message', debounced);\n         *\n         * // Cancel the trailing debounced invocation.\n         * jQuery(window).on('popstate', debounced.cancel);\n         */\n        function debounce(func, wait, options) {\n            var lastArgs,\n                lastThis,\n                maxWait,\n                result,\n                timerId,\n                lastCallTime,\n                lastInvokeTime = 0,\n                leading = false,\n                maxing = false,\n                trailing = true;\n\n            if (typeof func != 'function') {\n                throw new TypeError(FUNC_ERROR_TEXT);\n            }\n            wait = toNumber(wait) || 0;\n            if (isObject(options)) {\n                leading = !!options.leading;\n                maxing = 'maxWait' in options;\n                maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n                trailing = 'trailing' in options ? !!options.trailing : trailing;\n            }\n\n            function invokeFunc(time) {\n                var args = lastArgs,\n                    thisArg = lastThis;\n\n                lastArgs = lastThis = undefined;\n                lastInvokeTime = time;\n                result = func.apply(thisArg, args);\n                return result;\n            }\n\n            function leadingEdge(time) {\n                // Reset any `maxWait` timer.\n                lastInvokeTime = time;\n                // Start the timer for the trailing edge.\n                timerId = setTimeout(timerExpired, wait);\n                // Invoke the leading edge.\n                return leading ? invokeFunc(time) : result;\n            }\n\n            function remainingWait(time) {\n                var timeSinceLastCall = time - lastCallTime,\n                    timeSinceLastInvoke = time - lastInvokeTime,\n                    timeWaiting = wait - timeSinceLastCall;\n\n                return maxing\n                    ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n                    : timeWaiting;\n            }\n\n            function shouldInvoke(time) {\n                var timeSinceLastCall = time - lastCallTime,\n                    timeSinceLastInvoke = time - lastInvokeTime;\n\n                // Either this is the first call, activity has stopped and we're at the\n                // trailing edge, the system time has gone backwards and we're treating\n                // it as the trailing edge, or we've hit the `maxWait` limit.\n                return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n                    (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n            }\n\n            function timerExpired() {\n                var time = now();\n                if (shouldInvoke(time)) {\n                    return trailingEdge(time);\n                }\n                // Restart the timer.\n                timerId = setTimeout(timerExpired, remainingWait(time));\n            }\n\n            function trailingEdge(time) {\n                timerId = undefined;\n\n                // Only invoke if we have `lastArgs` which means `func` has been\n                // debounced at least once.\n                if (trailing && lastArgs) {\n                    return invokeFunc(time);\n                }\n                lastArgs = lastThis = undefined;\n                return result;\n            }\n\n            function cancel() {\n                if (timerId !== undefined) {\n                    clearTimeout(timerId);\n                }\n                lastInvokeTime = 0;\n                lastArgs = lastCallTime = lastThis = timerId = undefined;\n            }\n\n            function flush() {\n                return timerId === undefined ? result : trailingEdge(now());\n            }\n\n            function debounced() {\n                var time = now(),\n                    isInvoking = shouldInvoke(time);\n\n                lastArgs = arguments;\n                lastThis = this;\n                lastCallTime = time;\n\n                if (isInvoking) {\n                    if (timerId === undefined) {\n                        return leadingEdge(lastCallTime);\n                    }\n                    if (maxing) {\n                        // Handle invocations in a tight loop.\n                        clearTimeout(timerId);\n                        timerId = setTimeout(timerExpired, wait);\n                        return invokeFunc(lastCallTime);\n                    }\n                }\n                if (timerId === undefined) {\n                    timerId = setTimeout(timerExpired, wait);\n                }\n                return result;\n            }\n            debounced.cancel = cancel;\n            debounced.flush = flush;\n            return debounced;\n        }\n\n        /**\n         * Defers invoking the `func` until the current call stack has cleared. Any\n         * additional arguments are provided to `func` when it's invoked.\n         *\n         * @static\n         * @memberOf _\n         * @since 0.1.0\n         * @category Function\n         * @param {Function} func The function to defer.\n         * @param {...*} [args] The arguments to invoke `func` with.\n         * @returns {number} Returns the timer id.\n         * @example\n         *\n         * _.defer(function(text) {\n         *   console.log(text);\n         * }, 'deferred');\n         * // => Logs 'deferred' after one millisecond.\n         */\n        var defer = baseRest(function(func, args) {\n            return baseDelay(func, 1, args);\n        });\n\n        /**\n         * Invokes `func` after `wait` milliseconds. Any additional arguments are\n         * provided to `func` when it's invoked.\n         *\n         * @static\n         * @memberOf _\n         * @since 0.1.0\n         * @category Function\n         * @param {Function} func The function to delay.\n         * @param {number} wait The number of milliseconds to delay invocation.\n         * @param {...*} [args] The arguments to invoke `func` with.\n         * @returns {number} Returns the timer id.\n         * @example\n         *\n         * _.delay(function(text) {\n         *   console.log(text);\n         * }, 1000, 'later');\n         * // => Logs 'later' after one second.\n         */\n        var delay = baseRest(function(func, wait, args) {\n            return baseDelay(func, toNumber(wait) || 0, args);\n        });\n\n        /**\n         * Creates a function that invokes `func` with `partials` prepended to the\n         * arguments it receives. This method is like `_.bind` except it does **not**\n         * alter the `this` binding.\n         *\n         * The `_.partial.placeholder` value, which defaults to `_` in monolithic\n         * builds, may be used as a placeholder for partially applied arguments.\n         *\n         * **Note:** This method doesn't set the \"length\" property of partially\n         * applied functions.\n         *\n         * @static\n         * @memberOf _\n         * @since 0.2.0\n         * @category Function\n         * @param {Function} func The function to partially apply arguments to.\n         * @param {...*} [partials] The arguments to be partially applied.\n         * @returns {Function} Returns the new partially applied function.\n         * @example\n         *\n         * function greet(greeting, name) {\n         *   return greeting + ' ' + name;\n         * }\n         *\n         * var sayHelloTo = _.partial(greet, 'hello');\n         * sayHelloTo('fred');\n         * // => 'hello fred'\n         *\n         * // Partially applied with placeholders.\n         * var greetFred = _.partial(greet, _, 'fred');\n         * greetFred('hi');\n         * // => 'hi fred'\n         */\n        var partial = baseRest(function(func, partials) {\n            var holders = replaceHolders(partials, getHolder(partial));\n            return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);\n        });\n\n        /**\n         * Creates a throttled function that only invokes `func` at most once per\n         * every `wait` milliseconds. The throttled function comes with a `cancel`\n         * method to cancel delayed `func` invocations and a `flush` method to\n         * immediately invoke them. Provide `options` to indicate whether `func`\n         * should be invoked on the leading and/or trailing edge of the `wait`\n         * timeout. The `func` is invoked with the last arguments provided to the\n         * throttled function. Subsequent calls to the throttled function return the\n         * result of the last `func` invocation.\n         *\n         * **Note:** If `leading` and `trailing` options are `true`, `func` is\n         * invoked on the trailing edge of the timeout only if the throttled function\n         * is invoked more than once during the `wait` timeout.\n         *\n         * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n         * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n         *\n         * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n         * for details over the differences between `_.throttle` and `_.debounce`.\n         *\n         * @static\n         * @memberOf _\n         * @since 0.1.0\n         * @category Function\n         * @param {Function} func The function to throttle.\n         * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n         * @param {Object} [options={}] The options object.\n         * @param {boolean} [options.leading=true]\n         *  Specify invoking on the leading edge of the timeout.\n         * @param {boolean} [options.trailing=true]\n         *  Specify invoking on the trailing edge of the timeout.\n         * @returns {Function} Returns the new throttled function.\n         * @example\n         *\n         * // Avoid excessively updating the position while scrolling.\n         * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n         *\n         * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n         * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n         * jQuery(element).on('click', throttled);\n         *\n         * // Cancel the trailing throttled invocation.\n         * jQuery(window).on('popstate', throttled.cancel);\n         */\n        function throttle(func, wait, options) {\n            var leading = true,\n                trailing = true;\n\n            if (typeof func != 'function') {\n                throw new TypeError(FUNC_ERROR_TEXT);\n            }\n            if (isObject(options)) {\n                leading = 'leading' in options ? !!options.leading : leading;\n                trailing = 'trailing' in options ? !!options.trailing : trailing;\n            }\n            return debounce(func, wait, {\n                'leading': leading,\n                'maxWait': wait,\n                'trailing': trailing\n            });\n        }\n\n        /*------------------------------------------------------------------------*/\n\n        /**\n         * Performs a\n         * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n         * comparison between two values to determine if they are equivalent.\n         *\n         * @static\n         * @memberOf _\n         * @since 4.0.0\n         * @category Lang\n         * @param {*} value The value to compare.\n         * @param {*} other The other value to compare.\n         * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n         * @example\n         *\n         * var object = { 'a': 1 };\n         * var other = { 'a': 1 };\n         *\n         * _.eq(object, object);\n         * // => true\n         *\n         * _.eq(object, other);\n         * // => false\n         *\n         * _.eq('a', 'a');\n         * // => true\n         *\n         * _.eq('a', Object('a'));\n         * // => false\n         *\n         * _.eq(NaN, NaN);\n         * // => true\n         */\n        function eq(value, other) {\n            return value === other || (value !== value && other !== other);\n        }\n\n        /**\n         * Checks if `value` is likely an `arguments` object.\n         *\n         * @static\n         * @memberOf _\n         * @since 0.1.0\n         * @category Lang\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n         *  else `false`.\n         * @example\n         *\n         * _.isArguments(function() { return arguments; }());\n         * // => true\n         *\n         * _.isArguments([1, 2, 3]);\n         * // => false\n         */\n        var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n            return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n                !propertyIsEnumerable.call(value, 'callee');\n        };\n\n        /**\n         * Checks if `value` is classified as an `Array` object.\n         *\n         * @static\n         * @memberOf _\n         * @since 0.1.0\n         * @category Lang\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n         * @example\n         *\n         * _.isArray([1, 2, 3]);\n         * // => true\n         *\n         * _.isArray(document.body.children);\n         * // => false\n         *\n         * _.isArray('abc');\n         * // => false\n         *\n         * _.isArray(_.noop);\n         * // => false\n         */\n        var isArray = Array.isArray;\n\n        /**\n         * Checks if `value` is array-like. A value is considered array-like if it's\n         * not a function and has a `value.length` that's an integer greater than or\n         * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n         *\n         * @static\n         * @memberOf _\n         * @since 4.0.0\n         * @category Lang\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n         * @example\n         *\n         * _.isArrayLike([1, 2, 3]);\n         * // => true\n         *\n         * _.isArrayLike(document.body.children);\n         * // => true\n         *\n         * _.isArrayLike('abc');\n         * // => true\n         *\n         * _.isArrayLike(_.noop);\n         * // => false\n         */\n        function isArrayLike(value) {\n            return value != null && isLength(value.length) && !isFunction(value);\n        }\n\n        /**\n         * Checks if `value` is a buffer.\n         *\n         * @static\n         * @memberOf _\n         * @since 4.3.0\n         * @category Lang\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n         * @example\n         *\n         * _.isBuffer(new Buffer(2));\n         * // => true\n         *\n         * _.isBuffer(new Uint8Array(2));\n         * // => false\n         */\n        var isBuffer = nativeIsBuffer || stubFalse;\n\n        /**\n         * Checks if `value` is classified as a `Function` object.\n         *\n         * @static\n         * @memberOf _\n         * @since 0.1.0\n         * @category Lang\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n         * @example\n         *\n         * _.isFunction(_);\n         * // => true\n         *\n         * _.isFunction(/abc/);\n         * // => false\n         */\n        function isFunction(value) {\n            if (!isObject(value)) {\n                return false;\n            }\n            // The use of `Object#toString` avoids issues with the `typeof` operator\n            // in Safari 9 which returns 'object' for typed arrays and other constructors.\n            var tag = baseGetTag(value);\n            return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n        }\n\n        /**\n         * Checks if `value` is a valid array-like length.\n         *\n         * **Note:** This method is loosely based on\n         * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n         *\n         * @static\n         * @memberOf _\n         * @since 4.0.0\n         * @category Lang\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n         * @example\n         *\n         * _.isLength(3);\n         * // => true\n         *\n         * _.isLength(Number.MIN_VALUE);\n         * // => false\n         *\n         * _.isLength(Infinity);\n         * // => false\n         *\n         * _.isLength('3');\n         * // => false\n         */\n        function isLength(value) {\n            return typeof value == 'number' &&\n                value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n        }\n\n        /**\n         * Checks if `value` is the\n         * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n         * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n         *\n         * @static\n         * @memberOf _\n         * @since 0.1.0\n         * @category Lang\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n         * @example\n         *\n         * _.isObject({});\n         * // => true\n         *\n         * _.isObject([1, 2, 3]);\n         * // => true\n         *\n         * _.isObject(_.noop);\n         * // => true\n         *\n         * _.isObject(null);\n         * // => false\n         */\n        function isObject(value) {\n            var type = typeof value;\n            return value != null && (type == 'object' || type == 'function');\n        }\n\n        /**\n         * Checks if `value` is object-like. A value is object-like if it's not `null`\n         * and has a `typeof` result of \"object\".\n         *\n         * @static\n         * @memberOf _\n         * @since 4.0.0\n         * @category Lang\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n         * @example\n         *\n         * _.isObjectLike({});\n         * // => true\n         *\n         * _.isObjectLike([1, 2, 3]);\n         * // => true\n         *\n         * _.isObjectLike(_.noop);\n         * // => false\n         *\n         * _.isObjectLike(null);\n         * // => false\n         */\n        function isObjectLike(value) {\n            return value != null && typeof value == 'object';\n        }\n\n        /**\n         * Checks if `value` is classified as a `String` primitive or object.\n         *\n         * @static\n         * @since 0.1.0\n         * @memberOf _\n         * @category Lang\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n         * @example\n         *\n         * _.isString('abc');\n         * // => true\n         *\n         * _.isString(1);\n         * // => false\n         */\n        function isString(value) {\n            return typeof value == 'string' ||\n                (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n        }\n\n        /**\n         * Checks if `value` is classified as a `Symbol` primitive or object.\n         *\n         * @static\n         * @memberOf _\n         * @since 4.0.0\n         * @category Lang\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n         * @example\n         *\n         * _.isSymbol(Symbol.iterator);\n         * // => true\n         *\n         * _.isSymbol('abc');\n         * // => false\n         */\n        function isSymbol(value) {\n            return typeof value == 'symbol' ||\n                (isObjectLike(value) && baseGetTag(value) == symbolTag);\n        }\n\n        /**\n         * Checks if `value` is classified as a typed array.\n         *\n         * @static\n         * @memberOf _\n         * @since 3.0.0\n         * @category Lang\n         * @param {*} value The value to check.\n         * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n         * @example\n         *\n         * _.isTypedArray(new Uint8Array);\n         * // => true\n         *\n         * _.isTypedArray([]);\n         * // => false\n         */\n        var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n        /**\n         * Converts `value` to a finite number.\n         *\n         * @static\n         * @memberOf _\n         * @since 4.12.0\n         * @category Lang\n         * @param {*} value The value to convert.\n         * @returns {number} Returns the converted number.\n         * @example\n         *\n         * _.toFinite(3.2);\n         * // => 3.2\n         *\n         * _.toFinite(Number.MIN_VALUE);\n         * // => 5e-324\n         *\n         * _.toFinite(Infinity);\n         * // => 1.7976931348623157e+308\n         *\n         * _.toFinite('3.2');\n         * // => 3.2\n         */\n        function toFinite(value) {\n            if (!value) {\n                return value === 0 ? value : 0;\n            }\n            value = toNumber(value);\n            if (value === INFINITY || value === -INFINITY) {\n                var sign = (value < 0 ? -1 : 1);\n                return sign * MAX_INTEGER;\n            }\n            return value === value ? value : 0;\n        }\n\n        /**\n         * Converts `value` to an integer.\n         *\n         * **Note:** This method is loosely based on\n         * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n         *\n         * @static\n         * @memberOf _\n         * @since 4.0.0\n         * @category Lang\n         * @param {*} value The value to convert.\n         * @returns {number} Returns the converted integer.\n         * @example\n         *\n         * _.toInteger(3.2);\n         * // => 3\n         *\n         * _.toInteger(Number.MIN_VALUE);\n         * // => 0\n         *\n         * _.toInteger(Infinity);\n         * // => 1.7976931348623157e+308\n         *\n         * _.toInteger('3.2');\n         * // => 3\n         */\n        function toInteger(value) {\n            var result = toFinite(value),\n                remainder = result % 1;\n\n            return result === result ? (remainder ? result - remainder : result) : 0;\n        }\n\n        /**\n         * Converts `value` to a number.\n         *\n         * @static\n         * @memberOf _\n         * @since 4.0.0\n         * @category Lang\n         * @param {*} value The value to process.\n         * @returns {number} Returns the number.\n         * @example\n         *\n         * _.toNumber(3.2);\n         * // => 3.2\n         *\n         * _.toNumber(Number.MIN_VALUE);\n         * // => 5e-324\n         *\n         * _.toNumber(Infinity);\n         * // => Infinity\n         *\n         * _.toNumber('3.2');\n         * // => 3.2\n         */\n        function toNumber(value) {\n            if (typeof value == 'number') {\n                return value;\n            }\n            if (isSymbol(value)) {\n                return NAN;\n            }\n            if (isObject(value)) {\n                var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n                value = isObject(other) ? (other + '') : other;\n            }\n            if (typeof value != 'string') {\n                return value === 0 ? value : +value;\n            }\n            value = value.replace(reTrim, '');\n            var isBinary = reIsBinary.test(value);\n            return (isBinary || reIsOctal.test(value))\n                ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n                : (reIsBadHex.test(value) ? NAN : +value);\n        }\n\n        /*------------------------------------------------------------------------*/\n\n        /**\n         * Assigns own enumerable string keyed properties of source objects to the\n         * destination object. Source objects are applied from left to right.\n         * Subsequent sources overwrite property assignments of previous sources.\n         *\n         * **Note:** This method mutates `object` and is loosely based on\n         * [`Object.assign`](https://mdn.io/Object/assign).\n         *\n         * @static\n         * @memberOf _\n         * @since 0.10.0\n         * @category Object\n         * @param {Object} object The destination object.\n         * @param {...Object} [sources] The source objects.\n         * @returns {Object} Returns `object`.\n         * @see _.assignIn\n         * @example\n         *\n         * function Foo() {\n         *   this.a = 1;\n         * }\n         *\n         * function Bar() {\n         *   this.c = 3;\n         * }\n         *\n         * Foo.prototype.b = 2;\n         * Bar.prototype.d = 4;\n         *\n         * _.assign({ 'a': 0 }, new Foo, new Bar);\n         * // => { 'a': 1, 'c': 3 }\n         */\n        var assign = createAssigner(function(object, source) {\n            if (isPrototype(source) || isArrayLike(source)) {\n                copyObject(source, keys(source), object);\n                return;\n            }\n            for (var key in source) {\n                if (hasOwnProperty.call(source, key)) {\n                    assignValue(object, key, source[key]);\n                }\n            }\n        });\n\n        /**\n         * This method is like `_.assign` except that it iterates over own and\n         * inherited source properties.\n         *\n         * **Note:** This method mutates `object`.\n         *\n         * @static\n         * @memberOf _\n         * @since 4.0.0\n         * @alias extend\n         * @category Object\n         * @param {Object} object The destination object.\n         * @param {...Object} [sources] The source objects.\n         * @returns {Object} Returns `object`.\n         * @see _.assign\n         * @example\n         *\n         * function Foo() {\n         *   this.a = 1;\n         * }\n         *\n         * function Bar() {\n         *   this.c = 3;\n         * }\n         *\n         * Foo.prototype.b = 2;\n         * Bar.prototype.d = 4;\n         *\n         * _.assignIn({ 'a': 0 }, new Foo, new Bar);\n         * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }\n         */\n        var assignIn = createAssigner(function(object, source) {\n            copyObject(source, keysIn(source), object);\n        });\n\n        /**\n         * Creates an object that inherits from the `prototype` object. If a\n         * `properties` object is given, its own enumerable string keyed properties\n         * are assigned to the created object.\n         *\n         * @static\n         * @memberOf _\n         * @since 2.3.0\n         * @category Object\n         * @param {Object} prototype The object to inherit from.\n         * @param {Object} [properties] The properties to assign to the object.\n         * @returns {Object} Returns the new object.\n         * @example\n         *\n         * function Shape() {\n         *   this.x = 0;\n         *   this.y = 0;\n         * }\n         *\n         * function Circle() {\n         *   Shape.call(this);\n         * }\n         *\n         * Circle.prototype = _.create(Shape.prototype, {\n         *   'constructor': Circle\n         * });\n         *\n         * var circle = new Circle;\n         * circle instanceof Circle;\n         * // => true\n         *\n         * circle instanceof Shape;\n         * // => true\n         */\n        function create(prototype, properties) {\n            var result = baseCreate(prototype);\n            return properties == null ? result : baseAssign(result, properties);\n        }\n\n        /**\n         * Assigns own and inherited enumerable string keyed properties of source\n         * objects to the destination object for all destination properties that\n         * resolve to `undefined`. Source objects are applied from left to right.\n         * Once a property is set, additional values of the same property are ignored.\n         *\n         * **Note:** This method mutates `object`.\n         *\n         * @static\n         * @since 0.1.0\n         * @memberOf _\n         * @category Object\n         * @param {Object} object The destination object.\n         * @param {...Object} [sources] The source objects.\n         * @returns {Object} Returns `object`.\n         * @see _.defaultsDeep\n         * @example\n         *\n         * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n         * // => { 'a': 1, 'b': 2 }\n         */\n        var defaults = baseRest(function(object, sources) {\n            object = Object(object);\n\n            var index = -1;\n            var length = sources.length;\n            var guard = length > 2 ? sources[2] : undefined;\n\n            if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n                length = 1;\n            }\n\n            while (++index < length) {\n                var source = sources[index];\n                var props = keysIn(source);\n                var propsIndex = -1;\n                var propsLength = props.length;\n\n                while (++propsIndex < propsLength) {\n                    var key = props[propsIndex];\n                    var value = object[key];\n\n                    if (value === undefined ||\n                        (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n                        object[key] = source[key];\n                    }\n                }\n            }\n\n            return object;\n        });\n\n        /**\n         * Creates an array of the own enumerable property names of `object`.\n         *\n         * **Note:** Non-object values are coerced to objects. See the\n         * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n         * for more details.\n         *\n         * @static\n         * @since 0.1.0\n         * @memberOf _\n         * @category Object\n         * @param {Object} object The object to query.\n         * @returns {Array} Returns the array of property names.\n         * @example\n         *\n         * function Foo() {\n         *   this.a = 1;\n         *   this.b = 2;\n         * }\n         *\n         * Foo.prototype.c = 3;\n         *\n         * _.keys(new Foo);\n         * // => ['a', 'b'] (iteration order is not guaranteed)\n         *\n         * _.keys('hi');\n         * // => ['0', '1']\n         */\n        function keys(object) {\n            return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n        }\n\n        /**\n         * Creates an array of the own and inherited enumerable property names of `object`.\n         *\n         * **Note:** Non-object values are coerced to objects.\n         *\n         * @static\n         * @memberOf _\n         * @since 3.0.0\n         * @category Object\n         * @param {Object} object The object to query.\n         * @returns {Array} Returns the array of property names.\n         * @example\n         *\n         * function Foo() {\n         *   this.a = 1;\n         *   this.b = 2;\n         * }\n         *\n         * Foo.prototype.c = 3;\n         *\n         * _.keysIn(new Foo);\n         * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n         */\n        function keysIn(object) {\n            return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n        }\n\n        /*------------------------------------------------------------------------*/\n\n        /**\n         * Creates a function that returns `value`.\n         *\n         * @static\n         * @memberOf _\n         * @since 2.4.0\n         * @category Util\n         * @param {*} value The value to return from the new function.\n         * @returns {Function} Returns the new constant function.\n         * @example\n         *\n         * var objects = _.times(2, _.constant({ 'a': 1 }));\n         *\n         * console.log(objects);\n         * // => [{ 'a': 1 }, { 'a': 1 }]\n         *\n         * console.log(objects[0] === objects[1]);\n         * // => true\n         */\n        function constant(value) {\n            return function() {\n                return value;\n            };\n        }\n\n        /**\n         * This method returns the first argument it receives.\n         *\n         * @static\n         * @since 0.1.0\n         * @memberOf _\n         * @category Util\n         * @param {*} value Any value.\n         * @returns {*} Returns `value`.\n         * @example\n         *\n         * var object = { 'a': 1 };\n         *\n         * console.log(_.identity(object) === object);\n         * // => true\n         */\n        function identity(value) {\n            return value;\n        }\n\n        /**\n         * This method returns `undefined`.\n         *\n         * @static\n         * @memberOf _\n         * @since 2.3.0\n         * @category Util\n         * @example\n         *\n         * _.times(2, _.noop);\n         * // => [undefined, undefined]\n         */\n        function noop() {\n            // No operation performed.\n        }\n\n        /**\n         * This method returns `false`.\n         *\n         * @static\n         * @memberOf _\n         * @since 4.13.0\n         * @category Util\n         * @returns {boolean} Returns `false`.\n         * @example\n         *\n         * _.times(2, _.stubFalse);\n         * // => [false, false]\n         */\n        function stubFalse() {\n            return false;\n        }\n\n        /*------------------------------------------------------------------------*/\n\n        // Add methods that return wrapped values in chain sequences.\n        lodash.assign = assign;\n        lodash.assignIn = assignIn;\n        lodash.bind = bind;\n        lodash.constant = constant;\n        lodash.create = create;\n        lodash.debounce = debounce;\n        lodash.defaults = defaults;\n        lodash.defer = defer;\n        lodash.delay = delay;\n        lodash.keys = keys;\n        lodash.keysIn = keysIn;\n        lodash.partial = partial;\n        lodash.throttle = throttle;\n\n        // Add aliases.\n        lodash.extend = assignIn;\n\n        /*------------------------------------------------------------------------*/\n\n        // Add methods that return unwrapped values in chain sequences.\n        lodash.eq = eq;\n        lodash.identity = identity;\n        lodash.isArguments = isArguments;\n        lodash.isArray = isArray;\n        lodash.isArrayLike = isArrayLike;\n        lodash.isBuffer = isBuffer;\n        lodash.isFunction = isFunction;\n        lodash.isLength = isLength;\n        lodash.isObject = isObject;\n        lodash.isObjectLike = isObjectLike;\n        lodash.isString = isString;\n        lodash.isSymbol = isSymbol;\n        lodash.isTypedArray = isTypedArray;\n        lodash.stubFalse = stubFalse;\n        lodash.noop = noop;\n        lodash.now = now;\n        lodash.toFinite = toFinite;\n        lodash.toInteger = toInteger;\n        lodash.toNumber = toNumber;\n\n        /*------------------------------------------------------------------------*/\n\n        /**\n         * The semantic version number.\n         *\n         * @static\n         * @memberOf _\n         * @type {string}\n         */\n        lodash.VERSION = VERSION;\n\n        // Assign default placeholders.\n        arrayEach(['bind', 'partial'], function(methodName) {\n            lodash[methodName].placeholder = lodash;\n        });\n\n        /*--------------------------------------------------------------------------*/\n\n        // Some AMD build optimizers, like r.js, check for condition patterns like:\n        if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {\n            // Expose Lodash on the global object to prevent errors when Lodash is\n            // loaded by a script tag in the presence of an AMD loader.\n            // See http://requirejs.org/docs/errors.html#mismatch for more details.\n            // Use `_.noConflict` to remove Lodash from the global object.\n            root._ = lodash;\n\n            // Define as an anonymous module so, through path mapping, it can be\n            // referenced as the \"underscore\" module.\n            define(function() {\n                return lodash;\n            });\n        }\n        // Check for `exports` after `define` in case a build optimizer adds it.\n        else if (freeModule) {\n            // Export for Node.js.\n            (freeModule.exports = lodash)._ = lodash;\n            // Export for CommonJS support.\n            freeExports._ = lodash;\n        }\n        else {\n            // Export to the global object.\n            root._ = lodash;\n        }\n        return lodash; }.call(this));\n\n    /*!\n     * @overview es6-promise - a tiny implementation of Promises/A+.\n     * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)\n     * @license   Licensed under MIT license\n     *            See https://raw.githubusercontent.com/jakearchibald/es6-promise/master/LICENSE\n     * @version   2.0.1\n     */\n    (function() {\n        \"use strict\";\n\n        function $$utils$$objectOrFunction(x) {\n            return typeof x === 'function' || (typeof x === 'object' && x !== null);\n        }\n\n        function $$utils$$isFunction(x) {\n            return typeof x === 'function';\n        }\n\n        function $$utils$$isMaybeThenable(x) {\n            return typeof x === 'object' && x !== null;\n        }\n\n        var $$utils$$_isArray;\n\n        if (!Array.isArray) {\n            $$utils$$_isArray = function(x) {\n                return Object.prototype.toString.call(x) === '[object Array]';\n            };\n        } else {\n            $$utils$$_isArray = Array.isArray;\n        }\n\n        var $$utils$$isArray = $$utils$$_isArray;\n        var $$utils$$now = Date.now || function() { return new Date().getTime(); };\n        function $$utils$$F() { }\n\n        var $$utils$$o_create = (Object.create || function(o) {\n            if (arguments.length > 1) {\n                throw new Error('Second argument not supported');\n            }\n            if (typeof o !== 'object') {\n                throw new TypeError('Argument must be an object');\n            }\n            $$utils$$F.prototype = o;\n            return new $$utils$$F();\n        });\n\n        var $$asap$$len = 0;\n\n        var $$asap$$default = function asap(callback, arg) {\n            $$asap$$queue[$$asap$$len] = callback;\n            $$asap$$queue[$$asap$$len + 1] = arg;\n            $$asap$$len += 2;\n            if ($$asap$$len === 2) {\n                // If len is 1, that means that we need to schedule an async flush.\n                // If additional callbacks are queued before the queue is flushed, they\n                // will be processed by this flush that we are scheduling.\n                $$asap$$scheduleFlush();\n            }\n        };\n\n        var $$asap$$browserGlobal = (typeof window !== 'undefined') ? window : {};\n        var $$asap$$BrowserMutationObserver = $$asap$$browserGlobal.MutationObserver || $$asap$$browserGlobal.WebKitMutationObserver;\n\n        // test for web worker but not in IE10\n        var $$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' &&\n            typeof importScripts !== 'undefined' &&\n            typeof MessageChannel !== 'undefined';\n\n        // node\n        function $$asap$$useNextTick() {\n            return function() {\n                process.nextTick($$asap$$flush);\n            };\n        }\n\n        function $$asap$$useMutationObserver() {\n            var iterations = 0;\n            var observer = new $$asap$$BrowserMutationObserver($$asap$$flush);\n            var node = document.createTextNode('');\n            observer.observe(node, { characterData: true });\n\n            return function() {\n                node.data = (iterations = ++iterations % 2);\n            };\n        }\n\n        // web worker\n        function $$asap$$useMessageChannel() {\n            var channel = new MessageChannel();\n            channel.port1.onmessage = $$asap$$flush;\n            return function() {\n                channel.port2.postMessage(0);\n            };\n        }\n\n        function $$asap$$useSetTimeout() {\n            return function() {\n                setTimeout($$asap$$flush, 1);\n            };\n        }\n\n        var $$asap$$queue = new Array(1000);\n\n        function $$asap$$flush() {\n            for (var i = 0; i < $$asap$$len; i += 2) {\n                var callback = $$asap$$queue[i];\n                var arg = $$asap$$queue[i + 1];\n\n                callback(arg);\n\n                $$asap$$queue[i] = undefined;\n                $$asap$$queue[i + 1] = undefined;\n            }\n\n            $$asap$$len = 0;\n        }\n\n        var $$asap$$scheduleFlush;\n\n        // Decide what async method to use to triggering processing of queued callbacks:\n        if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {\n            $$asap$$scheduleFlush = $$asap$$useNextTick();\n        } else if ($$asap$$BrowserMutationObserver) {\n            $$asap$$scheduleFlush = $$asap$$useMutationObserver();\n        } else if ($$asap$$isWorker) {\n            $$asap$$scheduleFlush = $$asap$$useMessageChannel();\n        } else {\n            $$asap$$scheduleFlush = $$asap$$useSetTimeout();\n        }\n\n        function $$$internal$$noop() { }\n        var $$$internal$$PENDING = void 0;\n        var $$$internal$$FULFILLED = 1;\n        var $$$internal$$REJECTED = 2;\n        var $$$internal$$GET_THEN_ERROR = new $$$internal$$ErrorObject();\n\n        function $$$internal$$selfFullfillment() {\n            return new TypeError(\"You cannot resolve a promise with itself\");\n        }\n\n        function $$$internal$$cannotReturnOwn() {\n            return new TypeError('A promises callback cannot return that same promise.');\n        }\n\n        function $$$internal$$getThen(promise) {\n            try {\n                return promise.then;\n            } catch (error) {\n                $$$internal$$GET_THEN_ERROR.error = error;\n                return $$$internal$$GET_THEN_ERROR;\n            }\n        }\n\n        function $$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) {\n            try {\n                then.call(value, fulfillmentHandler, rejectionHandler);\n            } catch (e) {\n                return e;\n            }\n        }\n\n        function $$$internal$$handleForeignThenable(promise, thenable, then) {\n            $$asap$$default(function(promise) {\n                var sealed = false;\n                var error = $$$internal$$tryThen(then, thenable, function(value) {\n                    if (sealed) { return; }\n                    sealed = true;\n                    if (thenable !== value) {\n                        $$$internal$$resolve(promise, value);\n                    } else {\n                        $$$internal$$fulfill(promise, value);\n                    }\n                }, function(reason) {\n                    if (sealed) { return; }\n                    sealed = true;\n\n                    $$$internal$$reject(promise, reason);\n                }, 'Settle: ' + (promise._label || ' unknown promise'));\n\n                if (!sealed && error) {\n                    sealed = true;\n                    $$$internal$$reject(promise, error);\n                }\n            }, promise);\n        }\n\n        function $$$internal$$handleOwnThenable(promise, thenable) {\n            if (thenable._state === $$$internal$$FULFILLED) {\n                $$$internal$$fulfill(promise, thenable._result);\n            } else if (promise._state === $$$internal$$REJECTED) {\n                $$$internal$$reject(promise, thenable._result);\n            } else {\n                $$$internal$$subscribe(thenable, undefined, function(value) {\n                    $$$internal$$resolve(promise, value);\n                }, function(reason) {\n                    $$$internal$$reject(promise, reason);\n                });\n            }\n        }\n\n        function $$$internal$$handleMaybeThenable(promise, maybeThenable) {\n            if (maybeThenable.constructor === promise.constructor) {\n                $$$internal$$handleOwnThenable(promise, maybeThenable);\n            } else {\n                var then = $$$internal$$getThen(maybeThenable);\n\n                if (then === $$$internal$$GET_THEN_ERROR) {\n                    $$$internal$$reject(promise, $$$internal$$GET_THEN_ERROR.error);\n                } else if (then === undefined) {\n                    $$$internal$$fulfill(promise, maybeThenable);\n                } else if ($$utils$$isFunction(then)) {\n                    $$$internal$$handleForeignThenable(promise, maybeThenable, then);\n                } else {\n                    $$$internal$$fulfill(promise, maybeThenable);\n                }\n            }\n        }\n\n        function $$$internal$$resolve(promise, value) {\n            if (promise === value) {\n                $$$internal$$reject(promise, $$$internal$$selfFullfillment());\n            } else if ($$utils$$objectOrFunction(value)) {\n                $$$internal$$handleMaybeThenable(promise, value);\n            } else {\n                $$$internal$$fulfill(promise, value);\n            }\n        }\n\n        function $$$internal$$publishRejection(promise) {\n            if (promise._onerror) {\n                promise._onerror(promise._result);\n            }\n\n            $$$internal$$publish(promise);\n        }\n\n        function $$$internal$$fulfill(promise, value) {\n            if (promise._state !== $$$internal$$PENDING) { return; }\n\n            promise._result = value;\n            promise._state = $$$internal$$FULFILLED;\n\n            if (promise._subscribers.length === 0) {\n            } else {\n                $$asap$$default($$$internal$$publish, promise);\n            }\n        }\n\n        function $$$internal$$reject(promise, reason) {\n            if (promise._state !== $$$internal$$PENDING) { return; }\n            promise._state = $$$internal$$REJECTED;\n            promise._result = reason;\n\n            $$asap$$default($$$internal$$publishRejection, promise);\n        }\n\n        function $$$internal$$subscribe(parent, child, onFulfillment, onRejection) {\n            var subscribers = parent._subscribers;\n            var length = subscribers.length;\n\n            parent._onerror = null;\n\n            subscribers[length] = child;\n            subscribers[length + $$$internal$$FULFILLED] = onFulfillment;\n            subscribers[length + $$$internal$$REJECTED] = onRejection;\n\n            if (length === 0 && parent._state) {\n                $$asap$$default($$$internal$$publish, parent);\n            }\n        }\n\n        function $$$internal$$publish(promise) {\n            var subscribers = promise._subscribers;\n            var settled = promise._state;\n\n            if (subscribers.length === 0) { return; }\n\n            var child, callback, detail = promise._result;\n\n            for (var i = 0; i < subscribers.length; i += 3) {\n                child = subscribers[i];\n                callback = subscribers[i + settled];\n\n                if (child) {\n                    $$$internal$$invokeCallback(settled, child, callback, detail);\n                } else {\n                    callback(detail);\n                }\n            }\n\n            promise._subscribers.length = 0;\n        }\n\n        function $$$internal$$ErrorObject() {\n            this.error = null;\n        }\n\n        var $$$internal$$TRY_CATCH_ERROR = new $$$internal$$ErrorObject();\n\n        function $$$internal$$tryCatch(callback, detail) {\n            try {\n                return callback(detail);\n            } catch (e) {\n                $$$internal$$TRY_CATCH_ERROR.error = e;\n                return $$$internal$$TRY_CATCH_ERROR;\n            }\n        }\n\n        function $$$internal$$invokeCallback(settled, promise, callback, detail) {\n            var hasCallback = $$utils$$isFunction(callback),\n                value, error, succeeded, failed;\n\n            if (hasCallback) {\n                value = $$$internal$$tryCatch(callback, detail);\n\n                if (value === $$$internal$$TRY_CATCH_ERROR) {\n                    failed = true;\n                    error = value.error;\n                    value = null;\n                } else {\n                    succeeded = true;\n                }\n\n                if (promise === value) {\n                    $$$internal$$reject(promise, $$$internal$$cannotReturnOwn());\n                    return;\n                }\n\n            } else {\n                value = detail;\n                succeeded = true;\n            }\n\n            if (promise._state !== $$$internal$$PENDING) {\n                // noop\n            } else if (hasCallback && succeeded) {\n                $$$internal$$resolve(promise, value);\n            } else if (failed) {\n                $$$internal$$reject(promise, error);\n            } else if (settled === $$$internal$$FULFILLED) {\n                $$$internal$$fulfill(promise, value);\n            } else if (settled === $$$internal$$REJECTED) {\n                $$$internal$$reject(promise, value);\n            }\n        }\n\n        function $$$internal$$initializePromise(promise, resolver) {\n            try {\n                resolver(function resolvePromise(value) {\n                    $$$internal$$resolve(promise, value);\n                }, function rejectPromise(reason) {\n                    $$$internal$$reject(promise, reason);\n                });\n            } catch (e) {\n                $$$internal$$reject(promise, e);\n            }\n        }\n\n        function $$$enumerator$$makeSettledResult(state, position, value) {\n            if (state === $$$internal$$FULFILLED) {\n                return {\n                    state: 'fulfilled',\n                    value: value\n                };\n            } else {\n                return {\n                    state: 'rejected',\n                    reason: value\n                };\n            }\n        }\n\n        function $$$enumerator$$Enumerator(Constructor, input, abortOnReject, label) {\n            this._instanceConstructor = Constructor;\n            this.promise = new Constructor($$$internal$$noop, label);\n            this._abortOnReject = abortOnReject;\n\n            if (this._validateInput(input)) {\n                this._input = input;\n                this.length = input.length;\n                this._remaining = input.length;\n\n                this._init();\n\n                if (this.length === 0) {\n                    $$$internal$$fulfill(this.promise, this._result);\n                } else {\n                    this.length = this.length || 0;\n                    this._enumerate();\n                    if (this._remaining === 0) {\n                        $$$internal$$fulfill(this.promise, this._result);\n                    }\n                }\n            } else {\n                $$$internal$$reject(this.promise, this._validationError());\n            }\n        }\n\n        $$$enumerator$$Enumerator.prototype._validateInput = function(input) {\n            return $$utils$$isArray(input);\n        };\n\n        $$$enumerator$$Enumerator.prototype._validationError = function() {\n            return new Error('Array Methods must be provided an Array');\n        };\n\n        $$$enumerator$$Enumerator.prototype._init = function() {\n            this._result = new Array(this.length);\n        };\n\n        var $$$enumerator$$default = $$$enumerator$$Enumerator;\n\n        $$$enumerator$$Enumerator.prototype._enumerate = function() {\n            var length = this.length;\n            var promise = this.promise;\n            var input = this._input;\n\n            for (var i = 0; promise._state === $$$internal$$PENDING && i < length; i++) {\n                this._eachEntry(input[i], i);\n            }\n        };\n\n        $$$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) {\n            var c = this._instanceConstructor;\n            if ($$utils$$isMaybeThenable(entry)) {\n                if (entry.constructor === c && entry._state !== $$$internal$$PENDING) {\n                    entry._onerror = null;\n                    this._settledAt(entry._state, i, entry._result);\n                } else {\n                    this._willSettleAt(c.resolve(entry), i);\n                }\n            } else {\n                this._remaining--;\n                this._result[i] = this._makeResult($$$internal$$FULFILLED, i, entry);\n            }\n        };\n\n        $$$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) {\n            var promise = this.promise;\n\n            if (promise._state === $$$internal$$PENDING) {\n                this._remaining--;\n\n                if (this._abortOnReject && state === $$$internal$$REJECTED) {\n                    $$$internal$$reject(promise, value);\n                } else {\n                    this._result[i] = this._makeResult(state, i, value);\n                }\n            }\n\n            if (this._remaining === 0) {\n                $$$internal$$fulfill(promise, this._result);\n            }\n        };\n\n        $$$enumerator$$Enumerator.prototype._makeResult = function(state, i, value) {\n            return value;\n        };\n\n        $$$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) {\n            var enumerator = this;\n\n            $$$internal$$subscribe(promise, undefined, function(value) {\n                enumerator._settledAt($$$internal$$FULFILLED, i, value);\n            }, function(reason) {\n                enumerator._settledAt($$$internal$$REJECTED, i, reason);\n            });\n        };\n\n        var $$promise$all$$default = function all(entries, label) {\n            return new $$$enumerator$$default(this, entries, true /* abort on reject */, label).promise;\n        };\n\n        var $$promise$race$$default = function race(entries, label) {\n            /*jshint validthis:true */\n            var Constructor = this;\n\n            var promise = new Constructor($$$internal$$noop, label);\n\n            if (!$$utils$$isArray(entries)) {\n                $$$internal$$reject(promise, new TypeError('You must pass an array to race.'));\n                return promise;\n            }\n\n            var length = entries.length;\n\n            function onFulfillment(value) {\n                $$$internal$$resolve(promise, value);\n            }\n\n            function onRejection(reason) {\n                $$$internal$$reject(promise, reason);\n            }\n\n            for (var i = 0; promise._state === $$$internal$$PENDING && i < length; i++) {\n                $$$internal$$subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection);\n            }\n\n            return promise;\n        };\n\n        var $$promise$resolve$$default = function resolve(object, label) {\n            /*jshint validthis:true */\n            var Constructor = this;\n\n            if (object && typeof object === 'object' && object.constructor === Constructor) {\n                return object;\n            }\n\n            var promise = new Constructor($$$internal$$noop, label);\n            $$$internal$$resolve(promise, object);\n            return promise;\n        };\n\n        var $$promise$reject$$default = function reject(reason, label) {\n            /*jshint validthis:true */\n            var Constructor = this;\n            var promise = new Constructor($$$internal$$noop, label);\n            $$$internal$$reject(promise, reason);\n            return promise;\n        };\n\n        var $$es6$promise$promise$$counter = 0;\n\n        function $$es6$promise$promise$$needsResolver() {\n            throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');\n        }\n\n        function $$es6$promise$promise$$needsNew() {\n            throw new TypeError(\"Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.\");\n        }\n\n        var $$es6$promise$promise$$default = $$es6$promise$promise$$Promise;\n\n        /**\n         Promise objects represent the eventual result of an asynchronous operation. The\n         primary way of interacting with a promise is through its `then` method, which\n         registers callbacks to receive either a promise’s eventual value or the reason\n         why the promise cannot be fulfilled.\n\n         Terminology\n         -----------\n\n         - `promise` is an object or function with a `then` method whose behavior conforms to this specification.\n         - `thenable` is an object or function that defines a `then` method.\n         - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).\n         - `exception` is a value that is thrown using the throw statement.\n         - `reason` is a value that indicates why a promise was rejected.\n         - `settled` the final resting state of a promise, fulfilled or rejected.\n\n         A promise can be in one of three states: pending, fulfilled, or rejected.\n\n         Promises that are fulfilled have a fulfillment value and are in the fulfilled\n         state.  Promises that are rejected have a rejection reason and are in the\n         rejected state.  A fulfillment value is never a thenable.\n\n         Promises can also be said to *resolve* a value.  If this value is also a\n         promise, then the original promise's settled state will match the value's\n         settled state.  So a promise that *resolves* a promise that rejects will\n         itself reject, and a promise that *resolves* a promise that fulfills will\n         itself fulfill.\n\n\n         Basic Usage:\n         ------------\n\n         ```js\n         var promise = new Promise(function(resolve, reject) {\n            // on success\n            resolve(value);\n\n            // on failure\n            reject(reason);\n          });\n\n         promise.then(function(value) {\n            // on fulfillment\n          }, function(reason) {\n            // on rejection\n          });\n         ```\n\n         Advanced Usage:\n         ---------------\n\n         Promises shine when abstracting away asynchronous interactions such as\n         `XMLHttpRequest`s.\n\n         ```js\n         function getJSON(url) {\n            return new Promise(function(resolve, reject){\n              var xhr = new XMLHttpRequest();\n\n              xhr.open('GET', url);\n              xhr.onreadystatechange = handler;\n              xhr.responseType = 'json';\n              xhr.setRequestHeader('Accept', 'application/json');\n              xhr.send();\n\n              function handler() {\n                if (this.readyState === this.DONE) {\n                  if (this.status === 200) {\n                    resolve(this.response);\n                  } else {\n                    reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));\n                  }\n                }\n              };\n            });\n          }\n\n         getJSON('/posts.json').then(function(json) {\n            // on fulfillment\n          }, function(reason) {\n            // on rejection\n          });\n         ```\n\n         Unlike callbacks, promises are great composable primitives.\n\n         ```js\n         Promise.all([\n         getJSON('/posts'),\n         getJSON('/comments')\n         ]).then(function(values){\n            values[0] // => postsJSON\n            values[1] // => commentsJSON\n\n            return values;\n          });\n         ```\n\n         @class Promise\n         @param {function} resolver\n         Useful for tooling.\n         @constructor\n         */\n        function $$es6$promise$promise$$Promise(resolver) {\n            this._id = $$es6$promise$promise$$counter++;\n            this._state = undefined;\n            this._result = undefined;\n            this._subscribers = [];\n\n            if ($$$internal$$noop !== resolver) {\n                if (!$$utils$$isFunction(resolver)) {\n                    $$es6$promise$promise$$needsResolver();\n                }\n\n                if (!(this instanceof $$es6$promise$promise$$Promise)) {\n                    $$es6$promise$promise$$needsNew();\n                }\n\n                $$$internal$$initializePromise(this, resolver);\n            }\n        }\n\n        $$es6$promise$promise$$Promise.all = $$promise$all$$default;\n        $$es6$promise$promise$$Promise.race = $$promise$race$$default;\n        $$es6$promise$promise$$Promise.resolve = $$promise$resolve$$default;\n        $$es6$promise$promise$$Promise.reject = $$promise$reject$$default;\n\n        $$es6$promise$promise$$Promise.prototype = {\n            constructor: $$es6$promise$promise$$Promise,\n\n            /**\n             The primary way of interacting with a promise is through its `then` method,\n             which registers callbacks to receive either a promise's eventual value or the\n             reason why the promise cannot be fulfilled.\n\n             ```js\n             findUser().then(function(user){\n                // user is available\n              }, function(reason){\n                // user is unavailable, and you are given the reason why\n              });\n             ```\n\n             Chaining\n             --------\n\n             The return value of `then` is itself a promise.  This second, 'downstream'\n             promise is resolved with the return value of the first promise's fulfillment\n             or rejection handler, or rejected if the handler throws an exception.\n\n             ```js\n             findUser().then(function (user) {\n                return user.name;\n              }, function (reason) {\n                return 'default name';\n              }).then(function (userName) {\n                // If `findUser` fulfilled, `userName` will be the user's name, otherwise it\n                // will be `'default name'`\n              });\n\n             findUser().then(function (user) {\n                throw new Error('Found user, but still unhappy');\n              }, function (reason) {\n                throw new Error('`findUser` rejected and we're unhappy');\n              }).then(function (value) {\n                // never reached\n              }, function (reason) {\n                // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.\n                // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.\n              });\n             ```\n             If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.\n\n             ```js\n             findUser().then(function (user) {\n                throw new PedagogicalException('Upstream error');\n              }).then(function (value) {\n                // never reached\n              }).then(function (value) {\n                // never reached\n              }, function (reason) {\n                // The `PedgagocialException` is propagated all the way down to here\n              });\n             ```\n\n             Assimilation\n             ------------\n\n             Sometimes the value you want to propagate to a downstream promise can only be\n             retrieved asynchronously. This can be achieved by returning a promise in the\n             fulfillment or rejection handler. The downstream promise will then be pending\n             until the returned promise is settled. This is called *assimilation*.\n\n             ```js\n             findUser().then(function (user) {\n                return findCommentsByAuthor(user);\n              }).then(function (comments) {\n                // The user's comments are now available\n              });\n             ```\n\n             If the assimliated promise rejects, then the downstream promise will also reject.\n\n             ```js\n             findUser().then(function (user) {\n                return findCommentsByAuthor(user);\n              }).then(function (comments) {\n                // If `findCommentsByAuthor` fulfills, we'll have the value here\n              }, function (reason) {\n                // If `findCommentsByAuthor` rejects, we'll have the reason here\n              });\n             ```\n\n             Simple Example\n             --------------\n\n             Synchronous Example\n\n             ```javascript\n             var result;\n\n             try {\n                result = findResult();\n                // success\n              } catch(reason) {\n                // failure\n              }\n             ```\n\n             Errback Example\n\n             ```js\n             findResult(function(result, err){\n                if (err) {\n                  // failure\n                } else {\n                  // success\n                }\n              });\n             ```\n\n             Promise Example;\n\n             ```javascript\n             findResult().then(function(result){\n                // success\n              }, function(reason){\n                // failure\n              });\n             ```\n\n             Advanced Example\n             --------------\n\n             Synchronous Example\n\n             ```javascript\n             var author, books;\n\n             try {\n                author = findAuthor();\n                books  = findBooksByAuthor(author);\n                // success\n              } catch(reason) {\n                // failure\n              }\n             ```\n\n             Errback Example\n\n             ```js\n\n             function foundBooks(books) {\n\n              }\n\n             function failure(reason) {\n\n              }\n\n             findAuthor(function(author, err){\n                if (err) {\n                  failure(err);\n                  // failure\n                } else {\n                  try {\n                    findBoooksByAuthor(author, function(books, err) {\n                      if (err) {\n                        failure(err);\n                      } else {\n                        try {\n                          foundBooks(books);\n                        } catch(reason) {\n                          failure(reason);\n                        }\n                      }\n                    });\n                  } catch(error) {\n                    failure(err);\n                  }\n                  // success\n                }\n              });\n             ```\n\n             Promise Example;\n\n             ```javascript\n             findAuthor().\n             then(findBooksByAuthor).\n             then(function(books){\n                  // found books\n              }).catch(function(reason){\n                // something went wrong\n              });\n             ```\n\n             @method then\n             @param {Function} onFulfilled\n             @param {Function} onRejected\n             Useful for tooling.\n             @return {Promise}\n             */\n            then: function(onFulfillment, onRejection) {\n                var parent = this;\n                var state = parent._state;\n\n                if (state === $$$internal$$FULFILLED && !onFulfillment || state === $$$internal$$REJECTED && !onRejection) {\n                    return this;\n                }\n\n                var child = new this.constructor($$$internal$$noop);\n                var result = parent._result;\n\n                if (state) {\n                    var callback = arguments[state - 1];\n                    $$asap$$default(function() {\n                        $$$internal$$invokeCallback(state, child, callback, result);\n                    });\n                } else {\n                    $$$internal$$subscribe(parent, child, onFulfillment, onRejection);\n                }\n\n                return child;\n            },\n\n            /**\n             `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same\n             as the catch block of a try/catch statement.\n\n             ```js\n             function findAuthor(){\n                throw new Error('couldn't find that author');\n              }\n\n             // synchronous\n             try {\n                findAuthor();\n              } catch(reason) {\n                // something went wrong\n              }\n\n             // async with promises\n             findAuthor().catch(function(reason){\n                // something went wrong\n              });\n             ```\n\n             @method catch\n             @param {Function} onRejection\n             Useful for tooling.\n             @return {Promise}\n             */\n            'catch': function(onRejection) {\n                return this.then(null, onRejection);\n            }\n        };\n\n        var $$es6$promise$polyfill$$default = function polyfill() {\n            var local;\n\n            if (typeof global !== 'undefined') {\n                local = global;\n            } else if (typeof window !== 'undefined' && window.document) {\n                local = window;\n            } else {\n                local = self;\n            }\n\n            var es6PromiseSupport =\n                \"Promise\" in local &&\n                    // Some of these methods are missing from\n                    // Firefox/Chrome experimental implementations\n                \"resolve\" in local.Promise &&\n                \"reject\" in local.Promise &&\n                \"all\" in local.Promise &&\n                \"race\" in local.Promise &&\n                    // Older version of the spec had a resolver object\n                    // as the arg rather than a function\n                (function() {\n                    var resolve;\n                    new local.Promise(function(r) { resolve = r; });\n                    return $$utils$$isFunction(resolve);\n                }());\n\n            if (!es6PromiseSupport) {\n                local.Promise = $$es6$promise$promise$$default;\n            }\n        };\n\n        var es6$promise$umd$$ES6Promise = {\n            'Promise': $$es6$promise$promise$$default,\n            'polyfill': $$es6$promise$polyfill$$default\n        };\n\n        /* global define:true module:true window: true */\n        if (typeof define === 'function' && define['amd']) {\n            define(function() { return es6$promise$umd$$ES6Promise; });\n        } else if (typeof module !== 'undefined' && module['exports']) {\n            module['exports'] = es6$promise$umd$$ES6Promise;\n        } else if (typeof this !== 'undefined') {\n            this['ES6Promise'] = es6$promise$umd$$ES6Promise;\n        }\n    }).call(window);\n\n    window.ES6Promise.polyfill();\n\n    /**\n     * Console polyfill\n     */\n    var consoleOverride = (function() {\n        var overrideFn = function(con) {\n            con || (con = {});\n            con.assert = con.clear = con.count = con.debug = con.dir = con.dirxml = con.error = con.exception =\n                con.group = con.groupCollapsed = con.groupEnd = con.info = con.log = con.markTimeline = con.profile =\n                con.profileEnd = con.table = con.time = con.timeEnd = con.timeStamp = con.trace = con.warn = function() { };\n\n            return con;\n        };\n        if (!window.console) {\n            window.console = overrideFn();\n        }\n        return overrideFn;\n    }).call(window);\n\n    (function() {\n        \"use strict\";\n\n        var inStudio = !!(window.LIVEBALL && window.LIVEBALL.inStudio);\n        if (inStudio) {\n            var inStudioLabs;\n            if (window.LIVEBALL.App) {\n                inStudioLabs = window.LIVEBALL.App.features.labs;\n            } else {\n                inStudioLabs = window.LIVEBALL.features && window.LIVEBALL.features.labs;\n            }\n        }\n\n        window.ixp = window.ixp || {};\n        var runtime = window.ixp.runtime = window.ixp.runtime || {};\n        runtime.fn = runtime.fn || {};\n        runtime.inStudio = inStudio;\n        runtime.inStudioLabs = inStudioLabs;\n\n\n        runtime.interactionsConfig = {\n            BULK_SIZE: 50,\n            AJAX_INTERVAL: 2 * 60 * 60\n        };\n\n        runtime.interactionManager = {};\n\n        // Queue should be scoped if used elsewhere\n        var readyQueue = [];\n        var isReady = false;\n        runtime.ready = function(fn, context) {\n            if (typeof fn !== 'function') {\n                throw new Error('runtime.ready requires the callback to be a function');\n            }\n\n            var func = !context ? fn : function() { fn.call(context); };\n\n            if (isReady) {\n                if (_.isFunction(window.requestAnimationFrame)) {\n                    window.requestAnimationFrame(func);\n                } else {\n                    setTimeout(func, 0);\n                }\n                return;\n            }\n\n            readyQueue.push(func);\n        };\n\n        var constants = runtime.constants = runtime.constants || {};\n        runtime.constants.screenSizes =  runtime.constants.screenSizes || {};\n        runtime.constants.screenSizes =  {\n            xs: { maxWidth: 767 }, \n            sm: { minWidth: 768, maxWidth: 991 },\n            md: { minWidth: 992, maxWidth: 1199 },\n            lg: { minWidth: 1200 }\n        };\n\n        runtime.flags = runtime.flags || {};\n\n        var parseQueryString = function() {\n            var qs = {};\n            var match,\n                pl = /\\+/g, // Regex for replacing addition symbol with a space\n                search = /([^&=]+)=?([^&]*)/g,\n                decode = function(s) {\n                    try {\n                        return decodeURIComponent(s.replace(pl, ' '));\n                    }\n                    catch (ex) {\n                        console.error(ex);\n                        return null;\n                    }\n                },\n                query = window.location.search.substring(1);\n\n            while (match = search.exec(query)) {\n                qs[decode(match[1])] = decode(match[2]);\n            }\n            return qs;\n        };\n\n        runtime.queryString = parseQueryString();\n\n        var isHttps = (window.location.protocol === 'https:');\n\n        runtime.flags.https = isHttps;\n\n        if (runtime.queryString['debug'] === 'true' ||\n            runtime.queryString['_ion_debug'] === 'true') {\n            runtime.flags.debug = true;\n        }\n\n        var inDebug = !!runtime.flags.debug;\n\n        runtime.console = !inDebug ? consoleOverride() : window.console;\n\n        runtime.log = function() {\n            if (inDebug) {\n                if (typeof runtime.console.log === 'function') {\n                    runtime.console.log.apply(runtime.console, arguments);\n                } else {\n                    runtime.console.log(Array.prototype.slice.call(arguments));\n                }\n            }\n        };\n\n        if (inStudio) {\n            runtime.studio = {\n                app: window.LIVEBALL.App,\n                labs: !!inStudioLabs\n            };\n        }\n\n        // runtime URLs\n        runtime.paths = runtime.paths || {};\n        (function (paths) {\n            var cdnUrls = {\n                https: 'https://ionfiles.scribblecdn.net/',\n                http: 'http://ionfiles.scribblecdn.net/'\n            };\n            var trimFrontSlash = function(str) {\n                return str.replace(/^\\//g, '');\n            };\n            var trimEndSlash = function(str) {\n                return str.replace(/\\/$/g, '');\n            };\n            var trimSlashes = function(str) {\n                return trimFrontSlash(trimEndSlash(str));\n            };\n            paths.join = function() {\n                var args = Array.prototype.slice.call(arguments, 0);\n                var path = [];\n                for (var i = 0, len = args.length; i < len; i++) {\n                    var part = args[i];\n                    if (typeof part !== 'string') {\n                        throw new Error('Arguments to path.join must be strings');\n                    }\n                    if (part === '/') {\n                        continue;\n                    }\n                    if (i === 0) {\n                        part = trimEndSlash(part);\n                    } else {\n                        part = trimSlashes(part);\n                    }\n                    path = path.concat(part.split('/'));\n                }\n                return path.join('/');\n            };\n            paths.getCdnPath = function() {\n                var cdnPath = isHttps ? cdnUrls.https : cdnUrls.http;\n                if (!arguments.length) {\n                    return cdnPath;\n                }\n                var args = Array.prototype.slice.call(arguments, 0);\n                args = [cdnPath].concat(args);\n\n                var newPath = paths.join.apply(this, args);\n                if (!runtime.flags.debug) {\n                    return newPath;\n                }\n                return newPath.replace('.min', '');\n            };\n        }).call(this, runtime.paths);\n\n        // runtime.dependencies\n        runtime.dependencies = runtime.dependencies || {};\n        var components = runtime.components = runtime.components || {};\n        components.dependencies = components.dependencies || {};\n        components.dependencies._ = _;\n\n        (function(dependencies, componentDeps) {\n            var modules = {};\n            var loading = {};\n            if (runtime.flags.debug) {\n                dependencies._modules = modules;\n                dependencies._loading = loading;\n            }\n\n            var compareVersions = function(v1, v2) {\n                var v1Split = v1.split('.');\n                var v2Split = v2.split('.');\n\n                while (v1Split.length < v2Split.length) {\n                    v1Split.push('0');\n                }\n                while (v2Split.length < v1Split.length) {\n                    v2Split.push('0');\n                }\n\n                for (var i = 0, len = v1Split.length; i < len; i++) {\n                    var num1 = Number(v1Split[i]);\n                    var num2 = Number(v2Split[i]);\n\n                    if (num1 === num2) {\n                        continue;\n                    } else if (num1 > num2) {\n                        return 1;\n                    } else {\n                        return -1;\n                    }\n                }\n\n                return 0;\n            };\n\n            var getSortedInstancesInfo = function(instances, getVersion) {\n                if (instances instanceof Array) {\n                    var infos = [];\n                    for (var i = 0, len = instances.length; i < len; i++) {\n                        var instance = instances[i];\n                        infos.push({\n                            version: getVersion(instance),\n                            module: instance\n                        });\n                    }\n\n                    if (infos.length > 1) {\n                        infos.sort(function(i1, i2) {\n                            return -(compareVersions(i1.version, i2.version));\n                        });\n                    }\n\n                    return infos;\n                }\n\n                return [];\n            };\n\n            var loadScript = function(url, options) {\n                var script = document.createElement('script');\n                var head = document.head || document.getElementsByTagName('head')[0];\n\n                var loaded = false;\n                var load = options.load;\n                options.load = function() {\n                    if (loaded) {\n                        return;\n                    }\n                    loaded = true;\n\n                    load.apply(this, arguments);\n                };\n\n                // This is for IE8/9? support\n                script.onreadystatechange = function() {\n                    // IE8\n                    if (script.readyState === 'loaded' || script.readyState === 'complete') {\n                        options.load();\n                        script.onreadystatechange = null;\n                    }\n                };\n\n                script.onload = options.load;\n                script.onerror = options.error;\n\n                script.src = url;\n                head.appendChild(script);\n            };\n\n            var moduleLocator = function(module, defineOpts, requireOpts) {\n                var instances = module.instances;\n\n                // Find all available instances if we don't have any\n                if (!instances.length && typeof defineOpts.findInstances === 'function') {\n                    // getInstancesInfo returns [{ version: '1.0', module: <instance> }] sorted by descending version\n                    instances = module.instances = getSortedInstancesInfo(defineOpts.findInstances(), defineOpts.getInstanceVersion);\n                }\n\n                var minVer = requireOpts.minVer || requireOpts.version;\n                var maxVer = requireOpts.maxVer || requireOpts.upToVersion;\n                var checkVersion = !!(minVer || maxVer);\n\n                // If no version check and we have only 1 instance - return it\n                if (!checkVersion && instances.length === 1) {\n                    return instances[0].module;\n                }\n\n                if (instances.length) {\n                    // If no version check return the latest version (descendent sorted so 0 is latest)\n                    if (!checkVersion) {\n                        return instances[0].module;\n                    }\n\n                    var instance;\n                    for (var i = 0, len = instances.length; i < len; i++) {\n                        instance = instances[i];\n                        if ((!minVer || compareVersions(instance.version, minVer) >= 0) &&\n                            (!maxVer || compareVersions(instance.version, maxVer) < 0)) {\n                            return instance.module;\n                        }\n                    }\n                }\n\n                return null;\n            };\n\n            var moduleLoader = function(name, defineOpts, requireOpts) {\n                if (typeof requireOpts === 'function') {\n                    var doneFn = requireOpts;\n                    requireOpts = {\n                        done: doneFn\n                    };\n                } else {\n                    requireOpts || (requireOpts = {});\n                }\n\n                var url;\n\n                var module = modules[name];\n                if (requireOpts.sync === true) {\n                    return moduleLocator(module, defineOpts, requireOpts);\n                }\n\n                var promise = new Promise(function(resolve, reject) {\n                    var instances = module.instances;\n                    var found = moduleLocator(module, defineOpts, requireOpts);\n                    if (found) {\n                        resolve(found);\n                        return;\n                    }\n\n                    // Load module\n                    url = requireOpts.url || defineOpts.url;\n                    if (!url) {\n                        reject(new Error('No module instances found'));\n                        return;\n                    }\n\n                    // Make sure we aren't already trying to load the same module\n                    if (loading[url]) {\n                        if (runtime.flags.debug) {\n                            console.log('queuing module url=' + url, requireOpts);\n                        }\n\n                        loading[url].then(resolve)['catch'](reject);\n                        return;\n                    }\n\n                    if (runtime.flags.debug) {\n                        console.log('loading module url=' + url, requireOpts);\n                    }\n\n                    loadScript(url, {\n                        load: function() {\n                            delete loading[url];\n\n                            try {\n                                var instance = defineOpts.getInstanceExport();\n                                instances.push({\n                                    version: defineOpts.getInstanceVersion(instance),\n                                    module: instance\n                                });\n\n                                if (instances.length > 1) {\n                                    instances.sort(function(i1, i2) {\n                                        return -(compareVersions(i1.version, i2.version));\n                                    });\n                                }\n\n                                resolve(instance);\n                            }\n                            catch (ex) {\n                                reject(ex);\n                            }\n                        },\n\n                        error: function(err) {\n                            delete loading[url];\n\n                            err = new Error('failed to load script: url=' + url);\n                            reject(err);\n                        }\n                    });\n                });\n\n                // If we have a url and aren't already loading, then add our promise\n                if (url && !loading[url]) {\n                    loading[url] = promise;\n                }\n\n                if (typeof requireOpts.done === 'function') {\n                    promise.then(function(instance) {\n                        requireOpts.done(instance);\n                    });\n                }\n\n                if (typeof requireOpts.fail === 'function') {\n                    promise['catch'](function(err) {\n                        requireOpts.fail(err);\n                    });\n                }\n\n                return promise;\n            };\n\n            /**\n             * Defines a module\n             * @param {string} name\n             * @param {object} options\n             */\n            dependencies.define = function(name, options) {\n                if (!name || typeof name !== 'string') {\n                    throw new Error('(string) module name is required');\n                }\n\n                options || (options = {});\n                if (typeof options.getInstanceExport !== 'function' ||\n                    typeof options.getInstanceVersion !== 'function') {\n                    throw new Error('options must contain getInstanceExport and getInstanceVersion functions');\n                }\n\n                name = name.toLowerCase();\n\n                if (modules[name]) {\n                    throw new Error('module ' + name + ' has already been defined');\n                }\n\n                modules[name] = {\n                    loader: function(requireOpts) {\n                        return moduleLoader(name, options, requireOpts);\n                    },\n                    instances: []\n                };\n            };\n\n            /**\n             * @callback requireDone\n             * @param {object} [module] - desired module if successful\n             */\n\n            /**\n             * @callback requireFail\n             * @param {object} [error] - error information if unsuccessful\n             */\n\n            /**\n             * @typedef requireOptions\n             * @type {object}\n             * @property {requireDone} done - callback\n             * @property {requireFail} fail - callback\n             * @property {string} [url] - (optional) url of the desired module if loading is required\n             * @property {string} [minVer] - (optional) minVer (or minimum version) of the desired module\n             * @property {string} [maxVer] - (optional) exclusive maximum version of the desired module\n             */\n\n            /**\n             * Resolves a module\n             * @param {string} name\n             * @param {requireOptions|function} options\n             */\n            dependencies.require = function(name, options) {\n                if (!name || typeof name !== 'string') {\n                    throw new Error('(string) module name is required');\n                }\n\n                name = name.toLowerCase();\n\n                var module = modules[name];\n                if (!module) {\n                    throw new Error('module ' + name + ' has not been defined');\n                }\n                return module.loader(options);\n            };\n\n            dependencies.define('jQuery', {\n                url: runtime.dependencies.jQueryUrl,\n\n                findInstances: function() {\n                    var instances = [];\n\n                    // in components if loaded\n                    if (componentDeps && componentDeps.jQuery && componentDeps.jQuery.v1_11) {\n                        instances.push(componentDeps.jQuery.v1_11);\n                    }\n\n                    // in global scope if loaded\n                    if (window.jQuery) {\n                        instances.push(window.jQuery);\n                    }\n\n                    if (window.$ && (!window.jQuery || window.jQuery && window.jQuery !== window.$)) {\n                        instances.push(window.$);\n                    }\n\n                    return instances;\n                },\n\n                getInstanceExport: function() {\n                    return window.jQuery.noConflict(true);\n                },\n\n                getInstanceVersion: function(instance) {\n                    return instance.fn.jquery;\n                }\n            });\n        }).call(this, runtime.dependencies, components.dependencies);\n\n        // Start loading jquery as soon as possible\n        var $promise = runtime.dependencies.require('jQuery', {\n            minVer: '1.11.1',\n            maxVer: '1.11.2'\n        });\n\n        // Interactions Manager\n        var initInteractionManager = function($) {\n            if (window.ixp.runtime.initInteractionManager) {\n                window.ixp.runtime.initInteractionManager.call(window.ixp.runtime, $, _);\n            } else {\n                setTimeout(initInteractionManager, 200, $);\n            }\n        };\n        $promise.then(initInteractionManager);\n\n        // runtime.events\n        runtime.events = runtime.events || {};\n        (function(events) {\n            var subscriptions = {};\n            if (runtime.flags.debug) {\n                events._subscriptions = subscriptions;\n            }\n\n            var triggerEvents = function(listeners, args) {\n                var ev,\n                    i = -1,\n                    l = listeners.length,\n                    a1,\n                    a2,\n                    a3;\n\n                switch (args.length) {\n                    case 0:\n                        while (++i < l) {\n                            (ev = listeners[i]).fn.call(ev.ctx);\n                        }\n                        return;\n                    case 1:\n                        a1 = args[0];\n                        while (++i < l) {\n                            (ev = listeners[i]).fn.call(ev.ctx, a1);\n                        }\n                        return;\n                    case 2:\n                        a1 = args[0];\n                        a2 = args[1];\n                        while (++i < l) {\n                            (ev = listeners[i]).fn.call(ev.ctx, a1, a2);\n                        }\n                        return;\n                    case 3:\n                        a1 = args[0];\n                        a2 = args[1];\n                        a3 = args[2];\n                        while (++i < l) {\n                            (ev = listeners[i]).fn.call(ev.ctx, a1, a2, a3);\n                        }\n                        return;\n                    default:\n                        args = args || [];\n                        while (++i < l) {\n                            (ev = listeners[i]).fn.apply(ev.ctx, args);\n                        }\n                        return;\n                }\n            };\n\n            events.on = function(context, name, callback) {\n                if (!context || !name || !callback) {\n                    throw new Error('context, name, and callback are required');\n                }\n\n                name = name.toLowerCase();\n\n                var listeners = subscriptions[name] || (subscriptions[name] = []);\n                listeners.push({ ctx: context, fn: callback });\n                return this;\n            };\n\n            events.once = function(context, name, callback) {\n                if (!context || !name || !callback) {\n                    throw new Error('context, name, and callback are required');\n                }\n\n                var me = this;\n\n                var once = function() {\n                    me.off(name, once);\n                    callback.apply(this, arguments);\n                };\n                return this.on(context, name, once);\n            };\n\n            events.off = function(context, name, callback) {\n                if (!context) {\n                    throw new Error('context is required');\n                }\n\n                var names = name ? [name] : _.keys(subscriptions);\n                for (var i = 0, namesLen = names.length; i < namesLen; i++) {\n                    name = names[i];\n                    name = name.toLowerCase();\n\n                    // Bail out if there are no listeners stored\n                    var listeners = subscriptions[name];\n                    if (!listeners) {\n                        continue;\n                    }\n\n                    // Find any remaining listeners\n                    var remaining = [];\n                    for (var j = 0, listenersLen = listeners.length; j < listenersLen; j++) {\n                        var event = listeners[j];\n                        if (context !== event.ctx ||\n                            (callback && callback !== event.fn)) {\n                            remaining.push(event);\n                        }\n                    }\n\n                    // Replace listeners if there are any remaining.  Otherwise, clean up\n                    if (remaining.length) {\n                        subscriptions[name] = remaining;\n                    } else {\n                        delete subscriptions[name];\n                    }\n                }\n\n                return this;\n            };\n\n            events.trigger = function(sender, name) {\n                var args;\n                if (typeof sender === 'string') {\n                    args = Array.prototype.slice.call(arguments, 1);\n                    name = sender;\n                    sender = undefined;\n                } else {\n                    args = Array.prototype.slice.call(arguments, 2);\n                }\n\n                if (!name || !subscriptions) {\n                    return false;\n                }\n\n                name = name.toLowerCase();\n\n                var listeners = subscriptions[name];\n                if (!listeners) {\n                    return false;\n                }\n\n                if (sender) {\n                    var filtered = [];\n                    var i = -1,\n                        l = listeners.length,\n                        e;\n                    while (++i < l) {\n                        if ((e = listeners[i]).ctx !== sender) {\n                            filtered.push(e);\n                        }\n                    }\n                    listeners = filtered;\n                }\n\n                triggerEvents(listeners, args);\n                return true;\n            };\n        }).call(this, runtime.events);\n\n        var getRespondentId = function () {\n            const compositeIdParts = (runtime.context.id || '').split('$');\n\n            if (compositeIdParts.length === 3) {\n                return compositeIdParts[2];\n            }\n            return 0;\n        };\n\n        var promiseQueue;\n        var ajax = function($, options) {\n            var config = {\n                url: options.url,\n                async: true,\n                data: options.type === 'DELETE' ? undefined : JSON.stringify(options.data),\n                dataType: 'json',\n                contentType: 'application/json; charset=utf-8',\n                type: options.type || 'POST',\n                cache: false,\n                success: options.success && $.proxy(options.success, this),\n                error: options.error && $.proxy(options.error, this)\n            };\n\n            options.always = options.always || $.proxy(options.always || function() { }, this);\n\n            var promise;\n            if (options.queue === false) {\n                promise = Promise.resolve($.ajax(config).always(options.always));\n            } else {\n                if (promiseQueue) {\n                    var next = function() {\n                        return Promise.resolve($.ajax(config).always(options.always));\n                    };\n                    promise = promiseQueue.then(next, next);\n                } else {\n                    promise = Promise.resolve($.ajax(config).always(options.always));\n                }\n                promiseQueue = promise;\n            }\n\n            // Uncomment to simulate longer ajax times\n            //return new Promise(function(resolve) {\n            //    setTimeout(resolve, 10000);\n            //}).then(promise);\n\n            return promise;\n        };\n\n        runtime.constants.promise = runtime.constants.promise || {};\n        runtime.constants.promise = {\n            cancellationError: 'Promise has been cancelled'\n        };\n\n        var $ajax = function(options) {\n            return $promise.then(function($) {\n                return ajax($, options);\n            });\n        };\n\n        var findElementByIxpAnchor = function(anchor) {\n            if (!_.isFunction(document.querySelectorAll)) {\n                return null;\n            }\n\n            var anchorMatch = anchor.toLowerCase();\n            var els = document.querySelectorAll(runtime.constants.anchor.attrSelector);\n            var el;\n            for (var i = els.length - 1; i >= 0; i--) {\n                el = els[i];\n                if (el.getAttribute(runtime.constants.anchor.attr).toLowerCase() === anchorMatch) {\n                    return el;\n                }\n            }\n            return null;\n        };\n\n        // runtime apis\n        (function() {\n            runtime.constants.anchor = runtime.constants.anchor || {};\n            runtime.constants.anchor = {\n                attr: 'data-ixp-anchor',\n                attrSelector: '[data-ixp-anchor]'\n            };\n\n            runtime.runScriptlet = function(scriptletId, options) {\n                options || (options = {});\n\n                var ee = { scriptletId: scriptletId, options: options, cancel: false };\n                runtime.events.trigger('runtime:runscriptlet:starting', ee);\n                if (ee.cancel) return;\n\n                options = ee.options || options;\n\n                var promise = $ajax({\n                    url: '/admin/api/v1/scriptlets/' + scriptletId + '/run',\n                    data: {\n                        scriptletId: scriptletId,\n                        token: runtime.context.token,\n                        tokenId: getRespondentId(),\n                        wait: !!options.wait\n                    },\n                    queue: options.queue\n                });\n\n                ee = { scriptletId: scriptletId, options: options, promise: promise };\n                runtime.events.trigger('runtime:runscriptlet:completed', ee);\n\n                return promise;\n            };\n\n            runtime.runIntegration = function(integrationId, options) {\n                options || (options = {});\n\n                var ee = { integrationId: integrationId, options: options, cancel: false };\n                runtime.events.trigger('runtime:runintegration:starting', ee);\n                if (ee.cancel) return;\n\n                options = ee.options || options;\n\n                var promise = $ajax({\n                    url: '/admin/api/v1/integrations/' + integrationId + '/run',\n                    data: {\n                        integrationId: integrationId,\n                        token: runtime.context.token,\n                        tokenId: getRespondentId(),\n                        wait: !!options.wait\n                    },\n                    queue: options.queue\n                });\n\n                ee = { integrationId: integrationId, options: options, promise: promise };\n                runtime.events.trigger('runtime:runintegration:completed', ee);\n\n                return promise;\n            };\n            \n            var isScreenSizeXS = function() {\n                return window.innerWidth <= constants.screenSizes.xs.maxWidth;\n            };\n\n            var isScreenSizeSM = function() {\n                return window.innerWidth >= constants.screenSizes.sm.minWidth && window.innerWidth <= constants.screenSizes.sm.maxWidth;\n            };\n\n            var isScreenSizeMD = function() {\n                return window.innerWidth >= constants.screenSizes.md.minWidth && window.innerWidth <= constants.screenSizes.md.maxWidth;\n            };\n            \n            var isScreenSizeLG = function() {\n                return window.innerWidth >= constants.screenSizes.lg.minWidth;\n            };\n\n            runtime.isHiddenByCSS = function(element) {\n                if (element.hasClass('ixp-grid-hidden-xs') && isScreenSizeXS()) \n                    return true;\n                \n                if (element.hasClass('ixp-grid-hidden-sm') && isScreenSizeSM()) \n                    return true;\n                \n                if (element.hasClass('ixp-grid-hidden-md') && isScreenSizeMD()) \n                    return true;\n                \n                if (element.hasClass('ixp-grid-hidden-lg') && isScreenSizeLG())\n                    return true;\n\n                return false\n            };\n\n            runtime.convert = function(options) {\n                options || (options = {});\n\n                var ee = { options: options, cancel: false };\n                runtime.events.trigger('runtime:convert:starting', ee);\n                if (ee.cancel) return;\n\n                options = ee.options || options;\n\n                var promise = $ajax({\n                    url: '/outside/convert.ashx?lb3id=' + runtime.context.id + '&v=1&rnd=' + parseInt(31777 * Math.random()),\n                    type: 'GET',\n                    queue: options.queue\n                });\n\n                ee = { options: options, promise: promise };\n                runtime.events.trigger('runtime:convert:completed', ee);\n\n                return promise;\n            };\n\n            runtime.tag = function(tag, options) {\n                options || (options = {});\n\n                if (!tag) {\n                    throw new Error('Tag cannot be empty');\n                }\n\n                var ee = { tag: tag, options: options, cancel: false };\n                runtime.events.trigger('runtime:tag:starting', ee);\n                if (ee.cancel) return;\n\n                tag = ee.tag || tag;\n                options = ee.options || options;\n\n                var promise = $ajax({\n                    url: '/outside/tag.ashx?lb3id=' + runtime.context.id + '&tag=' + encodeURIComponent(tag) + '&v=1&rnd=' + parseInt(31777 * Math.random()),\n                    type: 'GET',\n                    queue: options.queue\n                });\n\n                ee = { tag: tag, options: options, promise: promise };\n                runtime.events.trigger('runtime:tag:completed', ee);\n\n                return promise;\n            };\n\n            var getParentComponentData = function($el, $) {\n                var $parents = $el.parents('[data-ixp-component-root]');\n                if (!$parents.length) {\n                    return [];\n                }\n                var parentData = [];\n\n                $parents.each(function() {\n                    var $parent = $(this);\n                    var id = $parent.data('ixp-component-root');\n                    var data = {\n                        element: $parent,\n                        id: id\n                    };\n\n                    parentData.push(data);\n                });\n\n                return parentData.reverse();\n            };\n\n            var getScrollToOffsetTop = function(location) {\n                var scrollAdjustment = 0;\n\n                var stickyStatuses = runtime.components.sendCommand && runtime.components.sendCommand('status', 'sticky_container');\n                if (stickyStatuses && stickyStatuses.length) {\n                    for (var i = 0, len = stickyStatuses.length; i < len; i++) {\n                        var stickyStatus = stickyStatuses[i].data;\n                        if (stickyStatus.sticksTo === 'top' && (stickyStatus.isSticking || (location && stickyStatus.scrollTop < location))) {\n                            scrollAdjustment += stickyStatus.offset + stickyStatus.height;\n                        }\n                    }\n                }\n\n                return scrollAdjustment;\n            };\n\n            var scrollToCore = function($target, data, $) {\n                var resolvePromise;\n\n                var onScrolled = function() {\n                    runtime.events.trigger(runtime.constants.visibility.events.recalculate, {});\n                    runtime.events.trigger('runtime:scrollto:scrolled', data);\n                    resolvePromise();\n                };\n\n                var location = $target.offset().top;\n                if (data.preventOffset !== true) {\n                    location -= getScrollToOffsetTop(location);\n                }\n\n                if (data.inViewport !== undefined) {\n                    var isInViewport = runtime.fn.isInViewport($target[0], data.inViewport);\n                    if (isInViewport) {\n                        return new Promise(function(resolve) {\n                            resolvePromise = resolve;\n                            _.defer(onScrolled);\n                        });\n                    }\n                }\n\n                if (data.speed === 0) {\n                    return new Promise(function(resolve) {\n                        resolvePromise = resolve;\n                        $('html, body').stop().scrollTop(location);\n                        _.defer(onScrolled);\n                    });\n                } else {\n                    return new Promise(function(resolve) {\n                        resolvePromise = resolve;\n                        var scrollingEl = document.scrollingElement || document.documentElement;\n                        $(scrollingEl).stop().animate({\n                            'scrollTop': location\n                        }, {\n                            duration: data.speed,\n                            easing: 'swing',\n                            always: _.debounce(onScrolled, 17)\n                        });\n                    });\n                }\n            };\n\n            runtime.scrollTo = function(anchorOrElement, options) {\n                options || (options = {});\n                $promise.then(function($) {\n                    var anchor, $target;\n                    if (!_.isObject(anchorOrElement)) {\n                        anchor = anchorOrElement;\n                        $target = $(findElementByIxpAnchor(anchor));\n                    } else {\n                        $target = $(anchorOrElement);\n                        anchor = $target.attr(runtime.constants.anchor.attr);\n                    }\n\n                    if (!$target.length) {\n                        return;\n                    }\n\n                    var targetEl = $target[0];\n                    var data = {\n                        anchor: anchor,\n                        element: targetEl,\n                        speed: (options.speed && parseInt(options.speed, 10)) || 0,\n                        updateUrlHash: (anchor !== undefined) && (options.updateUrlHash === undefined ? true : options.updateUrlHash),\n                        markAsConverted: (anchor !== undefined) && (options.markAsConverted === undefined ? false : options.markAsConverted),\n                        inViewport: options.inViewport,\n                        preventOffset: false,\n                        getOffsetTop: getScrollToOffsetTop\n                    };\n\n                    var ee = _.extend(data, { cancel: false });\n                    runtime.events.trigger('runtime:scrollto:scrolling', ee);\n\n                    if (ee.cancel) {\n                        return;\n                    }\n\n                    data.speed = ee.speed;\n                    data.updateUrlHash = ee.updateUrlHash;\n                    data.markAsConverted = ee.markAsConverted;\n                    data.inViewport = ee.inViewport;\n\n                    var resolveCompletionPromise;\n                    data.completionPromise = new Promise(function(resolve, reject) {\n                        resolveCompletionPromise = resolve;\n                    });\n\n                    if (data.updateUrlHash) {\n                        runtime.events.trigger('runtime:scrollto:hash:changing', { hash: anchor });\n                        window.location.hash = '#' + anchor;\n                    }\n\n                    if (data.markAsConverted) {\n                        runtime.convert();\n                    }\n\n                    var promiseChain = Promise.resolve();\n                    var preventDefault = false;\n                    var newTarget;\n\n                    var parentComponents = getParentComponentData($target, $);\n                    if (parentComponents.length && runtime.components.sendCommand) {\n                        var promises = [];\n\n                        for (var i = 0, len = parentComponents.length; i < len; i++) {\n                            var results = runtime.components.sendCommand('scrollto', parentComponents[i].id, data);\n                            if (results) {\n                                for (var j = 0, resultLen = results.length; j < resultLen; j++) {\n                                    var result = results[j];\n\n                                    if (result.data.preventDefault) {\n                                        preventDefault = true;\n                                    }\n\n                                    if (result.data.preventOffset) {\n                                        data.preventOffset = true;\n                                    }\n\n                                    if (result.data.element) {\n                                        newTarget = data.element = result.data.element;\n                                    }\n\n                                    data.inViewport = result.data.inViewport;\n\n                                    promises.push(result.data.promise);\n                                }\n                            }\n                        }\n\n                        if (promises.length) {\n                            promiseChain = promiseChain.then(function() {\n                                return Promise.all(promises);\n                            });\n                        }\n                    }\n\n                    if (!preventDefault) {\n                        if (newTarget) {\n                            $target = $(newTarget);\n                        }\n                        promiseChain = promiseChain.then(function() {\n                            return scrollToCore($target, data, $);\n                        });\n                    }\n\n                    if (resolveCompletionPromise) {\n                        promiseChain.then(resolveCompletionPromise);\n                    }\n\n                    return promiseChain;\n                });\n            };\n\n            // var INTERACTION_URL = 'https://ion-interactions.free.beeceptor.com';  // TODO move to constants\n            // console url\n            // https://beeceptor.com/console/ion-interactions-2\n\n            runtime.uploadInteractions = function(interactions, options) {\n                if (!interactions.length) {\n                    return;\n                }\n                options || (options = {});\n\n                var ee = { options: options, cancel: false };\n                runtime.events.trigger('runtime:uploadinteractions:starting', ee);\n                if (ee.cancel) return;\n\n                options = ee.options || options;\n\n                // TODO uncomment after interaction feature implementation\n                // var promise = $ajax({\n                //     url: INTERACTION_URL,\n                //     data: {\n                //         isBeacon: false,\n                //         interactions: interactions,\n                //         token: runtime.context.token,\n                //         tokenId: getRespondentId()\n                //     },\n                //     queue: false\n                // });\n\n                // Mocked API call\n                var promise = Promise.resolve();\n\n                ee = { options: options, promise: promise };\n                runtime.events.trigger('runtime:uploadinteractions:completed', ee);\n\n                return promise;\n            };\n        }).call(this);\n\n        // runtime.data\n        runtime.data = runtime.data || {};\n        (function(data) {\n            // Private respondent model\n            var model = {};\n\n            /**\n             * @typedef setOptions\n             * @type {object}\n             * @property {bool} [replace] - (optional) to override the entire model\n             */\n\n            /**\n             * Sets all or part of the runtime data-model\n             * @param {string} key - key in the model\n             * @param {object|string} value - value to set\n             * @param {setOptions} [options]\n             */\n            var setModel = function(key, value, options) {\n                if (!key || !value || typeof key !== 'string') {\n                    throw new Error('(string) key, and value are required');\n                }\n\n                key = key.toLowerCase();\n\n                if (typeof value === 'string') {\n                    value = { value: value };\n                }\n\n                options || (options = {});\n\n                if (!model[key] || options.replace) {\n                    model[key] = value;\n                } else {\n                    model[key] = _.extend(model[key], value);\n                }\n            };\n\n            // runtime.data.model - public respondent model\n            data.model = data.model || {};\n\n            /**\n             * Retrieves all or part of the runtime data-model\n             * @param {string} [key] - (optional) key to specific data in the model\n             */\n            data.model.get = function(key) {\n                if (!key) {\n                    return _.extend({}, model);\n                }\n\n                key = key.toLowerCase();\n\n                return model[key];\n            };\n\n            var parseDataField = function(dataField) {\n                if (!dataField) {\n                    return null;\n                }\n\n                if (dataField.indexOf('{') > -1) {\n                    try {\n                        var field = JSON.parse(dataField);\n                        return { id: field.id, key: field.name };\n                    }\n                    catch (ex) {\n                        throw new Error('Data field contains invalid JSON');\n                    }\n                }\n\n                var separator = dataField.indexOf('\\\\');\n                if (separator > -1) {\n                    return { id: 0, key: dataField.substring(separator + 2) };\n                } else {\n                    return { id: 0, key: dataField };\n                }\n            };\n\n            var triggerDataEvents = function(instanceId, data, saving) {\n                data = (data instanceof Array) ? data : [data];\n\n                var saved = [];\n                var failed = [];\n\n                var eventName = (saving ? ':saving' : ':saved');\n\n                var df,\n                    sd;\n                for (var i = 0, len = data.length; i < len; i++) {\n                    df = data[i];\n\n                    if (saving || df.validation === 'valid') {\n                        sd = {\n                            key: df.key,\n                            value: df.value\n                        };\n                        saved.push(sd);\n\n                        runtime.events.trigger('runtime:data:' + df.key + eventName, { instanceId: instanceId, data: sd });\n                    } else {\n                        var current = model[df.key];\n                        sd = {\n                            key: df.key,\n                            value: current && current.value,\n                            failedValue: df.value,\n                            validation: df.validation\n                        };\n                        failed.push(sd);\n\n                        runtime.events.trigger('runtime:data:' + df.key + ':failed', { instanceId: instanceId, data: sd });\n                    }\n                }\n\n                var ee = {\n                    instanceId: instanceId,\n                    data: saved\n                };\n                if (!saving) {\n                    ee.failed = failed;\n                }\n                runtime.events.trigger('runtime:data' + eventName, ee);\n            };\n\n            var updateDataModel = function(data) {\n                if (!data || !data.length) {\n                    return;\n                }\n\n                var df;\n                for (var i = 0, len = data.length; i < len; i++) {\n                    df = data[i];\n\n                    if (df.validation === 'valid') {\n                        setModel(df.key, { value: df.value });\n                    }\n                }\n            };\n\n            var saveDataCore = function($, options) {\n                var instanceId = options.data.instanceId;\n\n                var success = _.isFunction(options.success) && options.success;\n                options.success = function(response) {\n                    var data = response && (response instanceof Array) ? response : [response];\n                    updateDataModel(data);\n\n                    if (success) {\n                        try {\n                            success.apply(this, arguments);\n                        } catch (ex) { }\n                    }\n\n                    if (data && data.length) {\n                        triggerDataEvents(instanceId, data);\n                    }\n                };\n\n                var error = _.isFunction(options.error) && options.error;\n                options.error = function(xhr) {\n                    var data;\n                    if (xhr.status === 409) {\n                        var response = JSON.parse(xhr.responseText);\n                        data = response && response.responseStatus && response.responseStatus.data;\n                        if (data) {\n                            data = (data instanceof Array) ? data : [data];\n                            updateDataModel(data);\n                        }\n                    }\n\n                    if (error) {\n                        try {\n                            error.apply(this, arguments);\n                        } catch (ex) { }\n                    }\n\n                    if (data && data.length) {\n                        triggerDataEvents(instanceId, data);\n                    }\n                };\n\n                return ajax($, options);\n            };\n\n            data.save = function(options) {\n                if (inStudio || (!options.submit && !options.data)) {\n                    return Promise.resolve();\n                }\n\n                if (!options.data && options.submit) {\n                    options.data = [];\n                }\n\n                var urlSlug = '';\n                var dataToSave,\n                    requestType,\n                    dataField;\n\n                var isBulkSave = options.data instanceof Array;\n                if (isBulkSave) {\n                    urlSlug = options.submit ? '/submit' : '/bulk';\n\n                    var pair,\n                        fields = [];\n                    for (var i = 0, len = options.data.length; i < len; i++) {\n                        pair = options.data[i];\n                        dataField = parseDataField(pair.dataField);\n                        if (dataField) {\n                            fields.push({\n                                fieldId: dataField.id,\n                                key: dataField.key,\n                                value: pair.value,\n                                metadata: pair.metadata,\n                                method: pair.method\n                            });\n                        }\n                    }\n\n                    if (fields.length || options.submit) {\n                        dataToSave = {\n                            data: fields,\n                            token: runtime.context.token,\n                            instanceId: options.instanceId\n                        };\n                    }\n                } else {\n                    dataField = parseDataField(options.data.dataField);\n                    if (dataField) {\n                        dataToSave = {\n                            key: dataField.key,\n                            fieldId: dataField.id,\n                            value: options.data.value,\n                            metadata: options.data.metadata,\n                            token: runtime.context.token,\n                            instanceId: options.instanceId\n                        };\n\n                        // NOTE: Passing data using the query string to avoid a DELETE call with a body (which proxy servers can have a problem with as it is undefined by the HTTP spec)\n                        if (options.data.method && options.data.method.toUpperCase() === 'DELETE') {\n                            urlSlug += '?token=' + runtime.context.token;\n                            if (dataField.key) {\n                                urlSlug += '&key=' + dataField.key;\n                            }\n                            if (dataField.id) {\n                                urlSlug += '&fieldId=' + dataField.id;\n                            }\n\n                            requestType = 'DELETE';\n                            dataToSave.value = undefined;\n                        }\n\n                    }\n                }\n\n                if (!dataToSave && requestType !== 'DELETE') {\n                    if (typeof options.always === 'function') {\n                        options.always.call(this);\n                    }\n                    return Promise.resolve();\n                }\n\n                triggerDataEvents(dataToSave.instanceId, dataToSave, true);\n\n                var respondentId = getRespondentId();\n                var config = {\n                    url: '/admin/api/v1/respondents/' + respondentId + '/data' + urlSlug,\n                    data: dataToSave,\n                    success: options.success,\n                    error: options.error,\n                    always: options.always,\n                    type: requestType\n                };\n\n                return $promise.then(function($) {\n                    return saveDataCore.call(data, $, config);\n                });\n            };\n\n            data['delete'] = function(options) {\n                if (!options.data) {\n                    return Promise.resolve();\n                }\n\n                options.data.method = 'DELETE';\n                return data.save(options);\n            };\n\n            runtime.events.on(data, 'runtime:data:registered', function(e) {\n                setModel(e.key, e.value);\n            });\n        }).call(this, runtime.data);\n\n        // dom manipulation/events\n        var dom = {};\n        (function(dom) {\n            var listenerMap = {};\n\n            var passiveSupported = false;\n\n            try {\n                var options = Object.defineProperty({}, \"passive\", {\n                    get: function() {\n                        passiveSupported = true;\n                    }\n                });\n\n                window.addEventListener(\"test\", null, options);\n            } catch (err) { }\n\n            dom.on = function(el, eventNames, fn, options) {\n                var callback = fn;\n                options || (options = {});\n\n                if (!el.addEventListener && el.attachEvent) {\n                    callback = function() {\n                        fn.call(el);\n                    };\n\n                    listenerMap[eventNames] = callback;\n                }\n\n                var names = eventNames.split(' ');\n                for (var i = 0, len = names.length; i < len; i++) {\n                    if (el.addEventListener) {\n                        el.addEventListener(names[i], callback, options.passive && passiveSupported ? { passive: true } : false);\n                    } else if (el.attachEvent) {\n                        el.attachEvent(\"on\" + names[i], callback);\n                    }\n                }\n            };\n\n            dom.off = function(el, eventNames, fn) {\n                var callback = fn;\n                if (!el.addEventListener && el.attachEvent) {\n                    callback = listenerMap[eventNames] || fn;\n                }\n\n                var names = eventNames.split(' ');\n                for (var i = 0, len = names.length; i < len; i++) {\n                    if (el.removeEventListener) {\n                        el.removeEventListener(names[i], callback, false);\n                    } else if (el.detachEvent) {\n                        el.detachEvent(\"on\" + names[i], callback);\n                    }\n                }\n            };\n\n            dom.isSvgElement = function(el) {\n                return el.nodeType === 1 && el.nodeName === 'svg';\n            };\n\n            dom.getClassName = function(el) {\n                if (!el.className) {\n                    return '';\n                }\n\n                if (this.isSvgElement(el)) {\n                    return el.className.baseVal;\n                }\n\n                return el.className;\n            };\n\n            dom.addClass = function(el, className) {\n                if (!this.hasClass(el, className)) {\n                    if (this.isSvgElement(el)) {\n                        el.className.baseVal += (' ' + className);\n                    } else {\n                        el.className += (' ' + className);\n                    }\n                }\n            };\n\n            dom.hasClass = function(el, className) {\n                className = ' ' + className + ' ';\n                return el.nodeType === 1 && (' ' + this.getClassName(el) + ' ').replace(/[\\n\\t]/g, ' ').indexOf(className) >= 0;\n            };\n\n            dom.removeClass = function(el, className) {\n                var elementClassName = this.getClassName(el);\n                var current = el.nodeType === 1 && (elementClassName ? (' ' + elementClassName + ' ').replace(/[\\n\\t]/g, ' ') : '');\n                var isSvg = this.isSvgElement(el);\n\n                if (current) {\n                    while (current.indexOf(' ' + className + ' ') >= 0) {\n                        current = current.replace(' ' + className + ' ', ' ');\n                    }\n\n                    if (isSvg) {\n                        el.className.baseVal = current.replace(/^\\s+|\\s+$/g, '');\n                    } else {\n                        el.className = current.replace(/^\\s+|\\s+$/g, '');\n                    }\n                }\n            };\n\n            dom.ready = function(callback) {\n                /*\n                 jQuery's document.ready/$(function(){}) should\n                 you wish to use a cross-browser DOMReady solution\n                 without opting for a library.\n\n                 Demo: http://jsfiddle.net/8j85t/\n\n                 usage:\n                 $(function(){\n                 // your code\n                 });\n\n                 Parts: jQuery project, Diego Perini, Lucent M.\n                 This version: Addy Osmani, David Dallet\n                 */\n                \n                var isReady = false,\n                    readyBound = false,\n                    callbackQueue = [];\n\n                var registerOrRunCallback = function(callback) {\n                    if (typeof callback === \"function\") {\n                        callbackQueue.push(callback);\n                    }\n                };\n\n                var DOMReadyCallback = function() {\n                    while (callbackQueue.length) {\n                        (callbackQueue.shift())();\n                    }\n                    registerOrRunCallback = function(callback) {\n                        callback();\n                    };\n                };\n\n                // The ready event handler\n                var DOMContentLoaded = function() {\n                    if (document.addEventListener) {\n                        document.removeEventListener(\"DOMContentLoaded\", DOMContentLoaded, false);\n                    } else {\n                        // we're here because readyState !== \"loading\" in oldIE\n                        // which is good enough for us to call the dom ready!\n                        document.detachEvent(\"onreadystatechange\", DOMContentLoaded);\n                    }\n                    DOMReady();\n                };\n\n                var DOMReady = function() {\n                    // Make sure that the DOM is not already loaded\n                    if (!isReady) {\n                        // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).\n                        if (!document.body) {\n                            return setTimeout(DOMReady, 1);\n                        }\n                        // Remember that the DOM is ready\n                        isReady = true;\n                        // If there are functions bound, to execute\n                        DOMReadyCallback();\n                        // Execute all of them\n                    }\n                };\n\n                // /ready()\n                var bindReady = function() {\n                    var toplevel = false;\n\n                    if (readyBound) {\n                        return;\n                    }\n                    readyBound = true;\n\n                    // Catch cases where ready is called after the\n                    // browser event has already occurred.\n                    if (document.readyState !== \"loading\") {\n                        DOMReady();\n                    }\n\n                    // Mozilla, Opera and webkit nightlies currently support this event\n                    if (document.addEventListener) {\n                        // Use the handy event callback\n                        document.addEventListener(\"DOMContentLoaded\", DOMContentLoaded, false);\n                        // A fallback to window.onload, that will always work\n                        window.addEventListener(\"load\", DOMContentLoaded, false);\n                        // If IE event model is used\n                    } else if (document.attachEvent) {\n                        // ensure firing before onload,\n                        // maybe late but safe also for iframes\n                        document.attachEvent(\"onreadystatechange\", DOMContentLoaded);\n                        // A fallback to window.onload, that will always work\n                        window.attachEvent(\"onload\", DOMContentLoaded);\n                        // If IE and not a frame\n                        // continually check to see if the document is ready\n                        try {\n                            toplevel = window.frameElement == null;\n                        }\n                        catch (e) {\n                        }\n                        if (document.documentElement.doScroll && toplevel) {\n                            doScrollCheck();\n                        }\n                    }\n                };\n\n                // Handle when the DOM is ready\n\n                // The DOM ready check for Internet Explorer\n                var doScrollCheck = function() {\n                    if (isReady) {\n                        return;\n                    }\n                    try {\n                        // If IE is used, use the trick by Diego Perini\n                        // http://javascript.nwbox.com/IEContentLoaded/\n                        document.documentElement.doScroll(\"left\");\n                    }\n                    catch (error) {\n                        setTimeout(doScrollCheck, 1);\n                        return;\n                    }\n                    // and execute any waiting functions\n                    DOMReady();\n                };\n\n                registerOrRunCallback(callback);\n                bindReady();\n            };\n        }).call(this, dom);\n\n        if (dom.hasClass(document.documentElement, 'ixp-prevent-animations')) {\n            runtime.flags.preventAnimations = true;\n        }\n\n        // scroll visibility / parallax\n        (function(querySelectorAll, dom) {\n            var visStates;\n            var visCssMap = {};\n\n            constants.visibility = (function(visibility) {\n                var scrollPrefix = 'ixp-scroll-';\n\n                var css = visibility.css = visibility.css || {};\n                css.awareness = scrollPrefix + 'aware';\n                css.inOnce = scrollPrefix + 'in-once';\n                css.seen = scrollPrefix + 'seen';\n\n                var microthemes = css.microthemes = css.microthemes || {};\n                microthemes.awareness = 'ixp-scroll-aware-util';\n                microthemes.inOnce = 'ixp-scroll-in-once-util';\n\n                var states = css.states = css.states || {};\n                states.shown = scrollPrefix + 'in';\n                states.hidden = scrollPrefix + 'out';\n                states.entering = scrollPrefix + 'enter';\n                states.leaving = scrollPrefix + 'leave';\n\n                var events = visibility.events = visibility.events || {};\n                var visPrefix = 'visibility:';\n                events.recalculate = visPrefix + 'recalculate';\n                events.recalculating = visPrefix + 'recalculating';\n                events.change = visPrefix + 'change';\n\n                states = visibility.states = visibility.states || {};\n                states.shown = 'shown';\n                states.hidden = 'hidden';\n                states.entering = 'entering';\n                states.leaving = 'leaving';\n\n                visibility.awarenessDelay = 250;\n                if (runtime.flags.preventAnimations) {\n                    visibility.awarenessSelector = '.' + css.awareness + '.' + css.microthemes.awareness + ', .' + css.awareness + '.' + css.microthemes.inOnce;\n                } else {\n                    visibility.awarenessSelector = '.' + css.awareness;\n                }\n\n                visStates = states;\n\n                visCssMap[states.shown] = css.states.shown;\n                visCssMap[states.hidden] = css.states.hidden;\n                visCssMap[states.entering] = css.states.entering;\n                visCssMap[states.leaving] = css.states.leaving;\n\n                return visibility;\n            }).call(this, constants.visibility || {});\n\n            constants.parallax = (function(parallax) {\n                var css = parallax.css = parallax.css || {};\n                css.parallax = 'ixp-parallax';\n\n                parallax.parallaxSelector = '.' + parallax.css.parallax;\n\n                return parallax;\n            }).call(this, constants.parallax || {});\n\n\n            var getBoundingClientRect = function(el, options) {\n                options || (options = {});\n\n                var rect = el.getBoundingClientRect();\n                // Needed to support IE8\n                if (rect.height === undefined || rect.width === undefined) {\n                    rect = {\n                        top: rect.top,\n                        left: rect.left,\n                        bottom: rect.bottom,\n                        right: rect.right,\n                        height: rect.bottom - rect.top,\n                        width: rect.right - rect.left\n                    };\n                }\n                if (options.viewport) {\n                    rect = {\n                        top: rect.top + (options.viewport.scrollTop || 0),\n                        left: rect.left + (options.viewport.scrollLeft || 0),\n                        bottom: rect.bottom + (options.viewport.scrollTop || 0),\n                        right: rect.right + (options.viewport.scrollLeft || 0),\n                        height: rect.bottom - rect.top,\n                        width: rect.right - rect.left\n                    };\n                }\n                if (options.round) {\n                    rect = {\n                        top: Math.ceil(rect.top),\n                        left: Math.ceil(rect.left),\n                        bottom: Math.ceil(rect.bottom),\n                        right: Math.ceil(rect.right),\n                        height: Math.ceil(rect.height),\n                        width: Math.ceil(rect.width)\n                    };\n                }\n\n                return rect;\n            };\n\n            var isInViewport = function(el, options) {\n                options || (options = {});\n\n                var rect = getBoundingClientRect(el, { round: true, viewport: options.viewport });\n\n                // Needed to support IE8\n                var windowHeight = Math.ceil((options.viewport && options.viewport.windowHeight) || window.innerHeight || document.documentElement.clientHeight);\n                var windowWidth = Math.ceil((options.viewport && options.viewport.windowWidth) || window.innerWidth || document.documentElement.clientWidth);\n\n                if (options.tolerance == null) {\n                    if ((window.getComputedStyle && window.getComputedStyle(el, null).getPropertyValue('visibility')) === 'hidden') {\n                        return visStates.hidden;\n                    }\n\n                    // [MRM] There's a slight chance this could break scroll:always. If so, options needs to know\n                    // whether we're checking once or always, and only check the second clause if it's scroll:once\n                    if (rect.height >= windowHeight || ((rect.height * 2) > windowHeight && rect.top > 0)) {\n                        if ((rect.top > -rect.height) && (rect.top < windowHeight)) {\n                            return visStates.shown;\n                        } else {\n                            return visStates.hidden;\n                        }\n                    }\n\n                    if (((rect.top >= 0) && (rect.bottom < windowHeight)) &&\n                        ((rect.left >= 0) && (rect.left < windowWidth))) {\n                        return visStates.shown;\n                    } else if (rect.top >= windowHeight || rect.bottom <= 0 || rect.left >= windowWidth || rect.right <= 0) {\n                        return visStates.hidden;\n                    } else {\n                        if (options.direction === 'up') {\n                            if ((rect.top > -(rect.height / 2)) && ((rect.top + (rect.height / 2)) < windowHeight)) {\n                                return options.element.state == visStates.shown ? visStates.shown : visStates.entering;\n                            } else if ((rect.top > -rect.height) && (rect.top < windowHeight)) {\n                                return options.element.state == visStates.hidden ? visStates.hidden : visStates.leaving;\n                            }\n                        } else {\n                            if ((rect.top > -(rect.height / 2)) && ((rect.top + (rect.height / 2)) < windowHeight)) {\n                                return options.element.state == visStates.shown ? visStates.shown : visStates.entering;\n                            } else if ((rect.top > -rect.height) && (rect.top < windowHeight)) {\n                                return !options.element.state || options.element.state == visStates.hidden ? visStates.hidden : visStates.leaving;\n                            }\n                        }\n                    }\n\n                    return false;\n                }\n\n                var inView = false;\n                if (rect.height >= windowHeight) {\n                    options.tolerance = 0;\n                }\n\n                if (options.tolerance === 1) {\n                    inView = (rect.top >= 0) && (rect.bottom <= windowHeight);\n                } else if (options.tolerance < 1 && options.tolerance > 0) {\n                    var divisor = 1 / options.tolerance;\n                    var heightDivided = (rect.height / divisor);\n                    inView = (rect.top > -heightDivided) && ((rect.top + heightDivided) < windowHeight);\n                } else {\n                    inView = (rect.top > -rect.height) && (rect.top < windowHeight);\n                }\n\n                if (inView && options.edge) {\n                    if (options.edge === 'top') {\n                        inView = (rect.top >= 0);\n                    } else if (options.edge === 'bottom') {\n                        inView = (rect.bottom < windowHeight);\n                    }\n                }\n\n                return inView;\n            };\n\n            runtime.fn.isInViewport = isInViewport;\n\n            if (!querySelectorAll) {\n                return;\n            }\n\n            var appRoot = inStudio ? window.LIVEBALL : undefined;\n\n            var scrollAwareElements = [],\n                parallaxElements = [];\n\n            var getScrollAwareElements = function() {\n                var visibility = constants.visibility;\n                var els = querySelectorAll.call(document, visibility.awarenessSelector);\n                if (!els.length) {\n                    return [];\n                }\n\n                var el,\n                    once,\n                    results = [];\n\n                for (var i = 0, len = els.length; i < len; ++i) {\n                    el = els[i];\n                    once = dom.hasClass(el, visibility.css.inOnce);\n                    if (!once || !dom.hasClass(el, visibility.css.seen)) {\n                        results.push({ el: el, once: once });\n                    }\n                }\n                return results;\n            };\n\n            var getParallaxElements = function() {\n                var parallax = constants.parallax;\n                var els = querySelectorAll.call(document, parallax.parallaxSelector);\n                if (!els.length) {\n                    return [];\n                }\n\n                var regex = new RegExp('\\\\b' + parallax.css.parallax + '-(\\\\d+)');\n\n                var el,\n                    match,\n                    results = [];\n\n                for (var i = 0, len = els.length; i < len; ++i) {\n                    el = els[i];\n                    match = el.className.match(regex);\n\n                    results.push({\n                        el: el,\n                        // Linear\n                        //speed: 1 - ((match && match[1] && parseInt(match[1])) || 400) / 1000,\n                        // Exponential\n                        speed: 1 / (((match && match[1] && parseInt(match[1])) || 400) / 100)\n                    });\n                }\n                return results;\n            };\n\n            var getElements = function() {\n                scrollAwareElements = getScrollAwareElements();\n                parallaxElements = getParallaxElements();\n            };\n\n            var inCalculateVisibility = null,\n                inCalculateParallax = null,\n                lastScrollTop = 0;\n\n            var animationEndEvents = 'webkitAnimationEnd oanimationend MSAnimationEnd animationend';\n\n            var getScrollTop = function(options) {\n                if (options != null && options.scrollTop != null && !isNaN(options.scrollTop)) {\n                    return options.scrollTop;\n                }\n                return (window.pageYOffset || document.documentElement.scrollTop || 0) - (document.documentElement.clientTop || 0);\n            };\n\n            var calculateVisibility = function(options) {\n                options || (options = {});\n\n                var scrollTop = getScrollTop(options.viewport);\n                var delta = lastScrollTop - scrollTop;\n                if (delta !== 0 || options.force) {\n                    var vae,\n                        currentState,\n                        state;\n\n\n                    for (var i = 0, len = scrollAwareElements.length; i < len; ++i) {\n                        vae = scrollAwareElements[i];\n\n                        currentState = isInViewport(vae.el, { element: vae, direction: delta > 0 ? 'up' : 'down', viewport: options.viewport });\n\n                        vae.state = currentState;\n\n                        if (dom.hasClass(vae.el, visCssMap[currentState])) {\n                            continue;\n                        }\n\n                        for (state in visStates) {\n                            if (visStates.hasOwnProperty(state)) {\n                                dom.removeClass(vae.el, visCssMap[visStates[state]]);\n                            }\n                        }\n\n                        dom.addClass(vae.el, visCssMap[currentState]);\n\n                        if (currentState === visStates.shown && !vae.seen) {\n                            vae.seen = true;\n                            dom.addClass(vae.el, constants.visibility.css.seen);\n\n                            if (vae.once) {\n                                scrollAwareElements.splice(i, 1);\n                                i--;\n                                len = scrollAwareElements.length;\n\n                                if (vae.el.addEventListener) {\n                                    (function(el) {\n                                        var onAnimationEnd = function(e) {\n                                            if (e.target === el) {\n                                                dom.off(el, animationEndEvents, onAnimationEnd);\n                                                dom.removeClass(el, constants.visibility.css.states.shown);\n                                            }\n                                        };\n                                        dom.on(el, animationEndEvents, onAnimationEnd, { passive: true });\n                                    }).call(this, vae.el);\n                                }\n                            }\n                        }\n\n                        runtime.events.trigger(constants.visibility.events.change, {\n                            el: vae.el,\n                            once: vae.once,\n                            seen: vae.seen,\n                            state: currentState\n                        });\n                    }\n                }\n\n                lastScrollTop = scrollTop;\n                inCalculateVisibility = null;\n            };\n\n            var backgroundImageRegex = /url\\(\\s*[\"']?([^\"']+)[\"']?\\s*\\)/;\n\n            var getNormalizedBackgroundPosition = function(el) {\n                var pos = el.style.backgroundPosition.split(' ');\n                if (pos.length === 1) {\n                    pos[0] = el.style.backgroundPositionX;\n                    pos[1] = el.style.backgroundPositionY;\n                }\n\n                for (var i = 0, len = pos.length; i < len; i++) {\n                    switch (pos[i]) {\n                        case 'left':\n                            pos[i] = '0%';\n                            break;\n                        case 'right':\n                            pos[i] = '100%';\n                            break;\n                        case 'top':\n                            pos[i] = '0%';\n                            break;\n                        case 'bottom':\n                            pos[i] = '100%';\n                            break;\n                        case 'center':\n                            pos[i] = '50%';\n                            break;\n                    }\n                }\n\n                pos[0] = pos[0] || '0%';\n                return pos;\n            };\n\n            var getParallaxImageDimensions = function(callback, pe, height, delta, divisor) {\n                var match = pe.el.style.backgroundImage.match(backgroundImageRegex);\n                if (match) {\n                    var img = new Image();\n\n                    img.onload = function() {\n                        callback.call(this, pe, height, delta, divisor);\n                    };\n\n                    img.src = match[1];\n                }\n                return !!match;\n            };\n\n            var calculateParallaxWithImageDimensions = function(pe, height, delta, divisor) {\n                pe.y = (height - this.height) / divisor;\n                if (delta) {\n                    pe.el.style.backgroundPosition = pe.x + ' ' + (pe.y + delta) + 'px';\n                }\n            };\n\n            var calculateParallax = function(options) {\n                options || (options = {});\n\n                var scrollTop = getScrollTop(options.viewport);\n\n                var pe,\n                    delta,\n                    rect;\n\n                for (var i = 0, len = parallaxElements.length; i < len; ++i) {\n                    pe = parallaxElements[i];\n\n                    if (!isInViewport(pe.el, { tolerance: 0, viewport: options.viewport })) {\n                        continue;\n                    }\n\n                    delta = -scrollTop * pe.speed;\n                    rect = getBoundingClientRect(pe.el);\n\n                    // Save info about the element the first time it is visible\n                    if (pe.bgPos === undefined) {\n                        var backgroundPosition = getNormalizedBackgroundPosition(pe.el);\n                        pe.bgPos = backgroundPosition;\n                        pe.x = backgroundPosition[0];\n\n                        var y = backgroundPosition[1];\n                        if (y.charAt(y.length - 1) === '%') {\n                            y = parseInt(y, 10);\n                            if (y === 0) {\n                                pe.y = 0;\n                            } else {\n                                var divisor = 100 / y;\n                                pe.y = rect.height / divisor;\n                                if (getParallaxImageDimensions(calculateParallaxWithImageDimensions, pe, rect.height, delta, divisor)) {\n                                    continue;\n                                }\n                            }\n                        } else {\n                            pe.y = parseFloat(y);\n                        }\n\n                        if (delta) {\n                            pe.el.style.backgroundPosition = pe.x + ' ' + (pe.y + delta) + 'px';\n                        }\n\n                        continue;\n                    }\n\n                    pe.el.style.backgroundPosition = pe.x + ' ' + (pe.y + delta) + 'px';\n                }\n\n                inCalculateParallax = null;\n            };\n\n            var calculate = function(e, options) {\n                if (!scrollAwareElements.length && !parallaxElements.length) {\n                    return;\n                }\n\n                options || (options = {});\n\n                var ee = {\n                    options: options,\n                    cancel: false\n                };\n\n                runtime.events.trigger(constants.visibility.events.recalculating, ee);\n\n                if (ee.cancel) {\n                    return;\n                }\n\n                var force = options.force;\n                if ((force || !inCalculateVisibility) && scrollAwareElements.length) {\n                    if (inCalculateVisibility) {\n                        clearTimeout(inCalculateVisibility);\n                    }\n\n                    inCalculateVisibility = setTimeout(function() {\n                        calculateVisibility({ force: force, viewport: options.viewport });\n                    }, options.delay || constants.visibility.awarenessDelay);\n                }\n\n                if ((force || !inCalculateParallax) && parallaxElements.length) {\n                    if (inCalculateParallax) {\n                        clearTimeout(inCalculateParallax);\n                    }\n\n                    inCalculateParallax = setTimeout(function() {\n                        calculateParallax({ viewport: options.viewport });\n                    }, 1);\n                }\n            };\n\n            var recalculate = function(options) {\n                options || (options = {});\n\n                if (options.reset) {\n                    getElements();\n                }\n                calculate(null, { force: true, delay: options.delay || 1, viewport: options.viewport });\n            };\n\n            var updateScreenResolution = function () {\n\r\n                if (inStudio) return;\r\n\r\n                var respondentId = getRespondentId();\n\n                if (!!parseInt(respondentId, 10)) {\n                    var screenResolution = window.screen.width + 'X' + window.screen.height;\n\n                    $ajax({\n                        url: '/admin/api/v1/respondents/screenresolution/' + respondentId,\n                        data: { screenResolution: screenResolution },\n                        type: 'PUT',\n                        queue: false\n                    });\n                }\r\n            } \n\n            dom.ready(function() {\n                updateScreenResolution();\n                getElements();\n\n                if (!scrollAwareElements.length && !parallaxElements.length && !appRoot) {\n                    return;\n                }\n\n                dom.on(window, 'scroll', calculate, { passive: true });\n\n                dom.on(window, 'resize', function(e) {\n                    calculate(e, { force: true });\n                }, { passive: true });\n\n                runtime.events.on(window, constants.visibility.events.recalculate, recalculate);\n\n                calculate(null, { force: true });\n\n                if (appRoot) {\n                    var parallaxRegex = new RegExp('\\\\b' + constants.parallax.css.parallax + '\\\\b');\n                    var scrollAwareRegex = new RegExp('\\\\b' + constants.visibility.css.awareness + '\\\\b');\n\n                    // Wait for the app to finish intialization\n                    var intervalId = window.setInterval(function() {\n                        if (appRoot.App && appRoot.App.vent) {\n                            window.clearInterval(intervalId);\n\n                            var recalcTimeout;\n\n                            appRoot.App.vent.subscribe('style:changed:background style:changed:customClass element:microtheme:applied element:microtheme:removed', function(e) {\n                                if (e && e.classes) {\n                                    if (!e.classes.match(scrollAwareRegex) && !e.classes.match(parallaxRegex)) {\n                                        return;\n                                    }\n                                }\n\n                                // Reset any modified background positions\n                                var pe;\n                                for (var i = 0, len = parallaxElements.length; i < len; ++i) {\n                                    pe = parallaxElements[i];\n                                    if (pe.bgPos) {\n                                        pe.el.style.backgroundPosition = pe.bgPos.join(' ');\n                                    }\n                                }\n                                parallaxElements = [];\n\n                                if (recalcTimeout) {\n                                    window.clearTimeout(recalcTimeout);\n                                    recalcTimeout = null;\n                                }\n\n                                recalcTimeout = setTimeout(function() {\n                                    recalculate({ reset: true });\n                                }, 250);\n                            });\n                        }\n                    }, 500);\n                }\n            });\n\n        }).call(this, document.querySelectorAll, dom);\n\n        // runtime interaction events\n        (function() {\n            runtime.constants.interaction = runtime.constants.interaction || {};\n            runtime.constants.interaction = {\n                attrSelector: '[data-ixp-interaction]',\n                triggerAttrSelector: '[data-ixp-interaction-trigger]'\n            };\n\n            var runAction = function(action) {\n                var targetAndName = (action.name).toLowerCase();\n                var index = targetAndName.lastIndexOf(':');\n                var target = targetAndName.substring(0, index);\n                var name = targetAndName.substring(index + 1);\n\n                try {\n                    action.data || (action.data = {});\n                    if (target === 'runtime') {\n                        switch (name) {\n                            case 'tag':\n                                return runtime.tag(action.data.tag, action.data.options);\n                            case 'convert':\n                                return runtime.convert(action.data.options);\n                            case 'scrollto':\n                                return runtime.scrollTo(action.data.anchor, action.data.options);\n                        }\n                        return Promise.reject();\n                    }\n\n                    var result = runtime.components.sendCommand && runtime.components.sendCommand(name, target, action.data);\n                    return Promise.resolve(result);\n\n                } catch (e) {\n                    return Promise.reject(e);\n                }\n            };\n\n            var stopPolling = false;\n\n            $promise.then(function($) {\n                runtime.ready(function() {\n                    var onActionTrigger = function(e) {\n                        var $trigger = $(this);\n\n                        var data = $trigger.attr('data-ixp-interaction');\n                        if (!data) {\n                            return;\n                        }\n                        data = JSON.parse(data);\n\n                        var eventType = e.type;\n                        var actions = data[eventType];\n                        if (!actions || !actions.length) {\n                            return;\n                        }\n\n                        if (eventType.toLowerCase() === 'click') {\n                            e.preventDefault();\n                        }\n\n                        var promise;\n\n                        for (var i = 0, len = actions.length; i < len; i++) {\n                            var action = actions[i];\n                            if (action.queue === false) {\n                                runAction(action)['catch'](function(reason) {\n                                    console.warn(reason);\n                                });\n                            } else {\n                                if (promise) {\n                                    promise = promise.then(function() {\n                                        return runAction(action);\n                                    });\n                                } else {\n                                    promise = runAction(action);\n                                }\n                            }\n                        }\n\n                        if (promise) {\n                            promise['catch'](function(reason) {\n                                console.warn(reason);\n                            });\n                        }\n                    };\n\n                    var events = ['click', 'hover'];\n                    var $document = $(document);\n                    for (var i = 0, len = events.length; i < len; i++) {\n                        var evt = events[i];\n                        $document.on(evt + '.ixp-runtime', '[data-ixp-interaction-trigger~=\":' + evt + '\"]', onActionTrigger);\n                    }\n\n                    var scrollToHash = {};\n                    var onHasChanging = function(e) {\n                        var hash = e.hash && e.hash.toLowerCase();\n                        if (hash && window.location.hash.toLowerCase() !== ('#' + hash)) {\n                            scrollToHash[hash] = true;\n                        }\n                    };\n\n                    runtime.events.on(runtime, 'runtime:scrollto:hash:changing', onHasChanging);\n                    runtime.events.on(runtime, 'runtime:scrollto:ignore:hash:changing', onHasChanging);\n\n                    var scrollTo = _.debounce(runtime.scrollTo, 100);\n\n                    var onHashChange = function() {\n                        var hash = window.location.hash;\n                        if (hash) {\n                            if (hash.indexOf('#') === 0) {\n                                hash = hash.substring(1);\n                            }\n\n                            var hashMatch = hash.toLowerCase();\n                            if (scrollToHash[hashMatch]) {\n                                scrollToHash[hashMatch] = undefined;\n                            } else {\n                                scrollTo(hash);\n                            }\n                        }\n                    };\n\n                    $(window).on('hashchange.ixp-runtime', onHashChange);\n\n                    $(function() {\n                        stopPolling = true;\n                        if (runtime.flags.nativeAnchorSupport) {\n                            $('a[data-ixp-hidden-anchor]').remove();\n                        }\n                    });\n                });\n            });\n\n            (function() {\n                var ensureScrollToElement = function(hash) {\n                    var target = findElementByIxpAnchor(hash);\n                    if (target) {\n                        runtime.scrollTo(target, { updateUrlHash: true });\n                        return;\n                    }\n\n                    if (stopPolling) {\n                        return;\n                    }\n\n                    if (_.isFunction(window.requestAnimationFrame)) {\n                        window.requestAnimationFrame(function() {\n                            ensureScrollToElement(hash);\n                        });\n                    } else {\n                        setTimeout(function() {\n                            ensureScrollToElement(hash);\n                        }, 10);\n                    }\n                };\n\n                var hash = window.location.hash;\n                if (hash) {\n                    if (hash.indexOf('#') === 0) {\n                        hash = hash.substring(1);\n                    }\n\n                    if (runtime.anchors && runtime.anchors[hash.toLowerCase()]) {\n                        ensureScrollToElement(hash);\n\n                        window.addEventListener('load', function () {\n                            ensureScrollToElement(hash);\n                        });\n                    }\n                }\n            }).call(this);\n        }).call(this);\n\n        (function() {\n            isReady = true;\n\n            if (readyQueue.length === 0) {\n                return;\n            }\n\n            for (var i = 0, len = readyQueue.length; i < len; i++) {\n                try {\n                    readyQueue[i]();\n                } catch (e) {\n                    console.error(e);\n                }\n            }\n        }).call(this);\n\n        // window.navigator.sendBeacon polyfill\n        (function () {\n            if ('navigator' in this && 'sendBeacon' in this.navigator) {\n                return;\n            }\n            if (!('navigator' in this)) {\n                this.navigator = {}\n            }\n            this.navigator.sendBeacon = sendBeacon.bind(this);\n            function sendBeacon (url, data) {\n                var xhr = ('XMLHttpRequest' in this)\n                    ? new XMLHttpRequest()\n                    : new ActiveXObject('Microsoft.XMLHTTP');\n\n                xhr.open('POST', url, false); // Set 'false' for prevent browser canceling when tab closed\n                xhr.withCredentials = true;\n                xhr.setRequestHeader('Accept', '*/*');\n\n                if (_.isString(data)) {\n                    xhr.setRequestHeader('Content-Type', 'text/plain;charset=UTF-8');\n                    xhr.responseType = 'text';\n                } else if (data instanceof Blob && data.type) {\n                    xhr.setRequestHeader('Content-Type', data.type);\n                }\n\n                try {\n                    xhr.send(data)\n                } catch (error) {\n                    return false\n                }\n\n                return true\n            }\n\n        }).call(window);\n    })();\n})(window, document);\n"]}