{"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) \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 \n * Released under MIT license \n * Based on Underscore.js 1.8.3 \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: }] 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"]}