{"version":3,"sources":["../config-wrap-start-default.js","paychex.core/CUE.js","paychex.core/DeviceProfile.js","paychex.core/Errors.js","paychex.core/Eventing.js","paychex.core/FileOpener.js","paychex.core/InheritanceHelper.js","paychex.core/lib/canvas-to-blob.js","paychex.core/lib/dag.js","paychex.core/lib/nextTick.js","paychex.core/lib/pica.js","paychex.core/lib/queue.js","paychex.core/lib/tsort.js","paychex.core/lib/ua-parser.min.js","paychex.core/lib/usertiming.min.js","paychex.core/Logger.js","paychex.core/ModelList.js","paychex.core/native/AppReviewHelper.js","paychex.core/native/PluginManager.js","paychex.core/NotificationData.js","paychex.core/PaychexError.js","paychex.core/ProgressServiceFactory.js","paychex.core/Promise.js","../node_modules/json-stringify-safe/stringify.js","../node_modules/url-search-params-polyfill/index.js","paychex.core/Prototypes.js","paychex.core/Repository.js","paychex.core/Schedulers.js","paychex.core/signals/AutoResetSignal.js","paychex.core/signals/CountdownSignal.js","paychex.core/signals/ManualResetSignal.js","paychex.core/StateMachine.js","paychex.core/stores/AsyncStore.js","paychex.core/stores/CookieStorage.js","paychex.core/stores/EmptyStore.js","paychex.core/stores/HTML5Storage.js","paychex.core/stores/IndexedDBStore.js","paychex.core/stores/LocalStorage.js","paychex.core/stores/SessionStorage.js","paychex.core/stores/Store.js","paychex.core/stores/StoreToAsyncStoreWrapper.js","paychex.core/stores/TemporaryStore.js","paychex.core/SubscriptionManager.js","paychex.core/Tracker.js","paychex.core/TriggerMixin.js","paychex.core/UserFeedback.js","paychex.core/Utils.js","paychex.core/utils/FileUtils.js","paychex.core/utils/Overloader.js","paychex.core/Validator.js","paychex.core/WindowOpener.js","paychex.core/Workflows.js"],"names":["define","PIH","_","_formatCorrelationID","correlationId","result","attempt","isEmpty","split","pop","isError","CUE","message","cause","type","this","formattedCorrelationId","stack","Error","undefined","ERROR_TYPES","CRITICAL","extend","APPLOAD","formatCorrelationID","UAParser","getDeviceCategory","uaDevice","isFunction","uaParser","getDevice","toUpperCase","deviceCategory","category","navigator","platform","deviceTypes","constants","PHONE","getBrowserProfile","browser","pick","getBrowser","defaultVersion","version","versions","get","merge","defaults","name","family","full","join","major","minor","getOSName","DESKTOP","TABLET","GAME_CONSOLE","OTHER","PDA","PERSONAL_COMPUTER","SMART_TV","SMARTPHONE","UNKNOWN","WEARABLE_COMPUTER","devices","DEVICE","MODEL","VENDOR","TYPE","MOBILE","device","Categories","getUAParser","getDeviceResult","getResult","getDeviceProfile","getOSProfile","getOS","getEngineProfile","getEngine","setUAParser","uaParserObj","isObject","setUserAgent","uaString","setUA","isMobile","isPhone","isDesktop","isTablet","isIPhone","isAppleOS","isAndroidOS","isSafari","browserProfile","toLowerCase","isFirefox","isInternetExplorer","document","documentMode","isEdge","window","StyleMedia","isNative","getXPlatformInfo","osname","toLower","PaychexError","Logger","Overloader","Errors","createDynamicErrorClassIfNeeded","className","eval","prototype","constructor","getErrorInstance","inner","typename","props","instance","causedBy","severity","Severity","ERROR","methods","overload","ignored","arguments","length","invoke","throw","apply","toArray","fatal","throwFatal","err","FATAL","none","throwNone","NONE","swallow","logAndSwallow","logName","error","rethrow","rethrowAs","args","unshift","Types","Data","Http","IllegalArgument","Invocation","RemoteOperation","RestOperation","Timeout","Type","Validation","UserCancellation","Promise","Workflows","Validator","Broker","wfs","ErrorMessages","SUBSCRIBE","ANNOUNCE","getName","register","subscribe","topic","process","commit","rollback","isTypeMatch","wfName","sluggify","wf","step","uniqueId","create","addStep","execute","e","dispatchArgs","resolve","reject","success","failure","unregister","removeStep","fire","announce","source","payload","timeout","isNumber","dispatch","then","constant","brokers","isBroker","broker","makeNewEventBroker","brokerName","String","WindowOpener","open","includes","Array","slice","call","winRef","catch","PaychexInheritanceHelper","inherit","proto","F","Child","Parent","parent","superConstructor","that","t","HTMLCanvasElement","o","Blob","Boolean","n","Uint8Array","size","r","BlobBuilder","WebKitBlobBuilder","MozBlobBuilder","MSBlobBuilder","a","i","atob","ArrayBuffer","l","u","c","f","b","d","B","match","decodeURIComponent","charCodeAt","append","getBlob","toBlob","mozGetAsFile","setTimeout","toDataURL","amd","module","exports","dataURLtoBlob","Queue","tsort","noop","edges","concurrency","iterator","cb","selectEdge","id","graph","filter","action","next","children","forEach","notify","fulfilled","push","parents","queue","bootstrap","sorted","path","onerror","drain","requestAnimationFrame","g","global","self","pica","s","require","code","1","MathLib","requested_features","preload","__requested_features","__initPromise","__wasm_module","wasm_module","features","js","wasm","resetAlpha","dst","width","height","ptr","len","asUint8Array","src","buffer","byteLength","copyInt16asLE","target","target_offset","IS_LE","set","data","base64decode","math_wasm_base64","init","_this","unsharp","unsharp_js","indexOf","resize","resize_js","WebAssembly","resize_wasm","compile","resizeAndUnsharp","options","cache","unsharpAmount","toWidth","toHeight","unsharpRadius","unsharpThreshold","createFilters","Uint32Array","__","srcW","srcH","destW","destH","scaleX","scaleY","offsetX","offsetY","dest","quality","alpha","fx_key","fy_key","filtersX","filtersY","alloc_bytes","Math","max","alloc_pages","ceil","wasm_imports","env","memory","Memory","initial","mem_pages","grow","wasm_instance","Instance","mem","mem32","src32","tmp_offset","filtersX_offset","filtersY_offset","convolveHV","dest32","subarray","./mathlib/resize_filter_gen","./mathlib/resize_js","./mathlib/unsharp_js","./mathlib/wasm/math_wasm_base64","./utils","2","img","min","out","Uint16Array","3","clampTo8","convolveHorizontally","filters","filterPtr","filterShift","filterSize","srcPtr","srcY","destX","filterVal","srcOffset","destOffset","convolveVertically","4","toFixedPoint","num","round","FIXED_FRAC_BITS","FILTER_INFO","srcSize","destSize","scale","offset","destPixel","srcPixel","srcFirst","srcLast","filterElementSize","floatFilter","fxpFilter","total","pxl","idx","floatVal","filterTotal","leftNotEmpty","rightNotEmpty","filterFunction","scaleInverted","scaleClamped","srcWindow","win","maxFilterElementSize","floor","packedFilter","Int16Array","packedFilterPtr","slowCopy","Float32Array","./resize_filter_info","5","x","xpi","PI","sin","cos","6","tmp","./resize_convolve_js","./resize_filter_gen","7","glurMono16","getLightness","amount","radius","threshold","h","m1","m2","hShifted","diff","iTimes4","lightness","blured","amountFp","thresholdFp","abs","./lightness16_js","glur/mono16","8","9","Pool","idle","available","acquired","lastId","timeoutId","acquire","resource","release","_this2","lastUsed","Date","now","gc","_this3","destroy","10","pixelFloor","nearest","PIXEL_EPSILON","pixelCeil","y","innerX","innerY","toTileWidth","toTileHeight","tile","innerTileWidth","srcTileSize","destTileBorder","innerTileHeight","tiles","toX","toY","toInnerX","toInnerY","toInnerWidth","toInnerHeight","11","objClass","obj","Object","toString","isCanvas","element","cname","isImage","limiter","roll","active","shift","fn","cib_quality_name","cib_support","createImageBitmap","createElement","resizeWidth","resizeHeight","resizeQuality","bitmap","status","close","str","input","replace","bits","charAt","tailbits","12","mathLib","onmessage","ev","opts","postMessage","./mathlib","13","gaussCoef","sigma","exp","g1","g2","k","a0","a1","a2","a3","b1","b2","left_corner","right_corner","convolveMono16","line","coeff","prev_src","curr_src","curr_out","prev_out","prev_prev_out","src_index","out_index","line_index","j","coeff_a0","coeff_a1","coeff_b1","coeff_b2","blurMono16","tmp_line","14","toObject","val","TypeError","getOwnPropertySymbols","hasOwnProperty","propIsEnumerable","propertyIsEnumerable","assign","test1","getOwnPropertyNames","test2","fromCharCode","map","test3","letter","keys","from","symbols","to","key","15","bundleFn","sources","stringify","JSON","resolveSources","workerSources","depPath","depKey","wkey","cacheKeys","default","pow","random","wcache","Function","skey","scache","URL","webkitURL","mozURL","msURL","blob","bare","workerUrl","createObjectURL","worker","Worker","objectURL","/","workerFabric","value","webworkify","terminate","url","revokeObjectURL","Pica","DEFAULT_PICA_OPTS","limiter_key","__limit","singletones","utils","cib","ww","__workersPool","__mathlib","createRegions","NEED_SAFARI_FIX","userAgent","hardwareConcurrency","DEFAULT_RESIZE_OPTS","CAN_NEW_IMAGE_DATA","ImageData","Uint8ClampedArray","wpool_key","initMath","mathlib","checkCib","debug","all","isNaN","toHeigth","naturalWidth","naturalHeight","canceled","cancelToken","toCtx","getContext","imageBitmap","drawImage","tmpCanvas","tmpCtx","iData","getImageData","putImageData","srcCtx","srcImageBitmap","invokeResize","w","wasm_nodule","processTile","srcImageData","globalCompositeOperation","toImageData","createImageData","cleanup","regions","jobs","resizeBuffer","canvas","mimeType","asString","asBuffer","./lib/mathlib","./lib/pool","./lib/tiler","./lib/utils","./lib/worker","object-assign","nextTick","_iterator","_concurrency","_tasks","_err","workers","defineProperty","items","start","isArray","cc","sat","saturated","task","bind","empty","N","doVisit","idstr","ancestors","node","nodes","visited","afterId","v","doFilter","critical","ex","MAJOR","NAME","VERSION","util","regexes","extensions","concat","has","str1","str2","lowerize","mapper","rgx","p","q","matches","regex","exec","getUA","test","maps","oldsafari","?","1.0","1.2","1.3","2.0","2.0.2","2.0.3","2.0.4","amazon","model","Fire Phone","sprint","Evo Shift 4G","vendor","HTC","Sprint","os","windows","ME","NT 3.11","NT 4.0","2000","XP","Vista","8.1","RT","cpu","engine","uastring","ua","rgxmap","getCPU","BROWSER","CPU","ARCHITECTURE","CONSOLE","SMARTTV","WEARABLE","EMBEDDED","ENGINE","OS","$","jQuery","Zepto","parser","prop","performance","_perfRefForUserTimingPolyfill","userTimingJsNow","userTimingJsNowPrefixed","userTimingJsUserTiming","userTimingJsUserTimingPrefixed","userTimingJsPerformanceTimeline","userTimingJsPerformanceTimelinePrefixed","timing","navigationStart","getEntries","mark","substr","entryType","m","sort","startTime","splice","getEntriesByType","getEntriesByName","SyntaxError","duration","clearMarks","measure","clearMeasures","log4js","getLogger","TriggerMixin","ModelList","myId","activeItem","lastActiveIndex","fnValueOf","fnDefaultSort","fnDefaultGroup","fnDefaultFilter","fnSort","fnGroup","fnFilter","groupings","meta","allItems","currentItems","selectedItems","internal","getObjMeta","hash","removeObjMeta","assignValueOf","item","objMeta","origValueOf","valueOf","getNewGroup","arr","on","invokeMap","values","removeEmptyGroups","handleItemsChange","omitBy","list","isEqual","getSize","mergeFiltered","reApplyGroup","groups","groupBy","forOwn","group","itemMeta","prevGroup","prev","groupName","trim","pause","remove","resume","add","sortBy","filterBy","doCorrectSort","incoming","reApplySort","reApplyFilter","updateSelectedItemsIfNecessary","intersection","updateActiveItemIfNecessary","activeIndex","newActiveItem","isNull","setActiveItem","updateLastActiveIndex","visibleOnly","flattenDeep","isNullOrUndefined","uniq","difference","trigger","update","updateItems","index","load","loadItems","toAdd","toRemove","toUpdate","removeAll","getItems","clone","orderBy","newFnSort","propagate","newSort","newFnGroup","newGroup","newFnFilter","newFilter","getGroups","getSelected","getSelectedItems","setSelected","setSelectedItems","partialRight","toggleSelected","toggleSelectedItems","toSelect","toDeselect","current","union","getActiveItem","getActive","setActive","isUndefined","moveNext","wrap","atEnd","movePrev","movePrevious","atStart","setValueOf","fnNewValueOf","newValueOf","LocalStorage","Tracker","DeviceProfile","AppReviewHelper","reviewHandler","log","trace","showReview","activityId","userPromptString","getTime","optionals","reviewThreshold","DEFAULT_REVIEW_THRESHOLD","STORAGE_KEY","cloneDeep","DEFAULT_DATA","isString","isNil","save","activities","quietUntil","IN_QUIET_PERIOD","REVIEW_QUIET_PERIOD_IN_DAYS","imageId","errors","ERROR_OCCURRED","THRESHOLD_NOT_MET","NOT_NATIVE_DEVICE","reset","RESULTS","Eventing","_initPlugin","plugin","pluginPlatform","_addPluginEvents","newPlugin","events","pickBy","eventSubscription","eventName","addPluginEventHandler","fcall","tap","plugins","registeredEvents","flatten","eventReg","PluginManager","eventBroker","flatMap","pluginPlatformReady","defer","pendingEvents","registerPlugin","isPluginRegistered","promise","firePluginEvent","event","failIfNoEventRegistered","deferredEventFire","isPluginEventRegistered","property","handler","pluginId","eventRegistration","approve","done","originalUnregister","pull","pendingEvent","some","getPlugin","find","platformReady","callbacks","misc","cancel","isCanceled","formatError","msg","readwrite","writable","enumerable","configurable","toJSON","reduce","Rx","EMPTY","defaultPayload","saving","totalInProgress","loading","processing","batchScheduler","announceUpdates","activeTasks","mapValues","countBy","updateBlockingStatus","curr","deferBlocking","scheduler","activities$","Subject","api","whenFree","isPending","operation","spread","startWith","currentActivities","pairwise","registerActivity","subCategory","config","activity","blocking","onNext","finally","isErrorType","isErrorTypeOnWindow","convertToErrorType","getPrototypeOf","$$state","setScheduler","getValue","origAll","promises","isPlainObject","keyBy","origCatch","tail","callback","types","compact","matchesDesiredErrorType","ErrorType","allSettled","settle","orig","zipObject","prom","ms","fapply","replacer","spaces","cycleReplacer","serializer","thisPos","Infinity","getSerialize","URLSearchParams","search","__URLSearchParams__","pairs","decode","encode","!","'","(",")","~","%20","%00","encodeURIComponent","makeIterator","iterable","Symbol","dict","delete","getAll","thisArg","query","ret","entries","polyfill","Performance","safeStringify","oThis","aArgs","fToBind","NOP","fBound","every","fun","searchElement","Number","T","A","O","kValue","mappedValue","removeAtIndex","arrIndex","pred","predicate","findIndex","any","parseISO8601","parts","dateParts","timeParts","timeSubParts","timeSecParts","timeHours","_date","setUTCFullYear","setUTCMonth","setUTCDate","setUTCHours","setUTCMinutes","setUTCSeconds","setUTCMilliseconds","MutationObserver","WebKitMutationObserver","H","takeRecords","_period","addedNodes","removedNodes","previousSibling","nextSibling","attributeName","attributeNamespace","oldValue","I","J","attributes","C","namespaceURI","nodeType","nodeValue","childNodes","z","D","E","K","mo_id","G","observe","attributeFilter","attributeOldValue","childList","subtree","characterData","characterDataOldValue","disconnect","clearTimeout","undefined_","object","nameOf","defProp","func","toSource","funcName","createStorage","creator","storage","weakmap","WM","defaultCreator","getProps","hasOwn","puid","createUID","secret","unlock","store","dataDesc","uids","globalID","isExtensible","WeakMap","initialize","validate","unwrap","delete_","had","collection","stringifier","prep","__proto__","method","Element","closest","ownerDocument","querySelectorAll","el","parentElement","EXCLUDED_PROPS","foo","originalStringify","cookies","session","local","EmptyStore","base","root","immediate","fns","guard","obj2","setImmediate","addEventListener","setAttribute","getAttribute","ManualResetSignal","AutoResetSignal","signaled","signal","queued","waitOne","isResolved","CountdownSignal","initialCount","counter","decrement","count","number","increment","Transition","criteria","invokeInContext","machine","context","states","methodName","state","StateMachine","getHandler","withinState","conditions","results","executed","invocation","transitions","Events","STATE_ENTER","STATE_LEAVE","getNextState","transition","getStateMachineError","reason","handled","handleError","setCurrentState","stop","retry","fail","setResult","finish","addState","stateName","stateDef","stateToAdd","validateArgs","addStates","addTransition","fromState","toState","localCriteria","complete","resultsOrError","MACHINE_STOP","nextState","localStateName","MACHINE_START","overwrite","tryMoveNext","machineStarted","one","waitForState","unsubscribe","Store","AsyncStore","ready","clear","fill","isAsyncStore","isStore","hasIn","replaceInvalidChars","part","INVALID_CHARS","cookie","head","setValueForName","expired","expires","option","getValueForName","startsWith","json","substring","SKIP_CHAR","parse","STORE_GET","STORE_SET","itemName","itemValue","domain","COOKIE_DOMAIN","STORE_REMOVE","kvp","getValueFromName","getItem","res","setItem","removeItem","range","setPrefixedGlobal","defaultValue","proper","READ_WRITE","indexedDBTransaction","mode","successHandler","transaction","db","objectStore","errorArgs","onabort","onsuccess","localStorageTransaction","invokeAgain","continue","prefix","localStorage","transactionStrategy","subjects","onCompleted","cursor","asObservable","InitializeIndexedDBStore","request","indexedDB","database","onupgradeneeded","createUpgrade","isSafeInteger","HTML5Store","sessionStorage","abandon","validator","AsyncStoreWrapper","NotificationData","isPaused","lists","localKey","notificationData","Tracking","Subscriptions","pubSub","suspend","provider","getErrorMessage","feedback","email","submit","jsonSafeStringify","mixin","arrayUnionCustomizer","objValue","srcValue","arrayConcatCustomizer","serialize","chr","cloneTrue","RegExp","forIn","cross","rxWS","rxVar","rxCSS","css","var","upperFirst","identity","firstDefined","negate","invokeIf","alt","invokeLimitReached","invokeCount","exponentialFalloff","multiplier","getDelay","BASE","OFFSET","MULTIPLIER","lhs","rhs","isEqualWith","array","fromIndex","toFind","uniqWith","differenceWith","intersectionWith","isBlob","image","resizeImage","isFinite","DEFAULT_HEIGHT_AND_WIDTH","mimetype","inRange","QUALITY_MAX","DEFAULT_QUALITY","Image","onload","cast","resized","convertBlobToBase64","errorResult","reader","FileReader","readAsDataURL","methodKeys","localArgs","isArguments","functions","reverse","validateFunctionArgCount","minArgCount","localMin","localMax","MIN_VALUE","MAX_VALUE","minLength","matchesType","itemType","rx","pattern","isRegExp","localValues","localTypes","localType","validationMap","*","null","string","function","pojo","regexp","date","isDate","boolean","isBoolean","bool","nonemptystring","_openWindow","failureHandler","_openNewWindow","info","dag","NON_EMPTY","MISSING_KEY","MAX_CONCURRENCY","ADD_SEQUENCE","INJECT_STEP","DISPATCH_ARG_TYPES","DISPATCH_NEGATIVE_TIMEOUT","Workflow","level","State","RUNNING","RESOLVED","REJECTED","CANCELED","depends","localName","localDepends","localFunc","partial","dep","addSequence","steps","localSteps","space","memoize","repeat","numParents","elem","injectStep","stepName","stepsToPrecede","stepObjectOrFunction","localPrecedes","localStepObject","precedingStepName","dependencyExists","edge","onMissingStep","trackingData","Cancelable","WORKFLOW_COMPLETE","params","localTracking","localTimeout","aborted","getStepContext","contexts","getFullStep","failureReason","reduceRight","when","metaData","workflow","isNotStopped","baseTimer","assignIn","tags","isStepMissing","proceed","abort","timers","stepContext","tryExecuteStep","stepSuccess","stepFailure","originalReason","stepTimer","race","toFixed","once"],"mappings":"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","file":"paychex.core.min.js","sourcesContent":["/**\r\n * @license\r\n * (The MIT License)\r\n * \r\n * Copyright (C) 2014-2017 by Vitaly Puzrin and Andrei Tuputcyn\r\n * \r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n * \r\n * The above copyright notice and this permission notice shall be included in\r\n * all copies or substantial portions of the Software.\r\n * \r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n * THE SOFTWARE.\r\n * \r\n **/\r\n/**\r\n * @license\r\n * The ISC License\r\n * \r\n * Copyright (c) Isaac Z. Schlueter and Contributors\r\n * \r\n * Permission to use, copy, modify, and/or distribute this software for any\r\n * purpose with or without fee is hereby granted, provided that the above\r\n * copyright notice and this permission notice appear in all copies.\r\n * \r\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\r\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\r\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\r\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\r\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\r\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR\r\n * IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\r\n * \r\n **/\r\n/**\r\n * @license\r\n * dag, nextTick, queue, tsort\r\n * \r\n * (The MIT License)\r\n * \r\n * Copyright (c) 2012 Jake Luer jake@qualiancy.com (http://qualiancy.com)\r\n * \r\n * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\r\n * \r\n * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\r\n * \r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r\n * \r\n **/\r\n/**\r\n * @license\r\n * UAParser.js v0.7.3\r\n * Lightweight JavaScript-based User-Agent string parser\r\n * https://github.com/faisalman/ua-parser-js\r\n * \r\n * Copyright � 2012-2014 Faisal Salman <fyzlman@gmail.com>\r\n * Dual licensed under GPLv2 & MIT\r\n * \r\n **/\r\n/**\r\n * @license\r\n * A polyfill for UserTiming (http://www.w3.org/TR/user-timing/)\r\n * \r\n * Copyright 2013 Nic Jansma\r\n * http://nicj.net\r\n * \r\n * https://github.com/nicjansma/usertiming.js\r\n * \r\n * Licensed under the MIT license\r\n * \r\n **/\r\n/**\r\n * @license\r\n * MIT License\r\n * \r\n * Copyright © 2012 Sebastian Tschan, https://blueimp.net\r\n * \r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n * \r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n * \r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n * \r\n **/\r\n/**\r\n * @license\r\n * The MIT License (MIT)\r\n * \r\n * Copyright (c) 2015-2017 Fengyuan Chen\r\n * \r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n * \r\n * The above copyright notice and this permission notice shall be included in\r\n * all copies or substantial portions of the Software.\r\n * \r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n * THE SOFTWARE.\r\n **/\r\n/**\r\n * @license\r\n * (The MIT License)\r\n * \r\n * Copyright (C) 2014-2017 by Vitaly Puzrin\r\n * \r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n * \r\n * The above copyright notice and this permission notice shall be included in\r\n * all copies or substantial portions of the Software.\r\n * \r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n * THE SOFTWARE.\r\n **/\r\n","define('paychex.core/CUE',[\n    'paychex.core/InheritanceHelper',\n    'lodash'\n], function (PIH, _) {\n\n    /**\n     * @author Elliott Palermo\n     * @date 2014-07-15.\n     */\n\n    'use strict';\n\n    function _formatCorrelationID(correlationId) {\n        var result = _.attempt(function getCorrelationId() {\n            if (_.isEmpty(correlationId)) {\n                return 'none';\n            }\n            return correlationId.split('-').pop();\n        });\n\n        if (_.isError(result)) {\n            return 'none';\n        }\n        return result;\n    }\n\n    /**\n     * @constructor\n     * @description Constructs a new PaychexCriticalUnhandledException.\n     * @param {*=} message The message to display to the user. Can be an object of any type but PaychexMessage is\n     * recommended for the most compatibility with the standard error handlers.\n     * @param {*=} cause The cause of the Error. May be another Error or any other object.\n     * @param {String=} correlationId The unique correlationId for this error. Usually provided by the service tier.\n     * @param {String=} type The type of critical error. Usually provi\n     */\n    var CUE = function (message, cause, correlationId, type) {\n        // Don't call super with this message because we may be passing around non-string messages.\n        this.message = message;\n        this.cause = cause;\n        this.correlationId = correlationId;\n        this.formattedCorrelationId = _formatCorrelationID(correlationId);\n        this.stack = new Error().stack;\n        this.type = type !== undefined ? type : CUE.ERROR_TYPES.CRITICAL;\n    };\n\n    PIH.extend(CUE, Error);\n\n    /**\n     * The pre-defined error types.\n     *\n     * @type {{CRITICAL: string, APPLOAD: string}}\n     */\n    CUE.ERROR_TYPES = {\n        CRITICAL: 'CRITICAL_UNKNOWN',\n        APPLOAD: 'APPLICATION_LOAD'\n    };\n\n    CUE.formatCorrelationID = _formatCorrelationID;\n\n    return CUE;\n});\n\n","define('paychex.core/DeviceProfile',['lodash', 'paychex.core/lib/ua-parser.min'], function(_, UAParser) {\n\n    'use strict';\n\n    /**\n     * @class paychex.core.DeviceProfile\n     * @description Facade for server-side UAParser for device detection\n     * @deprecated Feature detection will replace this, slimming down functions.\n     */\n\n    /**\n     * @typedef {Object} UAParser\n     * @property {String} name\n     * @property {String} family\n     * @property {Array.<String>} versionNumber\n     */\n\n    /**\n     * @typedef {Object} UAParserVersionMap\n     * @property {String} full\n     * @property {String} major\n     * @property {String} minor\n     */\n\n    /**\n     * @typedef {Object} UAParserProfile\n     * @property {String} name\n     * @property {String} version\n     */\n\n    /**\n     * @typedef {Object} UAParserBrowserProfile\n     * @augments {UAParserProfile}\n     * @property {String} family\n     */\n\n    /**\n     * @typedef {Object} UAParserDeviceProfile\n     * @property {String} model\n     * @property {String} type\n     * @property {String} vendor\n     */\n\n    /**\n     * @typedef {Object} UAParserDeviceResult\n     * @property {String} ua\n     * @property {UAParserBrowserProfile} browser\n     * @property {UAParserDeviceProfile} device\n     * @property {UAParserProfile} engine\n     * @property {UAParserProfile} os\n     * @property {{architecture: string}} cpu\n     */\n\n    /**\n     * @typedef {('DESKTOP'|'TABLET'|'PHONE')} UAParserDeviceCategory\n     */\n\n    var constants = {\n            DESKTOP: 'desktop',\n            TABLET: 'tablet',\n            PHONE: 'phone'\n        },\n\n        deviceTypes = {\n            GAME_CONSOLE: constants.DESKTOP,\n            OTHER: constants.PHONE,\n            PDA: constants.PHONE,\n            PERSONAL_COMPUTER: constants.DESKTOP,\n            SMART_TV: constants.DESKTOP,\n            SMARTPHONE: constants.PHONE,\n            TABLET: constants.TABLET,\n            UNKNOWN: constants.PHONE,\n            WEARABLE_COMPUTER: constants.PHONE\n        },\n\n        devices = [\n            /* S5 */\n            [/(SM-G900\\w)/i], [UAParser.DEVICE.MODEL, [UAParser.DEVICE.VENDOR, 'Samsung'], [UAParser.DEVICE.TYPE, UAParser.DEVICE.MOBILE]]\n        ],\n\n        uaParser = new UAParser(null, {device: devices});\n\n    function getDeviceCategory() {\n        var uaDevice = _.isFunction(uaParser.getDevice) ?\n            (uaParser.getDevice().type || 'PERSONAL_COMPUTER').toUpperCase() :\n            uaParser.deviceCategory.category.toUpperCase();\n        //Override for ipadPro on cordova\n        //Also for wkwebview on cordova - device profile is DESKTOP, so use navigator.platform which fixes this\n        uaDevice = (navigator.platform === 'iPad') ? 'TABLET' : uaDevice;\n        uaDevice = (navigator.platform === 'iPhone') ? 'SMARTPHONE' : uaDevice;\n        return deviceTypes[uaDevice] || constants.PHONE;\n    }\n\n    function getBrowserProfile() {\n        var browser = _.attempt(function getOldVersion() {\n                return _.pick(uaParser.getBrowser(), ['name', 'version', 'major', 'family']);\n            }),\n            defaultVersion = _.isError(browser) ? [0, 0] : browser.version.split('.'),\n            versions = _.get(uaParser, 'versionNumber.groups', defaultVersion);\n        return _.merge(_.defaults(_.isError(browser) ? {} : browser, {\n            name: uaParser.name,\n            family: uaParser.family\n        }), {\n            version: {\n                full: versions.join('.'),\n                major: versions[0],\n                minor: versions[1]\n            }\n        });\n    }\n\n    function getOSName() {\n        return _.get(uaParser, 'operatingSystem.family', '');\n    }\n\n    return {\n\n        /**\n         * Contains the device types mapped by DeviceProfile.\n         * @member paychex.core.DeviceProfile#Categories\n         * @type {UAParserDeviceCategory}\n         * @example uaParser.getDeviceCategory() === uaParser.Categories.DESKTOP\n         */\n        Categories: constants,\n\n        /**\n         * @function paychex.core.DeviceProfile#getUAParser\n         * @returns {UAParser} the internal UAParser instance\n         * @description used primarily for unit testing\n         */\n        getUAParser: function getUAParser() {\n            return uaParser;\n        },\n\n        /**\n         * Returns the current device category (e.g. 'phone' or 'desktop' or 'tablet').\n         * @function paychex.core.DeviceProfile#getDeviceCategory\n         * @returns {String} The current device category.\n         * @example uaParser.getDeviceCategory() === uaParser.Categories.DESKTOP\n         */\n        getDeviceCategory: getDeviceCategory,\n\n        /**\n         * @function paychex.core.DeviceProfile#getBrowserProfile\n         * @returns {UAParserBrowserProfile} full object describing the profile of browser with version string in 'dot' form\n         * @example log.info(uaParser.getBrowserProfile().version.full)\n         */\n        getBrowserProfile: getBrowserProfile,\n\n        /**\n         * @function paychex.core.DeviceProfile#getDeviceResult\n         * @returns {UAParserDeviceResult} full object describing the results of device\n         * @example log.info(DeviceProfile.getDeviceResult().ua);\n         */\n        getDeviceResult: function () {\n            return uaParser.getResult();\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#getDeviceProfile\n         * @returns {UAParserDeviceProfile} full object describing the profile of device\n         * @example log.info(DeviceProfile.getDeviceProfile().vendor);\n         */\n        getDeviceProfile: function () {\n            return uaParser.getDevice();\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#getOSProfile\n         * @returns {UAParserProfile} full object describing the profile of os\n         * @example log.info(DeviceProfile.getOSProfile().name);\n         */\n        getOSProfile: function () {\n            return uaParser.getOS();\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#getEngineProfile\n         * @returns {UAParserProfile} full object describing the profile of browser engine\n         * @example log.info(DeviceProfile.getEngineProfile().name);\n         */\n        getEngineProfile: function () {\n            return uaParser.getEngine();\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#setUAParser\n         * @param {UAParser} uaParserObj object in the format UAParser expects.\n         * @description used primarily for unit testing\n         */\n        setUAParser: function setUAParser(uaParserObj) {\n            if (_.isObject(uaParserObj)) {\n                uaParser = uaParserObj;\n            }\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#setUserAgent\n         * @param {string} uaString string of the uaString to set.  This would be used for testing only.\n         */\n        setUserAgent: function (uaString) {\n            uaParser.setUA(uaString);\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#isMobile\n         * @returns {boolean} Is the page being served on a phone?\n         */\n        isMobile: function(){\n            return getDeviceCategory() === constants.PHONE;\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#isPhone\n         * @returns {boolean} Is the page being served on a phone\n         */\n        isPhone: function(){\n            return getDeviceCategory() === constants.PHONE;\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#isDesktop\n         * @returns {boolean} Is the page being served on a desktop?\n         */\n        isDesktop: function(){\n            return getDeviceCategory() === constants.DESKTOP;\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#isTablet\n         * @returns {boolean} Is the page being served on a tablet?\n         */\n        isTablet: function(){\n            return getDeviceCategory() === constants.TABLET;\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#isIPhone\n         * @returns {boolean} Is the page being served on is the page being served on an iPhone?\n         */\n        isIPhone: function(){\n            return  getDeviceCategory() === constants.PHONE && this.isAppleOS();\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#isAndroidOS\n         * @returns {boolean} Is the page being served on is the page being served on an Android OS?\n         */\n        isAndroidOS: function(){\n            return  getOSName() === 'ANDROID';\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#isAppleOS\n         * @returns {boolean} Is the page being served on is the page being served on an Apple OS?\n         */\n        isAppleOS: function(){\n            return  getOSName() === 'IOS';\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#isSafari\n         * @returns {boolean} Whether or not the browser is reporting as Safari\n         */\n        isSafari: function () {\n            var browserProfile = getBrowserProfile();\n            return !!(browserProfile.name && browserProfile.name.toLowerCase() === 'safari');\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#isFirefox\n         * @returns {boolean} Whether or not the browser is reporting as Firefox\n         */\n        isFirefox: function () {\n            var browserProfile = getBrowserProfile();\n            return !!(browserProfile.name && browserProfile.name.toLowerCase() === 'firefox');\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#isInternetExplorer\n         * @returns {boolean} Whether or not the browser exhibits IE specific behavior\n         */\n        isInternetExplorer: function () {\n            return /*@cc_on!@*/false || !!document.documentMode;\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#isEdge\n         * @returns {boolean} Whether or not the browser exhibits Edge specific behavior\n         */\n        isEdge: function () {\n            return !(/*@cc_on!@*/false || !!document.documentMode) && !!window.StyleMedia;\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#isNative\n         * @returns {boolean} Whether or not the page being served on a native app\n         */\n        isNative: function(){\n            return _.get(window, 'jspVars.isPhoneGap', false);\n        },\n\n        /**\n         * @function paychex.core.DeviceProfile#getXPlatformInfo\n         * @returns {String} returns x platform information\n         */\n        getXPlatformInfo: function () {\n            var platform = this.isNative() ? 'native' : 'web',\n                /* If it not ios and andorid, then defaulting it to other for now. we might need revisit on this if needed in the Future */\n                osname = (this.isAppleOS() || this.isAndroidOS()) ? getOSName() : 'other';\n            return platform + '-' + _.toLower(osname);\n        }\n    };\n\n});\n\n","define('paychex.core/Errors',[\n    'lodash',\n    './PaychexError',\n    'paychex.core/Logger',\n    'paychex.core/utils/Overloader'\n], function(\n    _,\n    PaychexError,\n    Logger,\n    Overloader\n) {\n\n    'use strict';\n\n    /**\n     * @author: dbarnes1\n     * Email: dbarnes1@paychex.com\n     * Date: 2015-05-18\n     */\n\n    var methods = new Overloader();\n\n    /**\n     * Provides a consistent way to throw errors in Paychex web applications.\n     * @class paychex.core.Errors\n     */\n    function Errors() {}\n\n    /**\n     * Creates a constructor on the window for use in later code.\n     * @param {String} className The Error class name to create on the window.\n     * @returns {undefined}\n     */\n    function createDynamicErrorClassIfNeeded(className) {\n        if (!window[className]) {\n            /**\n             * NOTE: there are only a few times when using eval should be permitted:\n             *  - dynamic functions (templating engines)\n             *  - dynamic typing (this particular use case)\n             */\n            /* jshint -W061 */\n            /* eslint no-eval: 0 */\n            eval(\n                'window[\"' + className + '\"] = function ' + className + '() {' +\n                '   var tmp = Error.apply(this, [].slice.call(arguments));' +\n                '   this.message = this.message || tmp.message;' +\n                '   this.name = tmp.name = \"' + className + '\";' +\n                '   Object.defineProperty(this, \"stack\", {' +\n                '       get: function getStack() { return tmp.stack; }' +\n                '   });' +\n                '   return this;' +\n                '}'\n            );\n            window[className].prototype = new PaychexError();\n            window[className].prototype.constructor = window[className];\n        }\n    }\n\n    /**\n     * Constructs a new Error instance matching the specified parameters.\n     * @param {Error} [inner] An optional inner exception to wrap.\n     * @param {String} [typename='PaychexError'] An optional Error type name. Defaults to PaychexError.\n     * @param {String} message The Error message to use.\n     * @param {Object} [props] Any additional properties to apply to the Error instance.\n     * @returns {Error} An Error instance matching the specified parameters.\n     */\n    function getErrorInstance(inner, typename, message, props) {\n        createDynamicErrorClassIfNeeded(typename);\n        /* eslint \"vars-on-top\": 0 */\n        var instance = new window[typename](message);\n        instance.causedBy = inner;\n        // if there is an inner exception with a severity, use that severity in this new error instance\n        instance.severity = inner && inner.severity ? inner.severity : PaychexError.Severity.ERROR;\n        _.merge(instance, props);\n        return instance;\n    }\n\n    /**\n     * Throws a new instance of PaychexError with the specified error message.\n     * @method paychex.core.Errors.throw\n     * @alias paychex.core.Errors.fatal\n     * @param {String} message\n     * @param {Object} [properties]\n     * @example\n     * Errors.throw('an error occurred');\n     * @example\n     * Errors.throw('an error occurred', {\n     *   source: 'my class',\n     *   datetime: Date.now()\n     * })\n     */\n    methods.overload('getError', 'string', function throwErrorFromMessage(message, props) {\n        return getErrorInstance(null, 'PaychexError', message, props);\n    });\n\n    /**\n     * Throws a new instance of the specified error type with no message.\n     * @method paychex.core.Errors.throw\n     * @alias paychex.core.Errors.fatal\n     * @param {String} The error type\n     * @param {undefined} The root cause (if undefined)\n     * @param {Object} [properties\n     * @example\n     * Errors.throw('CustomError', undefined);\n     * @example\n     * Errors.throw('CustomError', undefined, {\n     *   source: 'my class',\n     *   datetime: Date.now()\n     * })\n     */\n    methods.overload('getError', 'string', 'undefined', function throwErrorFromMessage(type, ignored, props) {\n        if( arguments.length === 1){\n            return getErrorInstance(null, 'PaychexError', type);\n        }\n        return getErrorInstance(null, type, 'No message provided to Errors API', props);\n    });\n\n    /**\n     * Throws a new instance of the specified Error class using the specified message.\n     * If the Error class does not exist, it will be created as a subclass of PaychexError.\n     * @method paychex.core.Errors.throw\n     * @param {String} typename\n     * @param {String} message\n     * @param {Object} [properties]\n     * @example\n     * Errors.throw('TypeError', 'a string was expected');\n     * @example\n     * Errors.throw('ArgumentTypeException', 'invalid type argument', {\n     *   expected: 'string',\n     *   received: typeof value\n     * })\n     */\n    methods.overload('getError', 'string', 'string', function throwErrorTypeFromMessage(typename, message, props) {\n        return getErrorInstance(null, typename, message, props);\n    });\n\n    /**\n     * Rethrows the specified error, optionally adding any extra properties to the instance.\n     * @method paychex.core.Errors.throw\n     * @param {Error} instance\n     * @param {Object} [properties]\n     * @example\n     * try {\n     *   doSomething();\n     * } catch (ex) {\n     *   Errors.throw(ex); // rethrow\n     * }\n     * @example\n     * try {\n     *   doSomething();\n     * } catch (ex) {\n     *   Errors.throw(ex, {\n     *     source: 'my class',\n     *     severity: 'FATAL'\n     *   })\n     * }\n     */\n    methods.overload('getError', 'Error', function rethrowError(instance, props) {\n        return _.merge(instance, {severity: instance.severity || 'ERROR'}, props); // just propagate\n    });\n\n    /**\n     * Rethrows the specified error by wrapping it in a new instance of PaychexError and\n     * using the given message for more information.\n     * @method paychex.core.Errors.throw\n     * @param {Error} inner\n     * @param {String} message\n     * @param {Object} [properties]\n     * @example\n     * try {\n     *   doSomething();\n     * } catch (ex) {\n     *   Errors.throw(ex, 'unexpected error');\n     * }\n     * @example\n     * try {\n     *   doSomething();\n     * } catch (ex) {\n     *   Errors.throw(ex, 'unexpected error', {\n     *     source: 'my class',\n     *     severity: 'FATAL'\n     *   })\n     * }\n     */\n    methods.overload('getError', 'Error', 'string', function throwInnerError(inner, message, props) {\n        return getErrorInstance(inner, 'PaychexError', message, props);\n    });\n\n    /**\n     * Rethrows the specified error by wrapping it in a new instance of the specified class name\n     * and using the given message for more information.\n     * @method paychex.core.Errors.throw\n     * @param {Error} inner\n     * @param {String} typename\n     * @param {String} message\n     * @param {Object} [properties]\n     * @example\n     * try {\n     *   doSomething();\n     * } catch (ex) {\n     *   Errors.throw(ex, 'InvocationException', 'unexpected error');\n     * }\n     * @example\n     * try {\n     *   doSomething();\n     * } catch (ex) {\n     *   Errors.throw(ex, 'InvocationException', 'unexpected error', {\n     *     source: 'my class',\n     *     severity: 'FATAL'\n     *   })\n     * }\n     */\n    methods.overload('getError', 'Error', 'string', 'string', function getInnerErrorOfType(inner, typename, message, props) {\n        return getErrorInstance(inner, typename, message, props);\n    });\n\n    /**\n     * Returns an Error instance matching the specified arguments. See\n     * the overloads for {@link paychex.core.Errors.throw throw} for the\n     * allowed argument types.\n     * @function paychex.core.Errors.get\n     * @returns {Error} An Error instance matching the specified arguments.\n     */\n    Errors.get = function getError() {\n        return methods.invoke('getError', arguments);\n    };\n\n    /* eslint no-restricted-syntax: [0] */\n\n    /**\n     * Throws a non-fatal Error instance matching the specified arguments. See\n     * the overloads for {@link paychex.core.Errors.throw throw} for the\n     * allowed argument types.\n     * @function paychex.core.Errors.throw\n     * @returns {undefined}\n     */\n    Errors.throw = function throwError() {\n        throw Errors.get.apply(null, _.toArray(arguments));\n    };\n\n    /**\n     * Throws a fatal Error instance matching the specified arguments. See\n     * the overloads for {@link paychex.core.Errors.throw throw} for the\n     * allowed argument types.\n     * @function paychex.core.Errors.fatal\n     * @alias paychex.core.Errors.throwFatal\n     */\n    Errors.fatal = Errors.throwFatal = function fatalError() {\n        var err = Errors.get.apply(null, _.toArray(arguments));\n        err.severity = PaychexError.Severity.FATAL;\n        throw err;\n    };\n\n    /**\n     * Throws a NONE-severity Error instance matching the specified arguments. See\n     * the overloads for {@link paychex.core.Errors.throw throw} for the\n     * allowed argument types.\n     * @function paychex.core.Errors.none\n     * @alias paychex.core.Errors.throwNone\n     */\n    Errors.none = Errors.throwNone = function nonErrorError() {\n        var err = Errors.get.apply(null, _.toArray(arguments));\n        err.severity = PaychexError.Severity.NONE;\n        throw err;\n    };\n\n    /**\n     * @function paychex.core.Errors.swallow\n     * @returns {Function} A function that swallows the error.\n     * @example\n     * somePromiseMethod()\n     *   .catch(Errors.swallow()) // do nothing\n     *   .done();\n     */\n    Errors.swallow = function swallow() {\n        return function swallowError(/* error */) {\n            return undefined;\n        };\n    };\n\n    /**\n     * @function paychex.core.Errors.logAndSwallow\n     * @param {String} [logName=paychex.core/Errors] The name of the logger to log the error to.\n     * @returns {Function} A function that logs the error using log4javascript.\n     * @example\n     * somePromiseMethod()\n     *   .catch(Errors.logAndSwallow()) // log to log4javascript, then swallow\n     *   .done();\n     */\n    Errors.logAndSwallow = function logAndSwallow(logName) {\n        return function logAndSwallowError(error) {\n            Logger.get(logName || 'paychex.core/Errors').error(error);\n        };\n    };\n\n    /**\n     * @function paychex.core.Errors.rethrow\n     * @alias paychex.core.Errors.rethrowAs\n     * @returns {Function} A function which will wrap the incoming error value in an Error\n     *  instance having the specified metadata.\n     * @example\n     * // throws:\n     * //   PaychexError - some non-Error rejection\n     * Promise.reject(Errors.get('some non-Error message'))\n     *   .catch(Errors.rethrow())\n     *   .done();\n     * @example\n     * // throws:\n     * //   TypeError - bad argument\n     * Promise.reject(new TypeError('bad argument'))\n     *   .catch(Errors.rethrow())\n     *   .done();\n     * @example\n     * // throws:\n     * //   PaychexError - somePromiseMethod failed\n     * //    └ caused by TypeError - bad argument\n     * Promise.reject(new TypeError('bad argument'))\n     *   .catch(Errors.rethrowAs('somePromiseMethod failed'))\n     *   .done();\n     * @example\n     * // throws:\n     * //   ServiceError - somePromiseMethod failed\n     * //    └ caused by PaychexError - some non-Error message\n     * Promise.reject(Errors.get('some non-Error message'))\n     *   .catch(Errors.rethrowAs('ServiceError', 'somePromiseMethod failed'))\n     *   .done();\n     * @example\n     * // throws:\n     * //   TypeError - bad argument - severity: NONE\n     * Promise.reject(new TypeError('bad argument'))\n     *   .catch(Errors.rethrowAs({severity: 'NONE'}))\n     *   .done();\n     */\n    Errors.rethrow = Errors.rethrowAs = function rethrow() {\n        var args = _.toArray(arguments);\n        return function rethrowError(error) {\n            var err = error;\n            if (!_.isError(err)) {\n                err = Errors.get(error); // PaychexError with 'error' value as message\n            }\n            args.unshift(err);\n            Errors.throw.apply(null, args);\n        };\n    };\n\n    /**\n     * Contains static names of common Error types for use throughout Paychex applications.\n     * @member paychex.core.Errors.Types\n     * @example\n     * Errors.throw(Errors.Types.IllegalArgument, 'An invalid argument was specified.');\n     */\n    Errors.Types = {\n        Data: 'DataError',\n        Http: 'HttpError',\n        IllegalArgument: 'IllegalArgumentError',\n        Invocation: 'InvocationError',\n        RemoteOperation: 'RemoteOperationError',\n        RestOperation: 'RestOperationError',\n        Timeout: 'TimeoutError',\n        Type: 'TypeError',\n        Validation: 'ValidationError',\n        UserCancellation: 'UserCancellationError'\n    };\n\n    return Errors;\n\n});\n\n","define('paychex.core/Eventing',[\n    'paychex.core/Utils',\n    'paychex.core/Errors',\n    'paychex.core/Promise',\n    'paychex.core/Workflows',\n    'paychex.core/Validator',\n    'paychex.core/Prototypes'\n],\nfunction(\n    _,\n    Errors,\n    Promise,\n    Workflows,\n    Validator\n) {\n\n    'use strict';\n\n    /**\n     * @author Dan Barnes\n     * @email dbarnes1@paychex.com\n     */\n\n    var brokers = {};\n\n    /**\n     * Provides 2-phased eventing to Paychex JavaScript projects.\n     * @class paychex.core.Broker\n     * @param {String} name The name of the broker to create.\n     * @example\n     * define(['paychex.core/Eventing'], function(EventBroker){\n     *     var eventing = EventBroker.makeNewEventBroker();\n     *     eventing.fire(...);\n     *     eventing.register(...);\n     * });\n     */\n    function Broker(name) {\n\n        var wfs = {},\n            MIN_TIMEOUT_VALUE = 1,\n            ErrorMessages = {\n                SUBSCRIBE:\n                    'Method `subscribe` requires a non-empty string' +\n                    ' and either 1 function or 3 functions as callbacks.',\n                ANNOUNCE:\n                    'Method `announce` requires non-empty strings for source and ' +\n                    'topic and an optional payload object and/or positive timeout.'\n            };\n\n        /**\n         * Returns the name of this event broker.\n         * @function paychex.core.Broker#getName\n         * @returns {String} The name associated with this event broker instance.\n         */\n        this.getName = function getName() {\n            return name;\n        };\n\n        /**\n         * Callback that handles approving or rejecting an event.\n         * @callback paychex.core.Broker~ProcessCallback\n         * @param {Object} event An object literal containing event data.\n         * @param {Function} reject A function to invoke to cancel the event.\n         * @param {Function} approve A function to invoke to approve the event.\n         */\n\n        /**\n         * Callback that handles the approved event.\n         * @callback paychex.core.Broker~CommitCallback\n         * @param {Object} event An object literal containing event data.\n         */\n\n        /**\n         * Callback that handles the rejected event.\n         * @callback paychex.core.Broker~FailureCallback\n         * @param {String} reason The reason the event failed.\n         */\n\n        /**\n         * Subscribes to the specified event name. Note that if only\n         * one callback is provided, it is assumed to be a commitCallback. In other\n         * words, the EventService will automatically approve the event and only\n         * fire your callback if all other handlers also approve the event. If any\n         * handler rejects the event, your callback will not be invoked.\n         * @function paychex.core.Broker#subscribe\n         * @alias paychex.core.Broker#register\n         * @param {String} topic The event name to associated the callbacks with.\n         * @param {paychex.core.Broker~ProcessCallback|paychex.core.Broker~CommitCallback} process\n         *  The function to execute when an event with the same name is announced. If this is the only callback\n         *  provided, it is assumed to be the commit callback.\n         * @param {paychex.core.Broker~CommitCallback} [commit] The function to execute if an event's\n         *  voteCallbacks have **all** voted to approve the event. The callback\n         *  should accept a single parameter: event, which is an object literal\n         *  containing event data.\n         * @param {paychex.core.Broker~FailureCallback} [rollback] The function to execute if **any**\n         *  of an event's voteCallbacks voted to reject the event. The callback\n         *  should accept a single parameter: reason, which is a string explaining\n         *  the reason the event was canceled (if a reason was given).\n         * @returns {paychex.core.Broker.registrationObject} An object the caller can use to\n         *  unregister from future event notifications.\n         * @example\n         * events.subscribe('com.paychex.png.landing.SubAppUnLoad',\n         *   function(event, reject, approve){\n         *     approve(); // or reject()\n         *   },\n         *   function(event){\n         *     // called if EVERYONE approves the event\n         *   },\n         *   function(reason){\n         *     // will be called if ANYONE rejects the event\n         *   });\n         * @example\n         * events.subscribe('com.paychex.png.landing.SubAppUnLoad',\n         *   function(event){\n         *     // assumed to be a commit callback\n         *     // will be called only if EVERYONE approves the event\n         *   });\n         * @example\n         * var token = events.subscribe('my-topic', function(){});\n         * if (token.topic === 'my-topic') {\n         *   token.unregister();\n         * }\n         */\n        this.register = this.subscribe = function register(topic, process, commit, rollback) {\n\n            if (!Validator.isTypeMatch(\n                [topic, process, commit, rollback],\n                ['nonEmptyString', 'function', 'function?', 'function?']\n            )) {\n                Errors.throw(Errors.Types.IllegalArgument, ErrorMessages.SUBSCRIBE);\n            }\n\n            /* eslint \"vars-on-top\": 0 */\n            var wfName = _.sluggify('css', name, topic),\n                wf = wfs[wfName],\n                step = _.uniqueId(topic);\n\n            if (!wf) {\n                wf = wfs[wfName] = Workflows.create(wfName);\n            }\n\n            wf.addStep(step, function addStep() {\n\n                return {\n\n                    execute: function dispatch(e) {\n                        this.dispatchArgs = e;\n                        if (!!commit) {\n                            return new Promise(function ProcessPromise(resolve, reject) {\n                                process(e, reject, resolve);\n                            });\n                        }\n                    },\n\n                    success: function wfSucceeded() {\n                        (commit || process)(this.dispatchArgs);\n                    },\n\n                    failure: rollback\n\n                };\n\n            });\n\n            /**\n             * @typedef {Object} paychex.core.Broker.registrationObject\n             * @property {String} topic The event topic used to register your handlers.\n             * @property {Function} unregister A method to invoke to un-register your handlers.\n             * @description\n             * Registration object that can be invoked to unsubscribe\n             *  your handlers from the specified event.\n             */\n            return {\n                topic: topic,\n                unregister: function removeSubscriber() {\n                    wf.removeStep(step);\n                }\n            };\n\n        };\n\n        /**\n         * Executes any callbacks subscribed for the given eventName,\n         * passing an event object containing the source, topic, and payload to the\n         * callback methods. If any voteCallback rejects the event, the promise\n         * returned from this function will be rejected.\n         * @function paychex.core.Broker#announce\n         * @alias paychex.core.Broker#fire\n         * @param {String} source An identifier for the object announcing this event.\n         * @param {String} topic The event name whose registered callbacks should be executed.\n         * @param {*} [payload] Optional data to pass to any registered callbacks. If not\n         *  provided, defaults to the empty object {}.\n         * @param {Number} [timeout] An optional number of milliseconds to wait before\n         *  automatically rejecting the event.\n         * @returns {Promise} An Angular promise that can be resolved or rejected.\n         * @example\n         * // no payload or timeout, adding commit and rollback to the returned promise\n         * events\n         *   .announce('MySubApp', 'com.paychex.png.landing.SubAppLoaded')\n         *   .then(function(){\n         *      logger.trace('SubAppLoaded committed');\n         *    }, function(reason){\n         *      logger.trace('SubAppLoaded rolled back because %s', reason);\n         *    });\n         * @example\n         * // specifying a payload and timeout:\n         * events.announce('MySource', 'my-event-topic', {my: 'payload'}, 2000);\n         */\n        this.fire = this.announce = function fire(source, topic, payload, timeout) {\n\n            if (\n                !Validator.isTypeMatch(\n                    [source, topic, payload, timeout],\n                    ['nonEmptyString', 'nonEmptyString', 'any?', 'number?']\n                ) || (timeout !== undefined && !Validator.isNumber(timeout, MIN_TIMEOUT_VALUE))\n            ) {\n                Errors.throw(Errors.Types.IllegalArgument, ErrorMessages.ANNOUNCE);\n            }\n\n            var wf = wfs[_.sluggify('css', name, topic)],\n                e = {\n                    topic: topic,\n                    source: source,\n                    payload: payload\n                };\n\n            return !!wf ? wf.dispatch([e], timeout).then(_.constant(e)) : Promise.resolve(e);\n\n        };\n\n    }\n\n    /**\n     * Factory to create new {@link paychex.core.Broker event broker} instances.\n     * @class paychex.core.Eventing\n     */\n    return {\n\n        /**\n         * @function paychex.core.Eventing#isBroker\n         * @param {paychex.core.Broker} broker The object to verify is a Broker instance.\n         * @returns {boolean} `true` if the specified object is a {@link\n         * paychex.core.Broker Broker} instance; `false` otherwise.\n         */\n        isBroker: function isBroker(broker) {\n            return broker instanceof Broker;\n        },\n\n        /**\n         * @function paychex.core.Eventing#makeNewEventBroker\n         * @param {String} [name] The name to associate with the new\n         *  event broker. If an event broker already exists with\n         *  the specified name, it will be returned.\n         * @returns {paychex.core.Broker} An event broker instance.\n         */\n        makeNewEventBroker: function makeNewEventBroker(name) {\n            var brokerName = _.sluggify('css', String(name || 'default-broker'));\n            if (!brokers[brokerName]) {\n                brokers[brokerName] = new Broker(brokerName);\n            }\n            return brokers[brokerName];\n        }\n\n    };\n\n});\n\n","define('paychex.core/FileOpener',['paychex.core/WindowOpener',\n    'paychex.core/Errors',\n    'lodash'\n], function (WindowOpener, Errors, _) {\n    'use strict';\n\n    // returning window opener api for file opener as\n    // window.open will get different implementation depending on Native and Web\n    // For native - cordova plugin will get called\n    return {open: function _openFile() {\n        // This is to ensure customized third param doesn't go through\n        var MAGIC_ARG_POS = 2,\n            args = arguments.length <= MAGIC_ARG_POS ? arguments : ( _.includes(arguments[MAGIC_ARG_POS], '=') ? arguments : Array.prototype.slice.call(arguments, 0, MAGIC_ARG_POS));\n        return WindowOpener.open.apply(this, args).then(function throwIfFailed(result) {\n            if (!result || !result.winRef) {\n                Errors.throw('FileOpener', 'failed to open window', {severity: 'NONE'});\n            }\n            return undefined; // according to unit tests, we should explicitly return undefined when the call succeeds...\n        }).catch(function rethrow(err) {\n            Errors.throw(err, 'FileOpener', 'failed to open window', {severity: 'NONE'});\n        });\n    }};\n});\n\n","define('paychex.core/InheritanceHelper',[], function () {\n\n    /**\n     * @author Elliott Palermo\n     * @date 2014-07-22\n     */\n\n    'use strict';\n\n    /**\n     * @class paychex.core.InheritanceHelper\n     * @description Provides methods to enable one JavaScript \"class\" to inherit from another.\n     */\n    var PaychexInheritanceHelper = {};\n\n    /**\n     * @function paychex.core.InheritanceHelper#inherit\n     * @private\n     * @description Sets the base instance of your JavaScript class.\n     * @param {Object} proto The prototype object to inherit from.\n     * @returns {PaychexInheritanceHelper.F} Returns a new object who's prototype is the object specified.\n     */\n    PaychexInheritanceHelper.inherit = function inherit(proto) {\n        function F() {}\n        F.prototype = proto;\n        return new F();\n    };\n\n    /**\n     * @function paychex.core.InheritanceHelper#extend\n     * @description Extends the child class with methods from the parent class.\n     * @param {Object} Child instance to extend\n     * @param {Object} Parent instance whose members should be added to the child instance.\n     */\n    PaychexInheritanceHelper.extend = function extend(Child, Parent) {\n        Child.prototype = PaychexInheritanceHelper.inherit(Parent.prototype);\n        Child.prototype.constructor = Child;\n        Child.parent = Parent.prototype;\n    };\n\n    /**\n     * @function paychex.core.InheritanceHelper#superConstructor\n     * @param {Object} that An object that was previously extended using the {@link\n     * paychex.core.InheritanceHelper#extend extend} method.\n     * @param {*} [args] Optional arguments to pass to the parent constructor.\n     */\n    PaychexInheritanceHelper.superConstructor = function superConstructor( that, args ) {\n        that.parent.constructor.apply( that, args);\n    };\n\n    return PaychexInheritanceHelper;\n\n});\n\n","!function(t){\"use strict\";var e=t.HTMLCanvasElement&&t.HTMLCanvasElement.prototype,o=t.Blob&&function(){try{return Boolean(new Blob)}catch(t){return!1}}(),n=o&&t.Uint8Array&&function(){try{return 100===new Blob([new Uint8Array(100)]).size}catch(t){return!1}}(),r=t.BlobBuilder||t.WebKitBlobBuilder||t.MozBlobBuilder||t.MSBlobBuilder,a=/^data:((.*?)(;charset=.*?)?)(;base64)?,/,i=(o||r)&&t.atob&&t.ArrayBuffer&&t.Uint8Array&&function(t){var e,i,l,u,c,f,b,d,B;if(!(e=t.match(a)))throw new Error(\"invalid data URI\");for(i=e[2]?e[1]:\"text/plain\"+(e[3]||\";charset=US-ASCII\"),l=!!e[4],u=t.slice(e[0].length),c=l?atob(u):decodeURIComponent(u),f=new ArrayBuffer(c.length),b=new Uint8Array(f),d=0;d<c.length;d+=1)b[d]=c.charCodeAt(d);return o?new Blob([n?b:f],{type:i}):((B=new r).append(f),B.getBlob(i))};t.HTMLCanvasElement&&!e.toBlob&&(e.mozGetAsFile?e.toBlob=function(t,o,n){var r=this;setTimeout(function(){t(n&&e.toDataURL&&i?i(r.toDataURL(o,n)):r.mozGetAsFile(\"blob\",o))})}:e.toDataURL&&i&&(e.toBlob=function(t,e,o){var n=this;setTimeout(function(){t(i(n.toDataURL(e,o)))})})),\"function\"==typeof define&&define.amd?define('paychex.core/lib/canvas-to-blob',[],function(){return i}):\"object\"==typeof module&&module.exports?module.exports=i:t.dataURLtoBlob=i}(window);\n//# sourceMappingURL=canvas-to-blob.min.js.map;\n","define('paychex.core/lib/dag',[\n    'paychex.core/lib/queue',\n    'paychex.core/lib/tsort'\n], function(\n    Queue,\n    tsort\n){\n\n    'use strict';\n\n    /*!\n     * Helpers\n     */\n\n    var noop = function () {};\n\n    /**\n     * ### dag (edges, concurrency, iterator[, done])\n     *\n     * DAG, directed-acyclic-graph, is a graph of nodes in\n     * which there are no cyclic references, and therefor has\n     * a specific starting and ending point. The `dag` async\n     * method will take an array of edges and resolve a best\n     * fit path of execution. It will then iterate over each\n     * edge in parallel up to a set amount of threads (concurrency).\n     * Furthermore, an edge will not begin it's processing until\n     * all of its dependencies have indicated successful execution.\n     *\n     * A set of edges is defined as an array, with each element being\n     * an array of x, y pairs, where `x` must complete before `y`\n     * can begin.\n     *\n     * ```js\n     * var edges = [\n     *     [ 'a', 'b' ]\n     *   , [ 'a', 'c' ]\n     *   , [ 'd', 'e' ]\n     *   , [ 'b', 'd' ]\n     * ];\n     * ```\n     *\n     * With the above edges, we expect `a` to start processing. Upon\n     * completion, `b` and `c` will start. Upon `b` completion, `d`\n     * will execute, then `e`.\n     *\n     * ```js\n     * var dag = require('breeze-dag');\n     *\n     * dag(edges, 2, function (e, next) {\n *   setTimeout(function () {\n *     next(); // or next(err);\n *   }, 1000);\n * }, function (err) {\n *   // our done callback\n *   should.not.exist(err);\n * });\n     * ```\n     *\n     * If there are cyclical references in the set of edges, the `done`\n     * callback will be immediately called with an error indicating\n     * the problem.\n     *\n     * If an error occurs the `done` callback will\n     * be executed immediately. No more items will begin processing,\n     * but items that have already started will run to completion.\n     *\n     * @param {Array} edges\n     * @param {Number} concurrency\n     * @param {Function} iterator\n     * @param {Function} callback\n     * @name dag\n     * @api public\n     */\n\n    return function (edges, concurrency, iterator, cb) {\n        cb = cb || noop;\n        var sorted = tsort(edges)\n        if (sorted.error) return cb(sorted.error);\n        if (!sorted.path.length) return cb(null);\n\n        // helper: get edge with id\n        function selectEdge(id) {\n            return graph.filter(function (e) {\n                return e.id === id;\n            })[0];\n        }\n\n        // queue iterator\n        function action (e, next) {\n            iterator(e, function done (err) {\n                var edge = selectEdge(e);\n                edge.children.forEach(function (n) {\n                    var notify = selectEdge(n);\n                    notify.fulfilled.push(e);\n                    var wl = notify.parents.length\n                        , fl = notify.fulfilled.length;\n                    if (wl === fl) queue.push(n, null, true);\n                });\n                next(err);\n            });\n        }\n\n        // determine where to start\n        function bootstrap (e) {\n            e.fulfilled = [];\n            if (!e.parents.length) queue.push(e.id);\n        }\n\n        // begin\n        var graph = sorted.graph\n            , queue = Queue(action, concurrency);\n        graph.forEach(bootstrap);\n        queue.onerror = cb;\n        queue.drain = cb;\n        queue.process();\n\n    };\n\n});\n","define('paychex.core/lib/nextTick',[], function(){\n\n    'use strict';\n\n    return !!window.requestAnimationFrame ?\n        window.requestAnimationFrame : window.setTimeout;\n\n});\n","/* pica 3.0.4 nodeca/pica */(function(f){if(typeof exports===\"object\"&&typeof module!==\"undefined\"){module.exports=f()}else if(typeof define===\"function\"&&define.amd){define('paychex.core/lib/pica',[],f)}else{var g;if(typeof window!==\"undefined\"){g=window}else if(typeof global!==\"undefined\"){g=global}else if(typeof self!==\"undefined\"){g=self}else{g=this}g.pica = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){// Collection of math functions\n//\n// 1. Combine components together\n// 2. Has async init to load wasm modules\n//\n    'use strict';\n\n    var base64decode = require('./utils').base64decode;\n    var math_wasm_base64 = require('./mathlib/wasm/math_wasm_base64');\n\n    function MathLib(requested_features, preload) {\n        this.__requested_features = requested_features || [];\n        this.__initPromise = null;\n        this.__wasm_module = preload && preload.wasm_module ? preload : null;\n\n        // List of supported features, according to options & browser/node.js\n        this.features = {\n            js: false, // pure JS implementation, can be disabled for testing\n            wasm: false // webassembly implementation for heavy functions\n        };\n    }\n\n    MathLib.prototype.init = function init() {\n        var _this = this;\n\n        this.__initPromise = Promise.resolve().then(function () {\n            // Map supported implementations\n            _this.unsharp = _this.unsharp_js; // That's in JS only for a while\n\n            if (_this.__requested_features.indexOf('js') >= 0) {\n                _this.features.js = true;\n                _this.resize = _this.resize_js;\n            }\n\n            if (typeof WebAssembly !== 'undefined' && _this.__requested_features.indexOf('wasm') >= 0) {\n\n                if (_this.__wasm_module) {\n                    _this.features.wasm = true;\n                    _this.resize = _this.resize_wasm;\n                    return null;\n                }\n\n                return WebAssembly.compile(base64decode(math_wasm_base64)).then(function (wasm_module) {\n                    _this.__wasm_module = wasm_module;\n                    _this.features.wasm = true;\n                    _this.resize = _this.resize_wasm;\n                })\n                // Suppress init errors\n                    .catch(function () {});\n            }\n\n            return null;\n        }).then(function () {\n            if (!_this.features.wasm && !_this.features.js) {\n                throw new Error('Pica mathlib: no supported methods found');\n            }\n\n            return _this;\n        });\n\n        return this.__initPromise;\n    };\n\n    MathLib.prototype.resizeAndUnsharp = function resizeAndUnsharp(options, cache) {\n        var result = this.resize(options, cache);\n\n        if (options.unsharpAmount) {\n            this.unsharp(result, options.toWidth, options.toHeight, options.unsharpAmount, options.unsharpRadius, options.unsharpThreshold);\n        }\n\n        return result;\n    };\n\n// Pin implementations\n    MathLib.prototype.unsharp_js = require('./mathlib/unsharp_js');\n    MathLib.prototype.resize_js = require('./mathlib/resize_js');\n\n////////////////////////////////////////////////////////////////////////////////\n// WebAssembly wrappers & helpers\n//\n\n    var createFilters = require('./mathlib/resize_filter_gen');\n\n    function resetAlpha(dst, width, height) {\n        var ptr = 3,\n            len = width * height * 4 | 0;\n        while (ptr < len) {\n            dst[ptr] = 0xFF;ptr = ptr + 4 | 0;\n        }\n    }\n\n    function asUint8Array(src) {\n        return new Uint8Array(src.buffer, 0, src.byteLength);\n    }\n\n    var IS_LE = true;\n// should not crash everything on module load in old browsers\n    try {\n        IS_LE = new Uint32Array(new Uint8Array([1, 0, 0, 0]).buffer)[0] === 1;\n    } catch (__) {}\n\n    function copyInt16asLE(src, target, target_offset) {\n        if (IS_LE) {\n            target.set(asUint8Array(src), target_offset);\n            return;\n        }\n\n        for (var ptr = target_offset, i = 0; i < src.length; i++) {\n            var data = src[i];\n            target[ptr++] = data & 0xFF;\n            target[ptr++] = data >> 8 & 0xFF;\n        }\n    }\n\n    MathLib.prototype.resize_wasm = function resize_wasm(options, cache) {\n        var src = options.src;\n        var srcW = options.width;\n        var srcH = options.height;\n        var destW = options.toWidth;\n        var destH = options.toHeight;\n        var scaleX = options.scaleX || options.toWidth / options.width;\n        var scaleY = options.scaleY || options.toHeight / options.height;\n        var offsetX = options.offsetX || 0.0;\n        var offsetY = options.offsetY || 0.0;\n        var dest = options.dest || new Uint8Array(destW * destH * 4);\n        var quality = typeof options.quality === 'undefined' ? 3 : options.quality;\n        var alpha = options.alpha || false;\n\n        if (!cache) cache = {};\n\n        var fx_key = 'filter_' + quality + '|' + srcW + '|' + destW + '|' + scaleX + '|' + offsetX;\n        var fy_key = 'filter_' + quality + '|' + srcH + '|' + destH + '|' + scaleY + '|' + offsetY;\n\n        var filtersX = cache[fx_key] || createFilters(quality, srcW, destW, scaleX, offsetX),\n            filtersY = cache[fy_key] || createFilters(quality, srcH, destH, scaleY, offsetY);\n\n        //if (!cache[fx_key]) cache[fx_key] = filtersX;\n        //if (!cache[fy_key]) cache[fy_key] = filtersY;\n\n        var alloc_bytes = Math.max(src.byteLength, dest.byteLength) + filtersX.byteLength + filtersY.byteLength + srcH * destW * 4; // Buffer between convolve passes\n\n        var alloc_pages = Math.ceil(alloc_bytes / (64 * 1024));\n\n        var wasm_imports = cache.wasm_imports || {\n                env: {\n                    memory: new WebAssembly.Memory({ initial: alloc_pages })\n                    // emsdk requires more import vars\n                    /*memoryBase: 0,\n                     tableBase:  0,\n                     memory: new WebAssembly.Memory({\n                     // Compiled wasm has 256 min memory value limit.\n                     // Atempt to provide less memory size will cause linking error\n                     initial: Math.max(256, alloc_pages)\n                     }),\n                     table: new WebAssembly.Table({\n                     initial:100,\n                     element: 'anyfunc'\n                     })*/\n                }\n            };\n\n        // Increase memory size if needed\n        var memory = wasm_imports.env.memory,\n            mem_pages = memory.buffer.byteLength / (64 * 1024);\n\n        if (alloc_pages > mem_pages) {\n            // increase to delta + 1MB\n            memory.grow(alloc_pages - mem_pages + 16);\n        }\n\n        var wasm_instance = cache.wasm_instance || new WebAssembly.Instance(this.__wasm_module, wasm_imports);\n\n        if (!cache.wasm_imports) cache.wasm_imports = wasm_imports;\n        if (!cache.wasm_instance) cache.wasm_instance = wasm_instance;\n\n        //\n        // Fill memory block with data to process\n        //\n\n        var mem = new Uint8Array(wasm_imports.env.memory.buffer);\n        var mem32 = new Uint32Array(wasm_imports.env.memory.buffer);\n\n        // mem.set(src)\n        // 32-bit copy is much faster in chrome\n        var src32 = new Uint32Array(src.buffer);\n        mem32.set(src32);\n\n        // Place tmp buffer after src to have 4x byte align.\n        // That doesn't seems to make sence but costs nothing.\n        var tmp_offset = Math.max(src.byteLength, dest.byteLength);\n\n        var filtersX_offset = tmp_offset + srcH * destW * 4;\n        var filtersY_offset = filtersX_offset + filtersX.byteLength;\n\n        // We should guarantee LE bytes order. Filters are not big, so\n        // speed difference is not significant vs direct .set()\n        copyInt16asLE(filtersX, mem, filtersX_offset);\n        copyInt16asLE(filtersY, mem, filtersY_offset);\n\n        //\n        // Now call webassembly method\n        //\n\n        wasm_instance.exports.convolveHV(\n            // emsdk does method names with '_'\n            //wasm_instance.exports._convolveHV(\n            filtersX_offset, filtersY_offset, tmp_offset, srcW, srcH, destW, destH);\n\n        //\n        // Copy data back to typed array\n        //\n\n        // 32-bit copy is much faster in chrome\n        var dest32 = new Uint32Array(dest.buffer);\n        dest32.set(mem32.subarray(0, dest32.length));\n\n        // That's faster than doing checks in convolver.\n        // !!! Note, canvas data is not premultipled. We don't need other\n        // alpha corrections.\n\n        if (!alpha) resetAlpha(dest, destW, destH);\n\n        return dest;\n    };\n\n    module.exports = MathLib;\n\n},{\"./mathlib/resize_filter_gen\":4,\"./mathlib/resize_js\":6,\"./mathlib/unsharp_js\":7,\"./mathlib/wasm/math_wasm_base64\":8,\"./utils\":11}],2:[function(require,module,exports){\n// Calculates 16-bit precision lightness from 8-bit rgba buffer\n//\n    'use strict';\n\n    module.exports = function lightness16_js(img, width, height) {\n        var size = width * height;\n        var out = new Uint16Array(size);\n        var r, g, b, min, max;\n        for (var i = 0; i < size; i++) {\n            r = img[4 * i];\n            g = img[4 * i + 1];\n            b = img[4 * i + 2];\n            max = r >= g && r >= b ? r : g >= b && g >= r ? g : b;\n            min = r <= g && r <= b ? r : g <= b && g <= r ? g : b;\n            out[i] = (max + min) * 257 >> 1;\n        }\n        return out;\n    };\n\n},{}],3:[function(require,module,exports){\n// Resize convolvers, pure JS implementation\n//\n    'use strict';\n\n// Precision of fixed FP values\n//var FIXED_FRAC_BITS = 14;\n\n\n    function clampTo8(i) {\n        return i < 0 ? 0 : i > 255 ? 255 : i;\n    }\n\n// Convolve image in horizontal directions and transpose output. In theory,\n// transpose allow:\n//\n// - use the same convolver for both passes (this fails due different\n//   types of input array and temporary buffer)\n// - making vertical pass by horisonltal lines inprove CPU cache use.\n//\n// But in real life this doesn't work :)\n//\n    function convolveHorizontally(src, dest, srcW, srcH, destW, filters) {\n\n        var r, g, b, a;\n        var filterPtr, filterShift, filterSize;\n        var srcPtr, srcY, destX, filterVal;\n        var srcOffset = 0,\n            destOffset = 0;\n\n        // For each row\n        for (srcY = 0; srcY < srcH; srcY++) {\n            filterPtr = 0;\n\n            // Apply precomputed filters to each destination row point\n            for (destX = 0; destX < destW; destX++) {\n                // Get the filter that determines the current output pixel.\n                filterShift = filters[filterPtr++];\n                filterSize = filters[filterPtr++];\n\n                srcPtr = srcOffset + filterShift * 4 | 0;\n\n                r = g = b = a = 0;\n\n                // Apply the filter to the row to get the destination pixel r, g, b, a\n                for (; filterSize > 0; filterSize--) {\n                    filterVal = filters[filterPtr++];\n\n                    // Use reverse order to workaround deopts in old v8 (node v.10)\n                    // Big thanks to @mraleph (Vyacheslav Egorov) for the tip.\n                    a = a + filterVal * src[srcPtr + 3] | 0;\n                    b = b + filterVal * src[srcPtr + 2] | 0;\n                    g = g + filterVal * src[srcPtr + 1] | 0;\n                    r = r + filterVal * src[srcPtr] | 0;\n                    srcPtr = srcPtr + 4 | 0;\n                }\n\n                // Bring this value back in range. All of the filter scaling factors\n                // are in fixed point with FIXED_FRAC_BITS bits of fractional part.\n                //\n                // (!) Add 1/2 of value before clamping to get proper rounding. In other\n                // case brightness loss will be noticeable if you resize image with white\n                // border and place it on white background.\n                //\n                dest[destOffset + 3] = clampTo8(a + (1 << 13) >> 14 /*FIXED_FRAC_BITS*/);\n                dest[destOffset + 2] = clampTo8(b + (1 << 13) >> 14 /*FIXED_FRAC_BITS*/);\n                dest[destOffset + 1] = clampTo8(g + (1 << 13) >> 14 /*FIXED_FRAC_BITS*/);\n                dest[destOffset] = clampTo8(r + (1 << 13) >> 14 /*FIXED_FRAC_BITS*/);\n                destOffset = destOffset + srcH * 4 | 0;\n            }\n\n            destOffset = (srcY + 1) * 4 | 0;\n            srcOffset = (srcY + 1) * srcW * 4 | 0;\n        }\n    }\n\n// Technically, convolvers are the same. But input array and temporary\n// buffer can be of different type (especially, in old browsers). So,\n// keep code in separate functions to avoid deoptimizations & speed loss.\n\n    function convolveVertically(src, dest, srcW, srcH, destW, filters) {\n\n        var r, g, b, a;\n        var filterPtr, filterShift, filterSize;\n        var srcPtr, srcY, destX, filterVal;\n        var srcOffset = 0,\n            destOffset = 0;\n\n        // For each row\n        for (srcY = 0; srcY < srcH; srcY++) {\n            filterPtr = 0;\n\n            // Apply precomputed filters to each destination row point\n            for (destX = 0; destX < destW; destX++) {\n                // Get the filter that determines the current output pixel.\n                filterShift = filters[filterPtr++];\n                filterSize = filters[filterPtr++];\n\n                srcPtr = srcOffset + filterShift * 4 | 0;\n\n                r = g = b = a = 0;\n\n                // Apply the filter to the row to get the destination pixel r, g, b, a\n                for (; filterSize > 0; filterSize--) {\n                    filterVal = filters[filterPtr++];\n\n                    // Use reverse order to workaround deopts in old v8 (node v.10)\n                    // Big thanks to @mraleph (Vyacheslav Egorov) for the tip.\n                    a = a + filterVal * src[srcPtr + 3] | 0;\n                    b = b + filterVal * src[srcPtr + 2] | 0;\n                    g = g + filterVal * src[srcPtr + 1] | 0;\n                    r = r + filterVal * src[srcPtr] | 0;\n                    srcPtr = srcPtr + 4 | 0;\n                }\n\n                // Bring this value back in range. All of the filter scaling factors\n                // are in fixed point with FIXED_FRAC_BITS bits of fractional part.\n                //\n                // (!) Add 1/2 of value before clamping to get proper rounding. In other\n                // case brightness loss will be noticeable if you resize image with white\n                // border and place it on white background.\n                //\n                dest[destOffset + 3] = clampTo8(a + (1 << 13) >> 14 /*FIXED_FRAC_BITS*/);\n                dest[destOffset + 2] = clampTo8(b + (1 << 13) >> 14 /*FIXED_FRAC_BITS*/);\n                dest[destOffset + 1] = clampTo8(g + (1 << 13) >> 14 /*FIXED_FRAC_BITS*/);\n                dest[destOffset] = clampTo8(r + (1 << 13) >> 14 /*FIXED_FRAC_BITS*/);\n                destOffset = destOffset + srcH * 4 | 0;\n            }\n\n            destOffset = (srcY + 1) * 4 | 0;\n            srcOffset = (srcY + 1) * srcW * 4 | 0;\n        }\n    }\n\n    module.exports = {\n        convolveHorizontally: convolveHorizontally,\n        convolveVertically: convolveVertically\n    };\n\n},{}],4:[function(require,module,exports){\n// Calculate convolution filters for each destination point,\n// and pack data to Int16Array:\n//\n// [ shift, length, data..., shift2, length2, data..., ... ]\n//\n// - shift - offset in src image\n// - length - filter length (in src points)\n// - data - filter values sequence\n//\n    'use strict';\n\n    var FILTER_INFO = require('./resize_filter_info');\n\n// Precision of fixed FP values\n    var FIXED_FRAC_BITS = 14;\n\n    function toFixedPoint(num) {\n        return Math.round(num * ((1 << FIXED_FRAC_BITS) - 1));\n    }\n\n    module.exports = function resizeFilterGen(quality, srcSize, destSize, scale, offset) {\n\n        var filterFunction = FILTER_INFO[quality].filter;\n\n        var scaleInverted = 1.0 / scale;\n        var scaleClamped = Math.min(1.0, scale); // For upscale\n\n        // Filter window (averaging interval), scaled to src image\n        var srcWindow = FILTER_INFO[quality].win / scaleClamped;\n\n        var destPixel, srcPixel, srcFirst, srcLast, filterElementSize, floatFilter, fxpFilter, total, pxl, idx, floatVal, filterTotal, filterVal;\n        var leftNotEmpty, rightNotEmpty, filterShift, filterSize;\n\n        var maxFilterElementSize = Math.floor((srcWindow + 1) * 2);\n        var packedFilter = new Int16Array((maxFilterElementSize + 2) * destSize);\n        var packedFilterPtr = 0;\n\n        var slowCopy = !packedFilter.subarray || !packedFilter.set;\n\n        // For each destination pixel calculate source range and built filter values\n        for (destPixel = 0; destPixel < destSize; destPixel++) {\n\n            // Scaling should be done relative to central pixel point\n            srcPixel = (destPixel + 0.5) * scaleInverted + offset;\n\n            srcFirst = Math.max(0, Math.floor(srcPixel - srcWindow));\n            srcLast = Math.min(srcSize - 1, Math.ceil(srcPixel + srcWindow));\n\n            filterElementSize = srcLast - srcFirst + 1;\n            floatFilter = new Float32Array(filterElementSize);\n            fxpFilter = new Int16Array(filterElementSize);\n\n            total = 0.0;\n\n            // Fill filter values for calculated range\n            for (pxl = srcFirst, idx = 0; pxl <= srcLast; pxl++, idx++) {\n                floatVal = filterFunction((pxl + 0.5 - srcPixel) * scaleClamped);\n                total += floatVal;\n                floatFilter[idx] = floatVal;\n            }\n\n            // Normalize filter, convert to fixed point and accumulate conversion error\n            filterTotal = 0;\n\n            for (idx = 0; idx < floatFilter.length; idx++) {\n                filterVal = floatFilter[idx] / total;\n                filterTotal += filterVal;\n                fxpFilter[idx] = toFixedPoint(filterVal);\n            }\n\n            // Compensate normalization error, to minimize brightness drift\n            fxpFilter[destSize >> 1] += toFixedPoint(1.0 - filterTotal);\n\n            //\n            // Now pack filter to useable form\n            //\n            // 1. Trim heading and tailing zero values, and compensate shitf/length\n            // 2. Put all to single array in this format:\n            //\n            //    [ pos shift, data length, value1, value2, value3, ... ]\n            //\n\n            leftNotEmpty = 0;\n            while (leftNotEmpty < fxpFilter.length && fxpFilter[leftNotEmpty] === 0) {\n                leftNotEmpty++;\n            }\n\n            if (leftNotEmpty < fxpFilter.length) {\n                rightNotEmpty = fxpFilter.length - 1;\n                while (rightNotEmpty > 0 && fxpFilter[rightNotEmpty] === 0) {\n                    rightNotEmpty--;\n                }\n\n                filterShift = srcFirst + leftNotEmpty;\n                filterSize = rightNotEmpty - leftNotEmpty + 1;\n\n                packedFilter[packedFilterPtr++] = filterShift; // shift\n                packedFilter[packedFilterPtr++] = filterSize; // size\n\n                if (!slowCopy) {\n                    packedFilter.set(fxpFilter.subarray(leftNotEmpty, rightNotEmpty + 1), packedFilterPtr);\n                    packedFilterPtr += filterSize;\n                } else {\n                    // fallback for old IE < 11, without subarray/set methods\n                    for (idx = leftNotEmpty; idx <= rightNotEmpty; idx++) {\n                        packedFilter[packedFilterPtr++] = fxpFilter[idx];\n                    }\n                }\n            } else {\n                // zero data, write header only\n                packedFilter[packedFilterPtr++] = 0; // shift\n                packedFilter[packedFilterPtr++] = 0; // size\n            }\n        }\n        return packedFilter;\n    };\n\n},{\"./resize_filter_info\":5}],5:[function(require,module,exports){\n// Filter definitions to build tables for\n// resizing convolvers.\n//\n// Presets for quality 0..3. Filter functions + window size\n//\n    'use strict';\n\n    module.exports = [{ // Nearest neibor (Box)\n        win: 0.5,\n        filter: function filter(x) {\n            return x >= -0.5 && x < 0.5 ? 1.0 : 0.0;\n        }\n    }, { // Hamming\n        win: 1.0,\n        filter: function filter(x) {\n            if (x <= -1.0 || x >= 1.0) {\n                return 0.0;\n            }\n            if (x > -1.19209290E-07 && x < 1.19209290E-07) {\n                return 1.0;\n            }\n            var xpi = x * Math.PI;\n            return Math.sin(xpi) / xpi * (0.54 + 0.46 * Math.cos(xpi / 1.0));\n        }\n    }, { // Lanczos, win = 2\n        win: 2.0,\n        filter: function filter(x) {\n            if (x <= -2.0 || x >= 2.0) {\n                return 0.0;\n            }\n            if (x > -1.19209290E-07 && x < 1.19209290E-07) {\n                return 1.0;\n            }\n            var xpi = x * Math.PI;\n            return Math.sin(xpi) / xpi * Math.sin(xpi / 2.0) / (xpi / 2.0);\n        }\n    }, { // Lanczos, win = 3\n        win: 3.0,\n        filter: function filter(x) {\n            if (x <= -3.0 || x >= 3.0) {\n                return 0.0;\n            }\n            if (x > -1.19209290E-07 && x < 1.19209290E-07) {\n                return 1.0;\n            }\n            var xpi = x * Math.PI;\n            return Math.sin(xpi) / xpi * Math.sin(xpi / 3.0) / (xpi / 3.0);\n        }\n    }];\n\n},{}],6:[function(require,module,exports){\n    'use strict';\n\n    var createFilters = require('./resize_filter_gen');\n    var convolveHorizontally = require('./resize_convolve_js').convolveHorizontally;\n    var convolveVertically = require('./resize_convolve_js').convolveVertically;\n\n    function resetAlpha(dst, width, height) {\n        var ptr = 3,\n            len = width * height * 4 | 0;\n        while (ptr < len) {\n            dst[ptr] = 0xFF;ptr = ptr + 4 | 0;\n        }\n    }\n\n    function resize(options, cache) {\n        var src = options.src;\n        var srcW = options.width;\n        var srcH = options.height;\n        var destW = options.toWidth;\n        var destH = options.toHeight;\n        var scaleX = options.scaleX || options.toWidth / options.width;\n        var scaleY = options.scaleY || options.toHeight / options.height;\n        var offsetX = options.offsetX || 0;\n        var offsetY = options.offsetY || 0;\n        var dest = options.dest || new Uint8Array(destW * destH * 4);\n        var quality = typeof options.quality === 'undefined' ? 3 : options.quality;\n        var alpha = options.alpha || false;\n\n        if (srcW < 1 || srcH < 1 || destW < 1 || destH < 1) {\n            return [];\n        }\n\n        if (!cache) cache = {};\n\n        var fx_key = 'filter_' + quality + '|' + srcW + '|' + destW + '|' + scaleX + '|' + offsetX;\n        var fy_key = 'filter_' + quality + '|' + srcH + '|' + destH + '|' + scaleY + '|' + offsetY;\n\n        var filtersX = cache[fx_key] || createFilters(quality, srcW, destW, scaleX, offsetX),\n            filtersY = cache[fy_key] || createFilters(quality, srcH, destH, scaleY, offsetY);\n\n        //if (!cache[fx_key]) cache[fx_key] = filtersX;\n        //if (!cache[fy_key]) cache[fy_key] = filtersY;\n\n        var tmp = new Uint8Array(destW * srcH * 4);\n\n        // To use single function we need src & tmp of the same type.\n        // But src can be CanvasPixelArray, and tmp - Uint8Array. So, keep\n        // vertical and horizontal passes separately to avoid deoptimization.\n\n        convolveHorizontally(src, tmp, srcW, srcH, destW, filtersX);\n        convolveVertically(tmp, dest, srcH, destW, destH, filtersY);\n\n        // That's faster than doing checks in convolver.\n        // !!! Note, canvas data is not premultipled. We don't need other\n        // alpha corrections.\n\n        if (!alpha) resetAlpha(dest, destW, destH);\n\n        return dest;\n    }\n\n    module.exports = resize;\n\n},{\"./resize_convolve_js\":3,\"./resize_filter_gen\":4}],7:[function(require,module,exports){\n// Unsharp mask filter\n//\n// http://stackoverflow.com/a/23322820/1031804\n// USM(O) = O + (2 * (Amount / 100) * (O - GB))\n// GB - gaussian blur.\n//\n// Image is converted from RGB to HSL, unsharp mask is applied to the\n// lightness channel and then image is converted back to RGB.\n//\n    'use strict';\n\n    var glurMono16 = require('glur/mono16');\n    var getLightness = require('./lightness16_js');\n\n    module.exports = function unsharp(img, width, height, amount, radius, threshold) {\n        var r, g, b;\n        var h, s, l;\n        var min, max;\n        var m1, m2, hShifted;\n        var diff, iTimes4;\n\n        if (amount === 0 || radius < 0.5) {\n            return;\n        }\n        if (radius > 2.0) {\n            radius = 2.0;\n        }\n\n        var lightness = getLightness(img, width, height);\n\n        var blured = new Uint16Array(lightness); // copy, because blur modify src\n\n        glurMono16(blured, width, height, radius);\n\n        var amountFp = amount / 100 * 0x1000 + 0.5 | 0;\n        var thresholdFp = threshold * 257 | 0;\n\n        var size = width * height;\n\n        for (var i = 0; i < size; i++) {\n            diff = 2 * (lightness[i] - blured[i]);\n\n            if (Math.abs(diff) >= thresholdFp) {\n                iTimes4 = i * 4;\n                r = img[iTimes4];\n                g = img[iTimes4 + 1];\n                b = img[iTimes4 + 2];\n\n                // convert RGB to HSL\n                // take RGB, 8-bit unsigned integer per each channel\n                // save HSL, H and L are 16-bit unsigned integers, S is 12-bit unsigned integer\n                // math is taken from here: http://www.easyrgb.com/index.php?X=MATH&H=18\n                // and adopted to be integer (fixed point in fact) for sake of performance\n                max = r >= g && r >= b ? r : g >= r && g >= b ? g : b; // min and max are in [0..0xff]\n                min = r <= g && r <= b ? r : g <= r && g <= b ? g : b;\n                l = (max + min) * 257 >> 1; // l is in [0..0xffff] that is caused by multiplication by 257\n\n                if (min === max) {\n                    h = s = 0;\n                } else {\n                    s = l <= 0x7fff ? (max - min) * 0xfff / (max + min) | 0 : (max - min) * 0xfff / (2 * 0xff - max - min) | 0; // s is in [0..0xfff]\n                    // h could be less 0, it will be fixed in backward conversion to RGB, |h| <= 0xffff / 6\n                    h = r === max ? (g - b) * 0xffff / (6 * (max - min)) | 0 : g === max ? 0x5555 + ((b - r) * 0xffff / (6 * (max - min)) | 0) // 0x5555 == 0xffff / 3\n                        : 0xaaaa + ((r - g) * 0xffff / (6 * (max - min)) | 0); // 0xaaaa == 0xffff * 2 / 3\n                }\n\n                // add unsharp mask mask to the lightness channel\n                l += amountFp * diff + 0x800 >> 12;\n                if (l > 0xffff) {\n                    l = 0xffff;\n                } else if (l < 0) {\n                    l = 0;\n                }\n\n                // convert HSL back to RGB\n                // for information about math look above\n                if (s === 0) {\n                    r = g = b = l >> 8;\n                } else {\n                    m2 = l <= 0x7fff ? l * (0x1000 + s) + 0x800 >> 12 : l + ((0xffff - l) * s + 0x800 >> 12);\n                    m1 = 2 * l - m2 >> 8;\n                    m2 >>= 8;\n                    // save result to RGB channels\n                    // R channel\n                    hShifted = h + 0x5555 & 0xffff; // 0x5555 == 0xffff / 3\n                    r = hShifted >= 0xaaaa ? m1 // 0xaaaa == 0xffff * 2 / 3\n                        : hShifted >= 0x7fff ? m1 + ((m2 - m1) * 6 * (0xaaaa - hShifted) + 0x8000 >> 16) : hShifted >= 0x2aaa ? m2 // 0x2aaa == 0xffff / 6\n                            : m1 + ((m2 - m1) * 6 * hShifted + 0x8000 >> 16);\n                    // G channel\n                    hShifted = h & 0xffff;\n                    g = hShifted >= 0xaaaa ? m1 // 0xaaaa == 0xffff * 2 / 3\n                        : hShifted >= 0x7fff ? m1 + ((m2 - m1) * 6 * (0xaaaa - hShifted) + 0x8000 >> 16) : hShifted >= 0x2aaa ? m2 // 0x2aaa == 0xffff / 6\n                            : m1 + ((m2 - m1) * 6 * hShifted + 0x8000 >> 16);\n                    // B channel\n                    hShifted = h - 0x5555 & 0xffff;\n                    b = hShifted >= 0xaaaa ? m1 // 0xaaaa == 0xffff * 2 / 3\n                        : hShifted >= 0x7fff ? m1 + ((m2 - m1) * 6 * (0xaaaa - hShifted) + 0x8000 >> 16) : hShifted >= 0x2aaa ? m2 // 0x2aaa == 0xffff / 6\n                            : m1 + ((m2 - m1) * 6 * hShifted + 0x8000 >> 16);\n                }\n\n                img[iTimes4] = r;\n                img[iTimes4 + 1] = g;\n                img[iTimes4 + 2] = b;\n            }\n        }\n    };\n\n},{\"./lightness16_js\":2,\"glur/mono16\":13}],8:[function(require,module,exports){\n// This is autogenerated file from math.wasm, don't edit.\n//\n    'use strict';\n\n    /* eslint-disable max-len */\n\n    module.exports = 'AGFzbQEAAAABlICAgAACYAZ/f39/f38AYAd/f39/f39/AAKPgICAAAEDZW52Bm1lbW9yeQIAAQODgICAAAIAAQSEgICAAAFwAAAHmYCAgAACCGNvbnZvbHZlAAAKY29udm9sdmVIVgABCYGAgIAAAArtg4CAAALBg4CAAAEQfwJAIANFDQAgBEUNACAFQQRqIRVBACEMQQAhDQNAIA0hDkEAIRFBACEHA0AgB0ECaiESAn8gBSAHQQF0IgdqIgZBAmouAQAiEwRAQQAhCEEAIBNrIRQgFSAHaiEPIAAgDCAGLgEAakECdGohEEEAIQlBACEKQQAhCwNAIBAoAgAiB0EYdiAPLgEAIgZsIAtqIQsgB0H/AXEgBmwgCGohCCAHQRB2Qf8BcSAGbCAKaiEKIAdBCHZB/wFxIAZsIAlqIQkgD0ECaiEPIBBBBGohECAUQQFqIhQNAAsgEiATagwBC0EAIQtBACEKQQAhCUEAIQggEgshByABIA5BAnRqIApBgMAAakEOdSIGQf8BIAZB/wFIG0EQdEGAgPwHcUEAIAZBAEobIAtBgMAAakEOdSIGQf8BIAZB/wFIG0EYdEEAIAZBAEobciAJQYDAAGpBDnUiBkH/ASAGQf8BSBtBCHRBgP4DcUEAIAZBAEobciAIQYDAAGpBDnUiBkH/ASAGQf8BSBtB/wFxQQAgBkEAShtyNgIAIA4gA2ohDiARQQFqIhEgBEcNAAsgDCACaiEMIA1BAWoiDSADRw0ACwsLoYCAgAAAAkBBACACIAMgBCAFIAAQACACQQAgBCAFIAYgARAACws=';\n\n},{}],9:[function(require,module,exports){\n    'use strict';\n\n    var GC_INTERVAL = 100;\n\n    function Pool(create, idle) {\n        this.create = create;\n\n        this.available = [];\n        this.acquired = {};\n        this.lastId = 1;\n\n        this.timeoutId = 0;\n        this.idle = idle || 2000;\n    }\n\n    Pool.prototype.acquire = function () {\n        var _this = this;\n\n        var resource = void 0;\n\n        if (this.available.length !== 0) {\n            resource = this.available.pop();\n        } else {\n            resource = this.create();\n            resource.id = this.lastId++;\n            resource.release = function () {\n                return _this.release(resource);\n            };\n        }\n        this.acquired[resource.id] = resource;\n        return resource;\n    };\n\n    Pool.prototype.release = function (resource) {\n        var _this2 = this;\n\n        delete this.acquired[resource.id];\n\n        resource.lastUsed = Date.now();\n        this.available.push(resource);\n\n        if (this.timeoutId === 0) {\n            this.timeoutId = setTimeout(function () {\n                return _this2.gc();\n            }, GC_INTERVAL);\n        }\n    };\n\n    Pool.prototype.gc = function () {\n        var _this3 = this;\n\n        var now = Date.now();\n\n        this.available = this.available.filter(function (resource) {\n            if (now - resource.lastUsed > _this3.idle) {\n                resource.destroy();\n                return false;\n            }\n            return true;\n        });\n\n        if (this.available.length !== 0) {\n            this.timeoutId = setTimeout(function () {\n                return _this3.gc();\n            }, GC_INTERVAL);\n        } else {\n            this.timeoutId = 0;\n        }\n    };\n\n    module.exports = Pool;\n\n},{}],10:[function(require,module,exports){\n    'use strict';\n\n    /*\n     * pixelFloor and pixelCeil are modified versions of Math.floor and Math.ceil\n     * functions which take into account floating point arithmetic errors.\n     * Those errors can cause undesired increments/decrements of sizes and offsets:\n     * Math.ceil(36 / (36 / 500)) = 501\n     * pixelCeil(36 / (36 / 500)) = 500\n     */\n\n    var PIXEL_EPSILON = 1e-5;\n\n    function pixelFloor(x) {\n        var nearest = Math.round(x);\n\n        if (Math.abs(x - nearest) < PIXEL_EPSILON) {\n            return nearest;\n        }\n        return Math.floor(x);\n    }\n\n    function pixelCeil(x) {\n        var nearest = Math.round(x);\n\n        if (Math.abs(x - nearest) < PIXEL_EPSILON) {\n            return nearest;\n        }\n        return Math.ceil(x);\n    }\n\n    module.exports = function createRegions(options) {\n        var scaleX = options.toWidth / options.width;\n        var scaleY = options.toHeight / options.height;\n\n        var innerTileWidth = pixelFloor(options.srcTileSize * scaleX) - 2 * options.destTileBorder;\n        var innerTileHeight = pixelFloor(options.srcTileSize * scaleY) - 2 * options.destTileBorder;\n\n        var x, y;\n        var innerX, innerY, toTileWidth, toTileHeight;\n        var tiles = [];\n        var tile;\n\n        // we go top-to-down instead of left-to-right to make image displayed from top to\n        // doesn in the browser\n        for (innerY = 0; innerY < options.toHeight; innerY += innerTileHeight) {\n            for (innerX = 0; innerX < options.toWidth; innerX += innerTileWidth) {\n                x = innerX - options.destTileBorder;\n                if (x < 0) {\n                    x = 0;\n                }\n                toTileWidth = innerX + innerTileWidth + options.destTileBorder - x;\n                if (x + toTileWidth >= options.toWidth) {\n                    toTileWidth = options.toWidth - x;\n                }\n\n                y = innerY - options.destTileBorder;\n                if (y < 0) {\n                    y = 0;\n                }\n                toTileHeight = innerY + innerTileHeight + options.destTileBorder - y;\n                if (y + toTileHeight >= options.toHeight) {\n                    toTileHeight = options.toHeight - y;\n                }\n\n                tile = {\n                    toX: x,\n                    toY: y,\n                    toWidth: toTileWidth,\n                    toHeight: toTileHeight,\n\n                    toInnerX: innerX,\n                    toInnerY: innerY,\n                    toInnerWidth: innerTileWidth,\n                    toInnerHeight: innerTileHeight,\n\n                    offsetX: x / scaleX - pixelFloor(x / scaleX),\n                    offsetY: y / scaleY - pixelFloor(y / scaleY),\n                    scaleX: scaleX,\n                    scaleY: scaleY,\n\n                    x: pixelFloor(x / scaleX),\n                    y: pixelFloor(y / scaleY),\n                    width: pixelCeil(toTileWidth / scaleX),\n                    height: pixelCeil(toTileHeight / scaleY)\n                };\n\n                tiles.push(tile);\n            }\n        }\n\n        return tiles;\n    };\n\n},{}],11:[function(require,module,exports){\n    'use strict';\n\n    function objClass(obj) {\n        return Object.prototype.toString.call(obj);\n    }\n\n    module.exports.isCanvas = function isCanvas(element) {\n        //return (element.nodeName && element.nodeName.toLowerCase() === 'canvas') ||\n        var cname = objClass(element);\n\n        return cname === '[object HTMLCanvasElement]' /* browser */ || cname === '[object Canvas]' /* node-canvas */;\n    };\n\n    module.exports.isImage = function isImage(element) {\n        //return element.nodeName && element.nodeName.toLowerCase() === 'img';\n        return objClass(element) === '[object HTMLImageElement]';\n    };\n\n    module.exports.limiter = function limiter(concurrency) {\n        var active = 0,\n            queue = [];\n\n        function roll() {\n            if (active < concurrency && queue.length) {\n                active++;\n                queue.shift()();\n            }\n        }\n\n        return function limit(fn) {\n            return new Promise(function (resolve, reject) {\n                queue.push(function () {\n                    fn().then(function (result) {\n                        resolve(result);\n                        active--;\n                        roll();\n                    }, function (err) {\n                        reject(err);\n                        active--;\n                        roll();\n                    });\n                });\n\n                roll();\n            });\n        };\n    };\n\n    module.exports.cib_quality_name = function cib_quality_name(num) {\n        switch (num) {\n            case 0:\n                return 'pixelated';\n            case 1:\n                return 'low';\n            case 2:\n                return 'medium';\n        }\n        return 'high';\n    };\n\n    module.exports.cib_support = function cib_support() {\n        return Promise.resolve().then(function () {\n            if (typeof createImageBitmap === 'undefined' || typeof document === 'undefined') {\n                return false;\n            }\n\n            var c = document.createElement('canvas');\n            c.width = 100;\n            c.height = 100;\n\n            return createImageBitmap(c, 0, 0, 100, 100, {\n                resizeWidth: 10,\n                resizeHeight: 10,\n                resizeQuality: 'high'\n            }).then(function (bitmap) {\n                var status = bitmap.width === 10;\n                bitmap.close();\n                c = null;\n                return status;\n            });\n        }).catch(function () {\n            return false;\n        });\n    };\n\n// [ 64, 65, 66 ] -> [ padding, CR, LF ]\n    var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\\n\\r';\n\n    module.exports.base64decode = function base64decode(str) {\n        var input = str.replace(/[\\r\\n=]/g, ''),\n            // remove CR/LF & padding to simplify scan\n            max = input.length;\n        var result = [];\n\n        // Collect by 6*4 bits (3 bytes)\n\n        var bits = 0;\n\n        for (var idx = 0; idx < max; idx++) {\n            if (idx % 4 === 0 && idx) {\n                result.push(bits >> 16 & 0xFF);\n                result.push(bits >> 8 & 0xFF);\n                result.push(bits & 0xFF);\n            }\n\n            bits = bits << 6 | BASE64_MAP.indexOf(input.charAt(idx));\n        }\n\n        // Dump tail\n\n        var tailbits = max % 4 * 6;\n\n        if (tailbits === 0) {\n            result.push(bits >> 16 & 0xFF);\n            result.push(bits >> 8 & 0xFF);\n            result.push(bits & 0xFF);\n        } else if (tailbits === 18) {\n            result.push(bits >> 10 & 0xFF);\n            result.push(bits >> 2 & 0xFF);\n        } else if (tailbits === 12) {\n            result.push(bits >> 4 & 0xFF);\n        }\n\n        return new Uint8Array(result);\n    };\n\n},{}],12:[function(require,module,exports){\n// Web Worker wrapper for image resize function\n\n    'use strict';\n\n    module.exports = function () {\n        var MathLib = require('./mathlib');\n\n        var mathLib = void 0;\n        var cache = {};\n\n        /* eslint-disable no-undef */\n        onmessage = function onmessage(ev) {\n            var opts = ev.data.opts;\n\n            if (!mathLib) mathLib = new MathLib(ev.data.features, ev.data.preload);\n\n            mathLib.init().then(function () {\n                var result = mathLib.resizeAndUnsharp(opts, cache);\n                postMessage({ result: result }, [result.buffer]);\n            }).catch(function (err) {\n                postMessage({ err: err });\n            });\n        };\n    };\n\n},{\"./mathlib\":1}],13:[function(require,module,exports){\n// Calculate Gaussian blur of an image using IIR filter\n// The method is taken from Intel's white paper and code example attached to it:\n// https://software.intel.com/en-us/articles/iir-gaussian-blur-filter\n// -implementation-using-intel-advanced-vector-extensions\n\n    var a0, a1, a2, a3, b1, b2, left_corner, right_corner;\n\n    function gaussCoef(sigma) {\n        if (sigma < 0.5) {\n            sigma = 0.5;\n        }\n\n        var a = Math.exp(0.726 * 0.726) / sigma,\n            g1 = Math.exp(-a),\n            g2 = Math.exp(-2 * a),\n            k = (1 - g1) * (1 - g1) / (1 + 2 * a * g1 - g2);\n\n        a0 = k;\n        a1 = k * (a - 1) * g1;\n        a2 = k * (a + 1) * g1;\n        a3 = -k * g2;\n        b1 = 2 * g1;\n        b2 = -g2;\n        left_corner = (a0 + a1) / (1 - b1 - b2);\n        right_corner = (a2 + a3) / (1 - b1 - b2);\n\n        // Attempt to force type to FP32.\n        return new Float32Array([ a0, a1, a2, a3, b1, b2, left_corner, right_corner ]);\n    }\n\n    function convolveMono16(src, out, line, coeff, width, height) {\n        // takes src image and writes the blurred and transposed result into out\n\n        var prev_src, curr_src, curr_out, prev_out, prev_prev_out;\n        var src_index, out_index, line_index;\n        var i, j;\n        var coeff_a0, coeff_a1, coeff_b1, coeff_b2;\n\n        for (i = 0; i < height; i++) {\n            src_index = i * width;\n            out_index = i;\n            line_index = 0;\n\n            // left to right\n            prev_src = src[src_index];\n            prev_prev_out = prev_src * coeff[6];\n            prev_out = prev_prev_out;\n\n            coeff_a0 = coeff[0];\n            coeff_a1 = coeff[1];\n            coeff_b1 = coeff[4];\n            coeff_b2 = coeff[5];\n\n            for (j = 0; j < width; j++) {\n                curr_src = src[src_index];\n\n                curr_out = curr_src * coeff_a0 +\n                    prev_src * coeff_a1 +\n                    prev_out * coeff_b1 +\n                    prev_prev_out * coeff_b2;\n\n                prev_prev_out = prev_out;\n                prev_out = curr_out;\n                prev_src = curr_src;\n\n                line[line_index] = prev_out;\n                line_index++;\n                src_index++;\n            }\n\n            src_index--;\n            line_index--;\n            out_index += height * (width - 1);\n\n            // right to left\n            prev_src = src[src_index];\n            prev_prev_out = prev_src * coeff[7];\n            prev_out = prev_prev_out;\n            curr_src = prev_src;\n\n            coeff_a0 = coeff[2];\n            coeff_a1 = coeff[3];\n\n            for (j = width - 1; j >= 0; j--) {\n                curr_out = curr_src * coeff_a0 +\n                    prev_src * coeff_a1 +\n                    prev_out * coeff_b1 +\n                    prev_prev_out * coeff_b2;\n\n                prev_prev_out = prev_out;\n                prev_out = curr_out;\n\n                prev_src = curr_src;\n                curr_src = src[src_index];\n\n                out[out_index] = line[line_index] + prev_out;\n\n                src_index--;\n                line_index--;\n                out_index -= height;\n            }\n        }\n    }\n\n\n    function blurMono16(src, width, height, radius) {\n        // Quick exit on zero radius\n        if (!radius) { return; }\n\n        var out      = new Uint16Array(src.length),\n            tmp_line = new Float32Array(Math.max(width, height));\n\n        var coeff = gaussCoef(radius);\n\n        convolveMono16(src, out, tmp_line, coeff, width, height, radius);\n        convolveMono16(out, src, tmp_line, coeff, height, width, radius);\n    }\n\n    module.exports = blurMono16;\n\n},{}],14:[function(require,module,exports){\n    /*\n     object-assign\n     (c) Sindre Sorhus\n     @license MIT\n     */\n\n    'use strict';\n    /* eslint-disable no-unused-vars */\n    var getOwnPropertySymbols = Object.getOwnPropertySymbols;\n    var hasOwnProperty = Object.prototype.hasOwnProperty;\n    var propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\n    function toObject(val) {\n        if (val === null || val === undefined) {\n            throw new TypeError('Object.assign cannot be called with null or undefined');\n        }\n\n        return Object(val);\n    }\n\n    function shouldUseNative() {\n        try {\n            if (!Object.assign) {\n                return false;\n            }\n\n            // Detect buggy property enumeration order in older V8 versions.\n\n            // https://bugs.chromium.org/p/v8/issues/detail?id=4118\n            var test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n            test1[5] = 'de';\n            if (Object.getOwnPropertyNames(test1)[0] === '5') {\n                return false;\n            }\n\n            // https://bugs.chromium.org/p/v8/issues/detail?id=3056\n            var test2 = {};\n            for (var i = 0; i < 10; i++) {\n                test2['_' + String.fromCharCode(i)] = i;\n            }\n            var order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n                return test2[n];\n            });\n            if (order2.join('') !== '0123456789') {\n                return false;\n            }\n\n            // https://bugs.chromium.org/p/v8/issues/detail?id=3056\n            var test3 = {};\n            'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n                test3[letter] = letter;\n            });\n            if (Object.keys(Object.assign({}, test3)).join('') !==\n                'abcdefghijklmnopqrst') {\n                return false;\n            }\n\n            return true;\n        } catch (err) {\n            // We don't expect any of the above to throw, but better to be safe.\n            return false;\n        }\n    }\n\n    module.exports = shouldUseNative() ? Object.assign : function (target, source) {\n        var from;\n        var to = toObject(target);\n        var symbols;\n\n        for (var s = 1; s < arguments.length; s++) {\n            from = Object(arguments[s]);\n\n            for (var key in from) {\n                if (hasOwnProperty.call(from, key)) {\n                    to[key] = from[key];\n                }\n            }\n\n            if (getOwnPropertySymbols) {\n                symbols = getOwnPropertySymbols(from);\n                for (var i = 0; i < symbols.length; i++) {\n                    if (propIsEnumerable.call(from, symbols[i])) {\n                        to[symbols[i]] = from[symbols[i]];\n                    }\n                }\n            }\n        }\n\n        return to;\n    };\n\n},{}],15:[function(require,module,exports){\n    var bundleFn = arguments[3];\n    var sources = arguments[4];\n    var cache = arguments[5];\n\n    var stringify = JSON.stringify;\n\n    module.exports = function (fn, options) {\n        var wkey;\n        var cacheKeys = Object.keys(cache);\n\n        for (var i = 0, l = cacheKeys.length; i < l; i++) {\n            var key = cacheKeys[i];\n            var exp = cache[key].exports;\n            // Using babel as a transpiler to use esmodule, the export will always\n            // be an object with the default export as a property of it. To ensure\n            // the existing api and babel esmodule exports are both supported we\n            // check for both\n            if (exp === fn || exp && exp.default === fn) {\n                wkey = key;\n                break;\n            }\n        }\n\n        if (!wkey) {\n            wkey = Math.floor(Math.pow(16, 8) * Math.random()).toString(16);\n            var wcache = {};\n            for (var i = 0, l = cacheKeys.length; i < l; i++) {\n                var key = cacheKeys[i];\n                wcache[key] = key;\n            }\n            sources[wkey] = [\n                Function(['require','module','exports'], '(' + fn + ')(self)'),\n                wcache\n            ];\n        }\n        var skey = Math.floor(Math.pow(16, 8) * Math.random()).toString(16);\n\n        var scache = {}; scache[wkey] = wkey;\n        sources[skey] = [\n            Function(['require'], (\n                // try to call default if defined to also support babel esmodule\n                // exports\n                'var f = require(' + stringify(wkey) + ');' +\n                '(f.default ? f.default : f)(self);'\n            )),\n            scache\n        ];\n\n        var workerSources = {};\n        resolveSources(skey);\n\n        function resolveSources(key) {\n            workerSources[key] = true;\n\n            for (var depPath in sources[key][1]) {\n                var depKey = sources[key][1][depPath];\n                if (!workerSources[depKey]) {\n                    resolveSources(depKey);\n                }\n            }\n        }\n\n        var src = '(' + bundleFn + ')({'\n            + Object.keys(workerSources).map(function (key) {\n                return stringify(key) + ':['\n                    + sources[key][0]\n                    + ',' + stringify(sources[key][1]) + ']'\n                    ;\n            }).join(',')\n            + '},{},[' + stringify(skey) + '])'\n        ;\n\n        var URL = window.URL || window.webkitURL || window.mozURL || window.msURL;\n\n        var blob = new Blob([src], { type: 'text/javascript' });\n        if (options && options.bare) { return blob; }\n        var workerUrl = URL.createObjectURL(blob);\n        var worker = new Worker(workerUrl);\n        worker.objectURL = workerUrl;\n        return worker;\n    };\n\n},{}],\"/\":[function(require,module,exports){\n    'use strict';\n\n    var assign = require('object-assign');\n    var webworkify = require('webworkify');\n\n    var MathLib = require('./lib/mathlib');\n    var Pool = require('./lib/pool');\n    var utils = require('./lib/utils');\n    var worker = require('./lib/worker');\n    var createRegions = require('./lib/tiler');\n\n// Deduplicate pools & limiters with the same configs\n// when user creates multiple pica instances.\n    var singletones = {};\n\n    var NEED_SAFARI_FIX = false;\n    try {\n        if (typeof navigator !== 'undefined' && navigator.userAgent) {\n            NEED_SAFARI_FIX = navigator.userAgent.indexOf('Safari') >= 0;\n        }\n    } catch (e) {}\n\n    var concurrency = 1;\n    if (typeof navigator !== 'undefined') {\n        concurrency = Math.min(navigator.hardwareConcurrency || 1, 4);\n    }\n\n    var DEFAULT_PICA_OPTS = {\n        tile: 1024,\n        concurrency: concurrency,\n        features: ['js', 'wasm', 'ww'],\n        idle: 2000\n    };\n\n    var DEFAULT_RESIZE_OPTS = {\n        quality: 3,\n        alpha: false,\n        unsharpAmount: 0,\n        unsharpRadius: 0.0,\n        unsharpThreshold: 0\n    };\n\n    var CAN_NEW_IMAGE_DATA = void 0;\n\n    function workerFabric() {\n        return {\n            value: webworkify(worker),\n            destroy: function destroy() {\n                this.value.terminate();\n\n                if (typeof window !== 'undefined') {\n                    var url = window.URL || window.webkitURL || window.mozURL || window.msURL;\n                    if (url && url.revokeObjectURL && this.value.objectURL) {\n                        url.revokeObjectURL(this.value.objectURL);\n                    }\n                }\n            }\n        };\n    }\n\n////////////////////////////////////////////////////////////////////////////////\n// API methods\n\n    function Pica(options) {\n        if (!(this instanceof Pica)) return new Pica(options);\n\n        this.options = assign(DEFAULT_PICA_OPTS, options || {});\n\n        var limiter_key = 'lk_' + this.options.concurrency;\n\n        // Share limiters to avoid multiple parallel workers when user creates\n        // multiple pica instances.\n        this.__limit = singletones[limiter_key] || utils.limiter(this.options.concurrency);\n\n        if (!singletones[limiter_key]) singletones[limiter_key] = this.__limit;\n\n        // List of supported features, according to options & browser/node.js\n        this.features = {\n            js: false, // pure JS implementation, can be disabled for testing\n            wasm: false, // webassembly implementation for heavy functions\n            cib: false, // resize via createImageBitmap (only FF at this moment)\n            ww: false // webworkers\n        };\n\n        this.__workersPool = null;\n\n        // Store requested features for webworkers\n        this.__requested_features = [];\n\n        this.__mathlib = null;\n    }\n\n    Pica.prototype.init = function () {\n        var _this = this;\n\n        if (this.__initPromise) return this.__initPromise;\n\n        // Test if we can create ImageData without canvas and memory copy\n        if (CAN_NEW_IMAGE_DATA !== false && CAN_NEW_IMAGE_DATA !== true) {\n            CAN_NEW_IMAGE_DATA = false;\n            if (typeof ImageData !== 'undefined' && typeof Uint8ClampedArray !== 'undefined') {\n                try {\n                    /* eslint-disable no-new */\n                    new ImageData(new Uint8ClampedArray(400), 10, 10);\n                    CAN_NEW_IMAGE_DATA = true;\n                } catch (__) {}\n            }\n        }\n\n        var features = this.options.features.slice();\n\n        if (features.indexOf('all') >= 0) {\n            features = ['cib', 'wasm', 'js', 'ww'];\n        }\n\n        this.__requested_features = features;\n\n        this.__mathlib = new MathLib(features);\n\n        // Check WebWorker support if requested\n        if (features.indexOf('ww') >= 0) {\n            if (typeof window !== 'undefined' && 'Worker' in window) {\n                // IE <= 11 don't allow to create webworkers from string. We should check it.\n                // https://connect.microsoft.com/IE/feedback/details/801810/web-workers-from-blob-urls-in-ie-10-and-11\n                try {\n                    var wkr = require('webworkify')(function () {});\n                    wkr.terminate();\n                    this.features.ww = true;\n\n                    // pool uniqueness depends on pool config + webworker config\n                    var wpool_key = 'wp_' + JSON.stringify(this.options);\n\n                    if (singletones[wpool_key]) {\n                        this.__workersPool = singletones[wpool_key];\n                    } else {\n                        this.__workersPool = new Pool(workerFabric, this.options.idle);\n                        singletones[wpool_key] = this.__workersPool;\n                    }\n                } catch (__) {}\n            }\n        }\n\n        var initMath = this.__mathlib.init().then(function (mathlib) {\n            // Copy detected features\n            assign(_this.features, mathlib.features);\n        });\n\n        var checkCib = utils.cib_support().then(function (status) {\n            if (_this.features.cib && features.indexOf('cib') < 0) {\n                _this.debug('createImageBitmap() resize supported, but disabled by config');\n                return;\n            }\n\n            if (features.indexOf('cib') >= 0) _this.features.cib = status;\n        });\n\n        // Init math lib. That's async because can load some\n        this.__initPromise = Promise.all([initMath, checkCib]).then(function () {\n            return _this;\n        });\n\n        return this.__initPromise;\n    };\n\n    Pica.prototype.resize = function (from, to, options) {\n        var _this2 = this;\n\n        this.debug('Start resize...');\n\n        var opts = DEFAULT_RESIZE_OPTS;\n\n        if (!isNaN(options)) {\n            opts = assign(opts, { quality: options });\n        } else if (options) {\n            opts = assign(opts, options);\n        }\n\n        opts.toWidth = to.width;\n        opts.toHeigth = to.height;\n        opts.width = from.naturalWidth || from.width;\n        opts.height = from.naturalHeight || from.height;\n\n        var canceled = false;\n        var cancelToken = null;\n\n        if (opts.cancelToken) {\n            // Wrap cancelToken to avoid successive resolve & set flag\n            cancelToken = opts.cancelToken.then(function (data) {\n                canceled = true;throw data;\n            }, function (err) {\n                canceled = true;throw err;\n            });\n        }\n\n        var toCtx = to.getContext('2d', { alpha: Boolean(opts.alpha) });\n\n        return this.init().then(function () {\n            if (canceled) return cancelToken;\n\n            // if createImageBitmap supports resize, just do it and return\n            if (_this2.features.cib) {\n                _this2.debug('Resize via createImageBitmap()');\n\n                return createImageBitmap(from, {\n                    resizeWidth: opts.toWidth,\n                    resizeHeight: opts.toHeigth,\n                    resizeQuality: utils.cib_quality_name(opts.quality)\n                }).then(function (imageBitmap) {\n                    if (canceled) return cancelToken;\n\n                    // if no unsharp - draw directly to output canvas\n                    if (!opts.unsharpAmount) {\n                        toCtx.drawImage(imageBitmap, 0, 0);\n                        imageBitmap.close();\n                        toCtx = null;\n\n                        _this2.debug('Finished!');\n\n                        return to;\n                    }\n\n                    _this2.debug('Unsharp result');\n\n                    var tmpCanvas = document.createElement('canvas');\n\n                    tmpCanvas.width = opts.toWidth;\n                    tmpCanvas.height = opts.toHeigth;\n\n                    var tmpCtx = tmpCanvas.getContext('2d', { alpha: Boolean(opts.alpha) });\n\n                    tmpCtx.drawImage(imageBitmap, 0, 0);\n                    imageBitmap.close();\n\n                    var iData = tmpCtx.getImageData(0, 0, opts.toWidth, opts.toHeigth);\n\n                    _this2.__mathlib.unsharp(iData.data, opts.toWidth, opts.toHeigth, opts.unsharpAmount, opts.unsharpRadius, opts.unsharpThreshold);\n\n                    toCtx.putImageData(iData, 0, 0);\n                    iData = tmpCtx = tmpCanvas = toCtx = null;\n\n                    _this2.debug('Finished!');\n\n                    return to;\n                });\n            }\n\n            //\n            // No easy way, let's resize manually via arrays\n            //\n\n            var srcCtx = void 0;\n            var srcImageBitmap = void 0;\n\n            // Share cache between calls:\n            //\n            // - wasm instance\n            // - wasm memory object\n            //\n            var cache = {};\n\n            // Call resizer in webworker or locally, depending on config\n            var invokeResize = function invokeResize(opts) {\n                return Promise.resolve().then(function () {\n                    if (!_this2.features.ww) return _this2.__mathlib.resizeAndUnsharp(opts, cache);\n\n                    return new Promise(function (resolve, reject) {\n                        var w = _this2.__workersPool.acquire();\n\n                        if (cancelToken) cancelToken.catch(function (err) {\n                            return reject(err);\n                        });\n\n                        w.value.onmessage = function (ev) {\n                            w.release();\n\n                            if (ev.data.err) reject(ev.data.err);else resolve(ev.data.result);\n                        };\n\n                        w.value.postMessage({\n                            opts: opts,\n                            features: _this2.__requested_features,\n                            preload: {\n                                wasm_nodule: _this2.__mathlib.__\n                            }\n                        }, [opts.src.buffer]);\n                    });\n                });\n            };\n\n            var processTile = function processTile(tile) {\n                return _this2.__limit(function () {\n                    if (canceled) return cancelToken;\n\n                    var srcImageData = void 0;\n\n                    // Extract tile RGBA buffer, depending on input type\n                    if (utils.isCanvas(from)) {\n                        _this2.debug('Get tile pixel data');\n\n                        // If input is Canvas - extract region data directly\n                        srcImageData = srcCtx.getImageData(tile.x, tile.y, tile.width, tile.height);\n                    } else {\n                        // If input is Image or decoded to ImageBitmap,\n                        // draw region to temporary canvas and extract data from it\n                        //\n                        // Note! Attempt to reuse this canvas causes significant slowdown in chrome\n                        //\n                        _this2.debug('Draw tile imageBitmap/image to temporary canvas');\n\n                        var tmpCanvas = document.createElement('canvas');\n                        tmpCanvas.width = tile.width;\n                        tmpCanvas.height = tile.height;\n\n                        var tmpCtx = tmpCanvas.getContext('2d', { alpha: Boolean(opts.alpha) });\n                        tmpCtx.globalCompositeOperation = 'copy';\n                        tmpCtx.drawImage(srcImageBitmap || from, tile.x, tile.y, tile.width, tile.height, 0, 0, tile.width, tile.height);\n\n                        _this2.debug('Get tile pixel data');\n\n                        srcImageData = tmpCtx.getImageData(0, 0, tile.width, tile.height);\n                        tmpCtx = tmpCanvas = null;\n                    }\n\n                    var o = {\n                        src: srcImageData.data,\n                        width: tile.width,\n                        height: tile.height,\n                        toWidth: tile.toWidth,\n                        toHeight: tile.toHeight,\n                        scaleX: tile.scaleX,\n                        scaleY: tile.scaleY,\n                        offsetX: tile.offsetX,\n                        offsetY: tile.offsetY,\n                        quality: opts.quality,\n                        alpha: opts.alpha,\n                        unsharpAmount: opts.unsharpAmount,\n                        unsharpRadius: opts.unsharpRadius,\n                        unsharpThreshold: opts.unsharpThreshold\n                    };\n\n                    _this2.debug('Invoke resize math');\n\n                    return Promise.resolve().then(function () {\n                        return invokeResize(o);\n                    }).then(function (result) {\n                        if (canceled) return cancelToken;\n\n                        srcImageData = null;\n\n                        var toImageData = void 0;\n\n                        _this2.debug('Convert raw rgba tile result to ImageData');\n\n                        if (CAN_NEW_IMAGE_DATA) {\n                            // this branch is for modern browsers\n                            // If `new ImageData()` & Uint8ClampedArray suported\n                            toImageData = new ImageData(new Uint8ClampedArray(result), tile.toWidth, tile.toHeight);\n                        } else {\n                            // fallback for `node-canvas` and old browsers\n                            // (IE11 has ImageData but does not support `new ImageData()`)\n                            toImageData = toCtx.createImageData(tile.toWidth, tile.toHeight);\n\n                            if (toImageData.data.set) {\n                                toImageData.data.set(result);\n                            } else {\n                                // IE9 don't have `.set()`\n                                for (var i = toImageData.data.length - 1; i >= 0; i--) {\n                                    toImageData.data[i] = result[i];\n                                }\n                            }\n                        }\n\n                        _this2.debug('Draw tile');\n\n                        if (NEED_SAFARI_FIX) {\n                            // Safari draws thin white stripes between tiles without this fix\n                            toCtx.putImageData(toImageData, tile.toX, tile.toY, tile.toInnerX - tile.toX, tile.toInnerY - tile.toY, tile.toInnerWidth + 1e-5, tile.toInnerHeight + 1e-5);\n                        } else {\n                            toCtx.putImageData(toImageData, tile.toX, tile.toY, tile.toInnerX - tile.toX, tile.toInnerY - tile.toY, tile.toInnerWidth, tile.toInnerHeight);\n                        }\n\n                        return null;\n                    });\n                });\n            };\n\n            // Need normalize data source first. It can be canvas or image.\n            // If image - try to decode in background if possible\n            return Promise.resolve().then(function () {\n                if (utils.isCanvas(from)) {\n                    srcCtx = from.getContext('2d', { alpha: Boolean(opts.alpha) });\n                    return null;\n                }\n\n                if (utils.isImage(from)) {\n                    // try do decode image in background for faster next operations\n                    if (typeof createImageBitmap === 'undefined') return null;\n\n                    _this2.debug('Decode image via createImageBitmap');\n\n                    return createImageBitmap(from).then(function (imageBitmap) {\n                        srcImageBitmap = imageBitmap;\n                    });\n                }\n\n                throw new Error('\".from\" should be image or canvas');\n            }).then(function () {\n                if (canceled) return cancelToken;\n\n                _this2.debug('Calculate tiles');\n\n                //\n                // Here we are with \"normalized\" source,\n                // follow to tiling\n                //\n\n                var DEST_TILE_BORDER = 3; // Max possible filter window size\n\n                var regions = createRegions({\n                    width: opts.width,\n                    height: opts.height,\n                    srcTileSize: _this2.options.tile,\n                    toWidth: opts.toWidth,\n                    toHeight: opts.toHeigth,\n                    destTileBorder: Math.ceil(Math.max(DEST_TILE_BORDER, 2.5 * opts.unsharpRadius | 0))\n                });\n\n                var jobs = regions.map(function (tile) {\n                    return processTile(tile);\n                });\n\n                function cleanup() {\n                    if (srcImageBitmap) {\n                        srcImageBitmap.close();\n                        srcImageBitmap = null;\n                    }\n                }\n\n                _this2.debug('Process tiles');\n\n                return Promise.all(jobs).then(function () {\n                    _this2.debug('Finished!');\n                    cleanup();return to;\n                }, function (err) {\n                    cleanup();throw err;\n                });\n            });\n        });\n    };\n\n// RGBA buffer resize\n//\n    Pica.prototype.resizeBuffer = function (options) {\n        var _this3 = this;\n\n        var opts = assign(DEFAULT_RESIZE_OPTS, options);\n\n        return this.init().then(function () {\n            return _this3.__mathlib.resizeAndUnsharp(opts);\n        });\n    };\n\n    Pica.prototype.toBlob = function (canvas, mimeType, quality) {\n        mimeType = mimeType || 'image/png';\n\n        return new Promise(function (resolve) {\n            if (canvas.toBlob) {\n                canvas.toBlob(function (blob) {\n                    return resolve(blob);\n                }, mimeType, quality);\n                return;\n            }\n\n            // Fallback for old browsers\n            var asString = atob(canvas.toDataURL(mimeType, quality).split(',')[1]);\n            var len = asString.length;\n            var asBuffer = new Uint8Array(len);\n\n            for (var i = 0; i < len; i++) {\n                asBuffer[i] = asString.charCodeAt(i);\n            }\n\n            resolve(new Blob([asBuffer], { type: mimeType }));\n        });\n    };\n\n    Pica.prototype.debug = function () {};\n\n    module.exports = Pica;\n\n},{\"./lib/mathlib\":1,\"./lib/pool\":9,\"./lib/tiler\":10,\"./lib/utils\":11,\"./lib/worker\":12,\"object-assign\":14,\"webworkify\":15}]},{},[])(\"/\")\n});\n","define('paychex.core/lib/queue',[\n    'paychex.core/lib/nextTick'\n], function(\n    nextTick\n){\n\n    'use strict';\n\n    /*!\n     * goodwin - deep object get/set path values\n     * Copyright(c) 2012 Jake Luer <jake@alogicalparadox.com>\n     * MIT Licensed\n     */\n\n    /*!\n     * Constants\n     */\n\n    var noop = function () {};\n\n    /*!\n     * Queue\n     *\n     * The Queue constructor will hold all of the necissary\n     * settings to correctly execute a queue.\n     *\n     * @param {Function} iterator\n     * @param {Number} concurrency (defaults to 10)\n     * @api private\n     */\n\n    function Queue (iterator, concurrency) {\n        this._iterator = iterator;\n        this._concurrency = concurrency || 10;\n        this._tasks = [];\n        this._err = false;\n        this.workers = 0;\n    }\n\n    /**\n     * ### .length\n     *\n     * Property indicating the number of items current\n     * in the queue. An item is removed from this list\n     * prior to being processed.\n     *\n     * @return {Number} count of queued items\n     * @api public\n     */\n\n    Object.defineProperty(Queue.prototype, 'length',\n        { get: function () {\n            return this._tasks.length;\n        }\n        });\n\n    /**\n     * ### .push (items[, callback[, autostart]])\n     *\n     * You can push an item or an array of items into\n     * the queue for processing. The callback will be\n     * called for the completion of each item if the queue\n     * has not entered into an error state. A `autostart`\n     * boolean my also be provided if you wish to start\n     * processing the queue with this push of items. If\n     * no pushes provide the autostart, then the queue\n     * must be started manually with `.process()`.\n     *\n     * Note that if the queue has already been started but\n     * has been drained of items, it will not start again\n     * with another push unless the `autostart` toggle is present.\n     *\n     * ```js\n     * // single item\n     * queue.push({ hello: 'universe' });\n     *\n     * // multiple items\n     * queue.push([\n     *     { hello: 'world' }\n     *   , { hello: 'universe' }\n     * ]);\n     *\n     * // notify callback\n     * queue.push({ hello: 'universe' }, notify);\n     *\n     * // autostart\n     * queue.push({ hello: 'universe' }, true);\n     *\n     * // notify + autostart\n     * queue.push({ hello: 'univeerse' }, notify, true);\n     * ```\n     *\n     * @param {Array} item or items to be added to the queue\n     * @param {Function} callback for completion of each item\n     * @param {Boolean} autostart process (defaults to false)\n     * @name push\n     * @api public\n     */\n\n    Queue.prototype.push = function (items, cb, start) {\n        if ('boolean' === typeof cb) start = cb, cb = noop;\n        if (!Array.isArray(items)) items = [ items ];\n        cb = cb || noop;\n\n        var cc = this._concurrency\n            , sat = this.saturated;\n\n        for (var i = 0, l = items.length; i < l; i ++) {\n            var task = items[i];\n            this._tasks.push({ task: task , cb: cb });\n            if (sat && this._tasks.length === cc) sat();\n            if (start) nextTick(this.process.bind(this));\n        }\n\n        return this;\n    };\n\n    /**\n     * ### .process ()\n     *\n     * Begin the queue processing cycle. Has no impact if\n     * the queue is already processing.\n     *\n     * ```js\n     * queue.process();\n     * ```\n     *\n     * @name process\n     * @api public\n     */\n\n    Queue.prototype.process = function () {\n        var self = this\n            , cc = this._concurrency\n            , iterator = this._iterator\n\n        if (this.workers < cc && this.length && !this._err) {\n            var task = this._tasks.shift();\n            if (this.empty && !this.length) this.empty();\n            this.workers++;\n            iterator(task.task, function next () {\n                self.workers--;\n                if (self._err) return;\n                var err = arguments[0];\n                if (err) self._err = true;\n                if (task.cb) task.cb.apply(task, arguments);\n                if (err && self.onerror) return self.onerror(err);\n                if (self.drain && self.length + self.workers === 0) self.drain();\n                self.process();\n            });\n            this.process();\n        }\n\n        return this;\n    };\n\n    /**\n     * ### .onerror\n     *\n     * Setting this to a function will provide a listener\n     * should an error occur. It will not be executed otherwise.\n     *\n     * ```js\n     * queue.onerror = function (err) {\n *   error(err.message);\n * };\n     * ```\n     *\n     * @default null\n     * @expected {Function} on error callback\n     * @cb {Error} object that was passed as error during iteration\n     * @api public\n     */\n\n    Queue.prototype.onerror = null;\n\n    /**\n     * ### .saturated\n     *\n     * This listener will be executed when the number of\n     * queued items exceeds the current concurrency value.\n     * This will be executed directly after the push of\n     * said items.\n     *\n     * ```js\n     * queue.saturated = function () {\n *   log('the queue is saturated');\n * };\n     * ```\n     *\n     * @default null\n     * @expected {Function}\n     * @api public\n     */\n\n    Queue.prototype.saturated = null;\n\n    /**\n     * ### .empty\n     *\n     * This listener will be executed when the queue is empty.\n     * In other words, prior to the last item in the queue\n     * being processed.\n     *\n     * ```js\n     * queue.empty = function () {\n *   log('the queue is on the last item');\n * };\n     * ```\n     *\n     * @default null\n     * @expected {Function}\n     * @api public\n     */\n\n    Queue.prototype.empty = null;\n\n    /**\n     * ### .drain\n     *\n     * This listener will be executed when all queued\n     * items have been executed through the iterator.\n     *\n     * ```js\n     * queue.drain = function () {\n *   log('the queue has processed all tiems');\n * };\n     * ```\n     *\n     * @default null\n     * @expected {Function}\n     * @api public\n     */\n\n    Queue.prototype.drain = null;\n\n    /**\n     * ### Queue (iterator, concurrency)\n     *\n     * The queue mechanism allows for a any number of\n     * data objects to be processed by an iterator\n     * when they become available. The queue will processes\n     * items in parellel, up to a given concurrently value\n     * then will wait until an item has finished before\n     * beginning to process the next.\n     *\n     * Should any item in the queue\n     * fail to process and provide an error to the `next`\n     * callback, no further items will be processed though items\n     * already started will run to completion.\n     *\n     * ```js\n     * var Queue = require('breeze-queue');\n     *\n     * var queue = Queue(function (obj, next) {\n *   setTimeout(next, 10);\n * }, 5);\n     * ```\n     *\n     * @param {Function} iterator\n     * @param {Number} concurrency (defaults to 10)\n     * @return {Object} queue api\n     * @name queue\n     * @api public\n     */\n\n    return function (iterator, concurrency) {\n        var queue = new Queue(iterator, concurrency);\n        return queue;\n    };\n\n});\n","define('paychex.core/lib/tsort',[], function(){\n\n    'use strict';\n\n    /*!\n     * gaia-tsort - Topological sorting utility\n     * Copyright(c) 2012 Jake Luer <jake@qualiancy.com>\n     * MIT Licensed\n     */\n\n    /**\n     * ### tsort (edges)\n     *\n     * Topological sorting is a methodology used to organize a\n     * directed-acyclic-graph (DAG). A DAG is a graph of nodes in\n     * which there are no cyclic references, and therefor has\n     * a specific starting and ending point.\n     *\n     * A set of edges is defined as an array, with each element being\n     * an array of x, y pairs, where `x` is a parent of `y`.\n     *\n     * ```js\n     * var edges = [\n     *     [ 'a', 'b' ]\n     *   , [ 'a', 'c' ]\n     *   , [ 'd', 'e' ]\n     *   , [ 'b', 'd' ]\n     * ];\n     * ```\n     *\n     * With the above edges, we expect `a` to be the top-most parent.\n     * `b` and `c` are it's children; `d` is a child of `b`; `e` is a\n     * child of `d`.\n     *\n     * The following demonstrates the output of this tool.\n     *\n     * ```js\n     * var tsort = require('gaia-tsort')\n     *   , sorted = tsort(edges);\n     *\n     * // console.log(sorted);\n     * {\n *     path: [ 'a', 'c', 'b', 'd', 'e' ]\n *   , graph: [\n *         { id: 'a', children: [ 'b', 'c' ], parents: [] }\n *       , { id: 'c', children: [], parents: [ 'a' ] }\n *       , { id: 'b', children: [ 'd' ], parents: [ 'a' ] }\n *       , { id: 'd', children: [ 'e' ], parents: [ 'b' ] }\n *       , { id: 'e', children: [], parents: [ 'd' ] }\n *     ]\n * }\n     * ```\n     *\n     * Should there a cyclical reference, the result will resemble the following.\n     *\n     * ```js\n     * {\n *   error: new Error('child-name can not come before parent-name')\n * }\n     * ```\n     *\n     * @param {Array} edges\n     * @return {Object}\n     * @api public\n     */\n\n    return function (edges) {\n        var graph = []\n            , nodes = {}\n            , sorted = []\n            , visited = {}\n            , critical;\n\n        // node constructor\n        function N (id) {\n            this.id = id;\n            this.children = [];\n            this.parents = [];\n        }\n\n        // recursively visit nodes\n        function doVisit (idstr, ancestors) {\n            var node = nodes[idstr]\n                , id = node.id;\n\n            if (visited[idstr]) return;\n            if (!Array.isArray(ancestors))\n                ancestors = [];\n\n            ancestors.push(id);\n            visited[idstr] = true;\n\n            // deep recursive checking\n            node.children.forEach(function (afterId) {\n                if (ancestors.indexOf(afterId) >= 0)\n                    throw new Error(id + ' can not come before ' + afterId);\n                var aid = afterId.toString()\n                    , anc = ancestors.map(function (v) { return v });\n                doVisit(aid, anc);\n            });\n\n            sorted.unshift(id);\n        }\n\n        function doFilter (s) {\n            return null !== s && 'undefined' !== typeof s;\n        }\n\n        // parse edges into nodes\n        edges.forEach(function (v) {\n            var from = v[0]\n                , to = v[1];\n            if (!nodes[from]) nodes[from] = new N(from);\n            if (!nodes[to]) nodes[to] = new N(to);\n            if (!~nodes[to].parents.indexOf(from))\n                nodes[to].parents.push(from);\n            if (!~nodes[from].children.indexOf(to))\n                nodes[from].children.push(to);\n        });\n\n        // do our recursion\n        // TODO: without try catch\n        try { Object.keys(nodes).forEach(doVisit); }\n        catch (ex) { return { error: ex } };\n\n        // order our children object\n        critical = sorted.filter(doFilter);\n\n        critical.forEach(function (v) {\n            var n = nodes[v];\n            n.children = n.children.filter(doFilter);\n            n.parents = n.parents.filter(doFilter);\n            graph.push(n);\n        });\n\n        return { path: critical, graph: graph };\n    };\n\n});\n","/**\n * UAParser.js v0.7.3\n * Lightweight JavaScript-based User-Agent string parser\n * https://github.com/faisalman/ua-parser-js\n * \n * Copyright © 2012-2014 Faisal Salman <fyzlman@gmail.com>\n * Dual licensed under GPLv2 & MIT\n */\n(function(window,undefined){\"use strict\";var LIBVERSION=\"0.7.3\",EMPTY=\"\",UNKNOWN=\"?\",FUNC_TYPE=\"function\",UNDEF_TYPE=\"undefined\",OBJ_TYPE=\"object\",MAJOR=\"major\",MODEL=\"model\",NAME=\"name\",TYPE=\"type\",VENDOR=\"vendor\",VERSION=\"version\",ARCHITECTURE=\"architecture\",CONSOLE=\"console\",MOBILE=\"mobile\",TABLET=\"tablet\",SMARTTV=\"smarttv\",WEARABLE=\"wearable\",EMBEDDED=\"embedded\";var util={extend:function(regexes,extensions){for(var i in extensions){if(\"browser cpu device engine os\".indexOf(i)!==-1&&extensions[i].length%2===0){regexes[i]=extensions[i].concat(regexes[i])}}return regexes},has:function(str1,str2){if(typeof str1===\"string\"){return str2.toLowerCase().indexOf(str1.toLowerCase())!==-1}},lowerize:function(str){return str.toLowerCase()}};var mapper={rgx:function(){var result,i=0,j,k,p,q,matches,match,args=arguments;while(i<args.length&&!matches){var regex=args[i],props=args[i+1];if(typeof result===UNDEF_TYPE){result={};for(p in props){q=props[p];if(typeof q===OBJ_TYPE){result[q[0]]=undefined}else{result[q]=undefined}}}j=k=0;while(j<regex.length&&!matches){matches=regex[j++].exec(this.getUA());if(!!matches){for(p=0;p<props.length;p++){match=matches[++k];q=props[p];if(typeof q===OBJ_TYPE&&q.length>0){if(q.length==2){if(typeof q[1]==FUNC_TYPE){result[q[0]]=q[1].call(this,match)}else{result[q[0]]=q[1]}}else if(q.length==3){if(typeof q[1]===FUNC_TYPE&&!(q[1].exec&&q[1].test)){result[q[0]]=match?q[1].call(this,match,q[2]):undefined}else{result[q[0]]=match?match.replace(q[1],q[2]):undefined}}else if(q.length==4){result[q[0]]=match?q[3].call(this,match.replace(q[1],q[2])):undefined}}else{result[q]=match?match:undefined}}}}i+=2}return result},str:function(str,map){for(var i in map){if(typeof map[i]===OBJ_TYPE&&map[i].length>0){for(var j=0;j<map[i].length;j++){if(util.has(map[i][j],str)){return i===UNKNOWN?undefined:i}}}else if(util.has(map[i],str)){return i===UNKNOWN?undefined:i}}return str}};var maps={browser:{oldsafari:{major:{1:[\"/8\",\"/1\",\"/3\"],2:\"/4\",\"?\":\"/\"},version:{\"1.0\":\"/8\",1.2:\"/1\",1.3:\"/3\",\"2.0\":\"/412\",\"2.0.2\":\"/416\",\"2.0.3\":\"/417\",\"2.0.4\":\"/419\",\"?\":\"/\"}}},device:{amazon:{model:{\"Fire Phone\":[\"SD\",\"KF\"]}},sprint:{model:{\"Evo Shift 4G\":\"7373KT\"},vendor:{HTC:\"APA\",Sprint:\"Sprint\"}}},os:{windows:{version:{ME:\"4.90\",\"NT 3.11\":\"NT3.51\",\"NT 4.0\":\"NT4.0\",2000:\"NT 5.0\",XP:[\"NT 5.1\",\"NT 5.2\"],Vista:\"NT 6.0\",7:\"NT 6.1\",8:\"NT 6.2\",8.1:\"NT 6.3\",10:\"NT 6.4\",RT:\"ARM\"}}}};var regexes={browser:[[/(opera\\smini)\\/((\\d+)?[\\w\\.-]+)/i,/(opera\\s[mobiletab]+).+version\\/((\\d+)?[\\w\\.-]+)/i,/(opera).+version\\/((\\d+)?[\\w\\.]+)/i,/(opera)[\\/\\s]+((\\d+)?[\\w\\.]+)/i],[NAME,VERSION,MAJOR],[/\\s(opr)\\/((\\d+)?[\\w\\.]+)/i],[[NAME,\"Opera\"],VERSION,MAJOR],[/(kindle)\\/((\\d+)?[\\w\\.]+)/i,/(lunascape|maxthon|netfront|jasmine|blazer)[\\/\\s]?((\\d+)?[\\w\\.]+)*/i,/(avant\\s|iemobile|slim|baidu)(?:browser)?[\\/\\s]?((\\d+)?[\\w\\.]*)/i,/(?:ms|\\()(ie)\\s((\\d+)?[\\w\\.]+)/i,/(rekonq)((?:\\/)[\\w\\.]+)*/i,/(chromium|flock|rockmelt|midori|epiphany|silk|skyfire|ovibrowser|bolt|iron)\\/((\\d+)?[\\w\\.-]+)/i],[NAME,VERSION,MAJOR],[/(trident).+rv[:\\s]((\\d+)?[\\w\\.]+).+like\\sgecko/i],[[NAME,\"IE\"],VERSION,MAJOR],[/(yabrowser)\\/((\\d+)?[\\w\\.]+)/i],[[NAME,\"Yandex\"],VERSION,MAJOR],[/(comodo_dragon)\\/((\\d+)?[\\w\\.]+)/i],[[NAME,/_/g,\" \"],VERSION,MAJOR],[/(chrome|omniweb|arora|[tizenoka]{5}\\s?browser)\\/v?((\\d+)?[\\w\\.]+)/i,/(uc\\s?browser|qqbrowser)[\\/\\s]?((\\d+)?[\\w\\.]+)/i],[NAME,VERSION,MAJOR],[/(dolfin)\\/((\\d+)?[\\w\\.]+)/i],[[NAME,\"Dolphin\"],VERSION,MAJOR],[/((?:android.+)crmo|crios)\\/((\\d+)?[\\w\\.]+)/i],[[NAME,\"Chrome\"],VERSION,MAJOR],[/version\\/((\\d+)?[\\w\\.]+).+?mobile\\/\\w+\\s(safari)/i],[VERSION,MAJOR,[NAME,\"Mobile Safari\"]],[/version\\/((\\d+)?[\\w\\.]+).+?(mobile\\s?safari|safari)/i],[VERSION,MAJOR,NAME],[/webkit.+?(mobile\\s?safari|safari)((\\/[\\w\\.]+))/i],[NAME,[MAJOR,mapper.str,maps.browser.oldsafari.major],[VERSION,mapper.str,maps.browser.oldsafari.version]],[/(konqueror)\\/((\\d+)?[\\w\\.]+)/i,/(webkit|khtml)\\/((\\d+)?[\\w\\.]+)/i],[NAME,VERSION,MAJOR],[/(navigator|netscape)\\/((\\d+)?[\\w\\.-]+)/i],[[NAME,\"Netscape\"],VERSION,MAJOR],[/(swiftfox)/i,/(icedragon|iceweasel|camino|chimera|fennec|maemo\\sbrowser|minimo|conkeror)[\\/\\s]?((\\d+)?[\\w\\.\\+]+)/i,/(firefox|seamonkey|k-meleon|icecat|iceape|firebird|phoenix)\\/((\\d+)?[\\w\\.-]+)/i,/(mozilla)\\/((\\d+)?[\\w\\.]+).+rv\\:.+gecko\\/\\d+/i,/(polaris|lynx|dillo|icab|doris|amaya|w3m|netsurf)[\\/\\s]?((\\d+)?[\\w\\.]+)/i,/(links)\\s\\(((\\d+)?[\\w\\.]+)/i,/(gobrowser)\\/?((\\d+)?[\\w\\.]+)*/i,/(ice\\s?browser)\\/v?((\\d+)?[\\w\\._]+)/i,/(mosaic)[\\/\\s]((\\d+)?[\\w\\.]+)/i],[NAME,VERSION,MAJOR]],cpu:[[/(?:(amd|x(?:(?:86|64)[_-])?|wow|win)64)[;\\)]/i],[[ARCHITECTURE,\"amd64\"]],[/(ia32(?=;))/i],[[ARCHITECTURE,util.lowerize]],[/((?:i[346]|x)86)[;\\)]/i],[[ARCHITECTURE,\"ia32\"]],[/windows\\s(ce|mobile);\\sppc;/i],[[ARCHITECTURE,\"arm\"]],[/((?:ppc|powerpc)(?:64)?)(?:\\smac|;|\\))/i],[[ARCHITECTURE,/ower/,\"\",util.lowerize]],[/(sun4\\w)[;\\)]/i],[[ARCHITECTURE,\"sparc\"]],[/((?:avr32|ia64(?=;))|68k(?=\\))|arm(?:64|(?=v\\d+;))|(?=atmel\\s)avr|(?:irix|mips|sparc)(?:64)?(?=;)|pa-risc)/i],[[ARCHITECTURE,util.lowerize]]],device:[[/\\((ipad|playbook);[\\w\\s\\);-]+(rim|apple)/i],[MODEL,VENDOR,[TYPE,TABLET]],[/applecoremedia\\/[\\w\\.]+ \\((ipad)/],[MODEL,[VENDOR,\"Apple\"],[TYPE,TABLET]],[/(apple\\s{0,1}tv)/i],[[MODEL,\"Apple TV\"],[VENDOR,\"Apple\"]],[/(archos)\\s(gamepad2?)/i,/(hp).+(touchpad)/i,/(kindle)\\/([\\w\\.]+)/i,/\\s(nook)[\\w\\s]+build\\/(\\w+)/i,/(dell)\\s(strea[kpr\\s\\d]*[\\dko])/i],[VENDOR,MODEL,[TYPE,TABLET]],[/(kf[A-z]+)\\sbuild\\/[\\w\\.]+.*silk\\//i],[MODEL,[VENDOR,\"Amazon\"],[TYPE,TABLET]],[/(sd|kf)[0349hijorstuw]+\\sbuild\\/[\\w\\.]+.*silk\\//i],[[MODEL,mapper.str,maps.device.amazon.model],[VENDOR,\"Amazon\"],[TYPE,MOBILE]],[/\\((ip[honed|\\s\\w*]+);.+(apple)/i],[MODEL,VENDOR,[TYPE,MOBILE]],[/\\((ip[honed|\\s\\w*]+);/i],[MODEL,[VENDOR,\"Apple\"],[TYPE,MOBILE]],[/(blackberry)[\\s-]?(\\w+)/i,/(blackberry|benq|palm(?=\\-)|sonyericsson|acer|asus|dell|huawei|meizu|motorola|polytron)[\\s_-]?([\\w-]+)*/i,/(hp)\\s([\\w\\s]+\\w)/i,/(asus)-?(\\w+)/i],[VENDOR,MODEL,[TYPE,MOBILE]],[/\\(bb10;\\s(\\w+)/i],[MODEL,[VENDOR,\"BlackBerry\"],[TYPE,MOBILE]],[/android.+(transfo[prime\\s]{4,10}\\s\\w+|eeepc|slider\\s\\w+|nexus 7)/i],[MODEL,[VENDOR,\"Asus\"],[TYPE,TABLET]],[/(sony)\\s(tablet\\s[ps])/i],[VENDOR,MODEL,[TYPE,TABLET]],[/\\s(ouya)\\s/i,/(nintendo)\\s([wids3u]+)/i],[VENDOR,MODEL,[TYPE,CONSOLE]],[/android.+;\\s(shield)\\sbuild/i],[MODEL,[VENDOR,\"Nvidia\"],[TYPE,CONSOLE]],[/(playstation\\s[3portablevi]+)/i],[MODEL,[VENDOR,\"Sony\"],[TYPE,CONSOLE]],[/(sprint\\s(\\w+))/i],[[VENDOR,mapper.str,maps.device.sprint.vendor],[MODEL,mapper.str,maps.device.sprint.model],[TYPE,MOBILE]],[/(lenovo)\\s?(S(?:5000|6000)+(?:[-][\\w+]))/i],[VENDOR,MODEL,[TYPE,TABLET]],[/(htc)[;_\\s-]+([\\w\\s]+(?=\\))|\\w+)*/i,/(zte)-(\\w+)*/i,/(alcatel|geeksphone|huawei|lenovo|nexian|panasonic|(?=;\\s)sony)[_\\s-]?([\\w-]+)*/i],[VENDOR,[MODEL,/_/g,\" \"],[TYPE,MOBILE]],[/[\\s\\(;](xbox(?:\\sone)?)[\\s\\);]/i],[MODEL,[VENDOR,\"Microsoft\"],[TYPE,CONSOLE]],[/(kin\\.[onetw]{3})/i],[[MODEL,/\\./g,\" \"],[VENDOR,\"Microsoft\"],[TYPE,MOBILE]],[/\\s((milestone|droid(?:[2-4x]|\\s(?:bionic|x2|pro|razr))?(:?\\s4g)?))[\\w\\s]+build\\//i,/(mot)[\\s-]?(\\w+)*/i],[[VENDOR,\"Motorola\"],MODEL,[TYPE,MOBILE]],[/android.+\\s(mz60\\d|xoom[\\s2]{0,2})\\sbuild\\//i],[MODEL,[VENDOR,\"Motorola\"],[TYPE,TABLET]],[/android.+((sch-i[89]0\\d|shw-m380s|gt-p\\d{4}|gt-n8000|sgh-t8[56]9|nexus 10))/i,/((SM-T\\w+))/i],[[VENDOR,\"Samsung\"],MODEL,[TYPE,TABLET]],[/((s[cgp]h-\\w+|gt-\\w+|galaxy\\snexus|sm-n900))/i,/(sam[sung]*)[\\s-]*(\\w+-?[\\w-]*)*/i,/sec-((sgh\\w+))/i],[[VENDOR,\"Samsung\"],MODEL,[TYPE,MOBILE]],[/(samsung);smarttv/i],[VENDOR,MODEL,[TYPE,SMARTTV]],[/\\(dtv[\\);].+(aquos)/i],[MODEL,[VENDOR,\"Sharp\"],[TYPE,SMARTTV]],[/sie-(\\w+)*/i],[MODEL,[VENDOR,\"Siemens\"],[TYPE,MOBILE]],[/(maemo|nokia).*(n900|lumia\\s\\d+)/i,/(nokia)[\\s_-]?([\\w-]+)*/i],[[VENDOR,\"Nokia\"],MODEL,[TYPE,MOBILE]],[/android\\s3\\.[\\s\\w-;]{10}(a\\d{3})/i],[MODEL,[VENDOR,\"Acer\"],[TYPE,TABLET]],[/android\\s3\\.[\\s\\w-;]{10}(lg?)-([06cv9]{3,4})/i],[[VENDOR,\"LG\"],MODEL,[TYPE,TABLET]],[/(lg) netcast\\.tv/i],[VENDOR,MODEL,[TYPE,SMARTTV]],[/(nexus\\s[45])/i,/lg[e;\\s\\/-]+(\\w+)*/i],[MODEL,[VENDOR,\"LG\"],[TYPE,MOBILE]],[/android.+(ideatab[a-z0-9\\-\\s]+)/i],[MODEL,[VENDOR,\"Lenovo\"],[TYPE,TABLET]],[/linux;.+((jolla));/i],[VENDOR,MODEL,[TYPE,MOBILE]],[/((pebble))app\\/[\\d\\.]+\\s/i],[VENDOR,MODEL,[TYPE,WEARABLE]],[/android.+;\\s(glass)\\s\\d/i],[MODEL,[VENDOR,\"Google\"],[TYPE,WEARABLE]],[/(mobile|tablet);.+rv\\:.+gecko\\//i],[[TYPE,util.lowerize],VENDOR,MODEL]],engine:[[/(presto)\\/([\\w\\.]+)/i,/(webkit|trident|netfront|netsurf|amaya|lynx|w3m)\\/([\\w\\.]+)/i,/(khtml|tasman|links)[\\/\\s]\\(?([\\w\\.]+)/i,/(icab)[\\/\\s]([23]\\.[\\d\\.]+)/i],[NAME,VERSION],[/rv\\:([\\w\\.]+).*(gecko)/i],[VERSION,NAME]],os:[[/microsoft\\s(windows)\\s(vista|xp)/i],[NAME,VERSION],[/(windows)\\snt\\s6\\.2;\\s(arm)/i,/(windows\\sphone(?:\\sos)*|windows\\smobile|windows)[\\s\\/]?([ntce\\d\\.\\s]+\\w)/i],[NAME,[VERSION,mapper.str,maps.os.windows.version]],[/(win(?=3|9|n)|win\\s9x\\s)([nt\\d\\.]+)/i],[[NAME,\"Windows\"],[VERSION,mapper.str,maps.os.windows.version]],[/\\((bb)(10);/i],[[NAME,\"BlackBerry\"],VERSION],[/(blackberry)\\w*\\/?([\\w\\.]+)*/i,/(tizen)[\\/\\s]([\\w\\.]+)/i,/(android|webos|palm\\os|qnx|bada|rim\\stablet\\sos|meego|contiki)[\\/\\s-]?([\\w\\.]+)*/i,/linux;.+(sailfish);/i],[NAME,VERSION],[/(symbian\\s?os|symbos|s60(?=;))[\\/\\s-]?([\\w\\.]+)*/i],[[NAME,\"Symbian\"],VERSION],[/\\((series40);/i],[NAME],[/mozilla.+\\(mobile;.+gecko.+firefox/i],[[NAME,\"Firefox OS\"],VERSION],[/(nintendo|playstation)\\s([wids3portablevu]+)/i,/(mint)[\\/\\s\\(]?(\\w+)*/i,/(mageia|vectorlinux)[;\\s]/i,/(joli|[kxln]?ubuntu|debian|[open]*suse|gentoo|arch|slackware|fedora|mandriva|centos|pclinuxos|redhat|zenwalk|linpus)[\\/\\s-]?([\\w\\.-]+)*/i,/(hurd|linux)\\s?([\\w\\.]+)*/i,/(gnu)\\s?([\\w\\.]+)*/i],[NAME,VERSION],[/(cros)\\s[\\w]+\\s([\\w\\.]+\\w)/i],[[NAME,\"Chromium OS\"],VERSION],[/(sunos)\\s?([\\w\\.]+\\d)*/i],[[NAME,\"Solaris\"],VERSION],[/\\s([frentopc-]{0,4}bsd|dragonfly)\\s?([\\w\\.]+)*/i],[NAME,VERSION],[/(ip[honead]+)(?:.*os\\s*([\\w]+)*\\slike\\smac|;\\sopera)/i],[[NAME,\"iOS\"],[VERSION,/_/g,\".\"]],[/(mac\\sos\\sx)\\s?([\\w\\s\\.]+\\w)*/i,/(macintosh|mac(?=_powerpc)\\s)/i],[[NAME,\"Mac OS\"],[VERSION,/_/g,\".\"]],[/((?:open)?solaris)[\\/\\s-]?([\\w\\.]+)*/i,/(haiku)\\s(\\w+)/i,/(aix)\\s((\\d)(?=\\.|\\)|\\s)[\\w\\.]*)*/i,/(plan\\s9|minix|beos|os\\/2|amigaos|morphos|risc\\sos|openvms)/i,/(unix)\\s?([\\w\\.]+)*/i],[NAME,VERSION]]};var UAParser=function(uastring,extensions){if(!(this instanceof UAParser)){return new UAParser(uastring,extensions).getResult()}var ua=uastring||(window&&window.navigator&&window.navigator.userAgent?window.navigator.userAgent:EMPTY);var rgxmap=extensions?util.extend(regexes,extensions):regexes;this.getBrowser=function(){return mapper.rgx.apply(this,rgxmap.browser)};this.getCPU=function(){return mapper.rgx.apply(this,rgxmap.cpu)};this.getDevice=function(){return mapper.rgx.apply(this,rgxmap.device)};this.getEngine=function(){return mapper.rgx.apply(this,rgxmap.engine)};this.getOS=function(){return mapper.rgx.apply(this,rgxmap.os)};this.getResult=function(){return{ua:this.getUA(),browser:this.getBrowser(),engine:this.getEngine(),os:this.getOS(),device:this.getDevice(),cpu:this.getCPU()}};this.getUA=function(){return ua};this.setUA=function(uastring){ua=uastring;return this};this.setUA(ua)};UAParser.VERSION=LIBVERSION;UAParser.BROWSER={NAME:NAME,MAJOR:MAJOR,VERSION:VERSION};UAParser.CPU={ARCHITECTURE:ARCHITECTURE};UAParser.DEVICE={MODEL:MODEL,VENDOR:VENDOR,TYPE:TYPE,CONSOLE:CONSOLE,MOBILE:MOBILE,SMARTTV:SMARTTV,TABLET:TABLET,WEARABLE:WEARABLE,EMBEDDED:EMBEDDED};UAParser.ENGINE={NAME:NAME,VERSION:VERSION};UAParser.OS={NAME:NAME,VERSION:VERSION};if(typeof exports!==UNDEF_TYPE){if(typeof module!==UNDEF_TYPE&&module.exports){exports=module.exports=UAParser}exports.UAParser=UAParser}else{window.UAParser=UAParser;if(typeof define===FUNC_TYPE&&define.amd){define('paychex.core/lib/ua-parser.min',[],function(){return UAParser})}var $=window.jQuery||window.Zepto;if(typeof $!==UNDEF_TYPE){var parser=new UAParser;$.ua=parser.getResult();$.ua.get=function(){return parser.getUA()};$.ua.set=function(uastring){parser.setUA(uastring);var result=parser.getResult();for(var prop in result){$.ua[prop]=result[prop]}}}}})(this);\n","/*! usertiming v0.1.6 */\n\n!function(a){\"use strict\";\"undefined\"==typeof a&&(a={}),\"undefined\"==typeof a.performance&&(a.performance={}),a._perfRefForUserTimingPolyfill=a.performance,a.performance.userTimingJsNow=!1,a.performance.userTimingJsNowPrefixed=!1,a.performance.userTimingJsUserTiming=!1,a.performance.userTimingJsUserTimingPrefixed=!1,a.performance.userTimingJsPerformanceTimeline=!1,a.performance.userTimingJsPerformanceTimelinePrefixed=!1;var b,c,d=[],e=[],f=null;if(\"function\"!=typeof a.performance.now){for(a.performance.userTimingJsNow=!0,e=[\"webkitNow\",\"msNow\",\"mozNow\"],b=0;b<e.length;b++)if(\"function\"==typeof a.performance[e[b]]){a.performance.now=a.performance[e[b]],a.performance.userTimingJsNowPrefixed=!0;break}var g=+new Date;a.performance.timing&&a.performance.timing.navigationStart&&(g=a.performance.timing.navigationStart),\"function\"!=typeof a.performance.now&&(a.performance.now=Date.now?function(){return Date.now()-g}:function(){return+new Date-g})}var h=function(){},i=function(){},j=[],k=!1,l=!1;if(\"function\"!=typeof a.performance.getEntries||\"function\"!=typeof a.performance.mark){for(\"function\"==typeof a.performance.getEntries&&\"function\"!=typeof a.performance.mark&&(l=!0),a.performance.userTimingJsPerformanceTimeline=!0,d=[\"webkit\",\"moz\"],e=[\"getEntries\",\"getEntriesByName\",\"getEntriesByType\"],b=0;b<e.length;b++)for(c=0;c<d.length;c++)f=d[c]+e[b].substr(0,1).toUpperCase()+e[b].substr(1),\"function\"==typeof a.performance[f]&&(a.performance[e[b]]=a.performance[f],a.performance.userTimingJsPerformanceTimelinePrefixed=!0);h=function(a){j.push(a),\"measure\"===a.entryType&&(k=!0)};var m=function(){k&&(j.sort(function(a,b){return a.startTime-b.startTime}),k=!1)};if(i=function(a,c){for(b=0;b<j.length;)j[b].entryType===a&&(\"undefined\"==typeof c||j[b].name===c)?j.splice(b,1):b++},\"function\"!=typeof a.performance.getEntries||l){var n=a.performance.getEntries;a.performance.getEntries=function(){m();var b=j.slice(0);return l&&n&&(Array.prototype.push.apply(b,n.call(a.performance)),b.sort(function(a,b){return a.startTime-b.startTime})),b}}if(\"function\"!=typeof a.performance.getEntriesByType||l){var o=a.performance.getEntriesByType;a.performance.getEntriesByType=function(c){if(\"undefined\"==typeof c||\"mark\"!==c&&\"measure\"!==c)return l&&o?o.call(a.performance,c):[];\"measure\"===c&&m();var d=[];for(b=0;b<j.length;b++)j[b].entryType===c&&d.push(j[b]);return d}}if(\"function\"!=typeof a.performance.getEntriesByName||l){var p=a.performance.getEntriesByName;a.performance.getEntriesByName=function(c,d){if(d&&\"mark\"!==d&&\"measure\"!==d)return l&&p?p.call(a.performance,c,d):[];\"undefined\"!=typeof d&&\"measure\"===d&&m();var e=[];for(b=0;b<j.length;b++)(\"undefined\"==typeof d||j[b].entryType===d)&&j[b].name===c&&e.push(j[b]);return l&&p&&(Array.prototype.push.apply(e,p.call(a.performance,c,d)),e.sort(function(a,b){return a.startTime-b.startTime})),e}}}if(\"function\"!=typeof a.performance.mark){for(a.performance.userTimingJsUserTiming=!0,d=[\"webkit\",\"moz\",\"ms\"],e=[\"mark\",\"measure\",\"clearMarks\",\"clearMeasures\"],b=0;b<e.length;b++)for(c=0;c<d.length;c++)f=d[c]+e[b].substr(0,1).toUpperCase()+e[b].substr(1),\"function\"==typeof a.performance[f]&&(a.performance[e[b]]=a.performance[f],a.performance.userTimingJsUserTimingPrefixed=!0);var q={};\"function\"!=typeof a.performance.mark&&(a.performance.mark=function(b){var c=a.performance.now();if(\"undefined\"==typeof b)throw new SyntaxError(\"Mark name must be specified\");if(a.performance.timing&&b in a.performance.timing)throw new SyntaxError(\"Mark name is not allowed\");q[b]||(q[b]=[]),q[b].push(c),h({entryType:\"mark\",name:b,startTime:c,duration:0})}),\"function\"!=typeof a.performance.clearMarks&&(a.performance.clearMarks=function(a){a?q[a]=[]:q={},i(\"mark\",a)}),\"function\"!=typeof a.performance.measure&&(a.performance.measure=function(b,c,d){var e=a.performance.now();if(\"undefined\"==typeof b)throw new SyntaxError(\"Measure must be specified\");if(!c)return void h({entryType:\"measure\",name:b,startTime:0,duration:e});var f=0;if(a.performance.timing&&c in a.performance.timing){if(\"navigationStart\"!==c&&0===a.performance.timing[c])throw new Error(c+\" has a timing of 0\");f=a.performance.timing[c]-a.performance.timing.navigationStart}else{if(!(c in q))throw new Error(c+\" mark not found\");f=q[c][q[c].length-1]}var g=e;if(d)if(g=0,a.performance.timing&&d in a.performance.timing){if(\"navigationStart\"!==d&&0===a.performance.timing[d])throw new Error(d+\" has a timing of 0\");g=a.performance.timing[d]-a.performance.timing.navigationStart}else{if(!(d in q))throw new Error(d+\" mark not found\");g=q[d][q[d].length-1]}var i=g-f;h({entryType:\"measure\",name:b,startTime:f,duration:i})}),\"function\"!=typeof a.performance.clearMeasures&&(a.performance.clearMeasures=function(a){i(\"measure\",a)})}\"undefined\"!=typeof define&&define.amd?define('paychex.core/lib/usertiming.min',[],function(){return a.performance}):\"undefined\"!=typeof module&&\"undefined\"!=typeof module.exports&&(module.exports=a.performance)}(\"undefined\"!=typeof window?window:void 0);\n//# sourceMappingURL=usertiming.min.js.map;\n","define('paychex.core/Logger',['lib.log4js'], function(log4js) {\n\n    /**\n     * @author Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2014-05-29\n     */\n\n    'use strict';\n\n    /**\n     * @class paychex.core.Logger\n     * @description Wrapper for the log4javascript logger factory.\n     */\n\n    // create alias method\n    /**\n     * Retrieve a specific logger instance. If the instance\n     * has previously been created, the existing instance\n     * will be returned; otherwise, a new instance will be\n     * created.\n     * @function paychex.core.Logger.get\n     * @alias paychex.core.Logger.getLogger\n     * @alias log4javascript.getLogger\n     * @param {String} name The name of the logger to retrieve.\n     *  Names typically use a period to separate namespaces, e.g.\n     *  'my.logger' or 'my.logger.child'\n     * @example\n     * define(['paychex.core/Logger'], function(Logger) {\n     *\n     *   var logger = Logger.get('my.namespaced.logger.name');\n     *\n     *   logger.trace('about to start my code');\n     *   // ...\n     *   logger.trace('code finished');\n     *\n     * });\n     */\n    log4js.get = log4js.getLogger;\n\n    return log4js;\n\n});\n\n","define('paychex.core/ModelList',[\n    'paychex.core/Utils',\n    'paychex.core/Validator',\n    'paychex.core/TriggerMixin'\n], function(\n    _,\n    Validator,\n    TriggerMixin\n) {\n\n    'use strict';\n\n    /* jshint newcap: false */\n\n    /**\n     * @author Dan Barnes\n     * @date 2014-10-04\n     */\n\n    /**\n     * Provides utility methods to help developers manage a collection of objects.\n     * @class paychex.core.ModelList\n     * @mixes paychex.core.TriggerMixin\n     * @example\n     * var list1 = new ModelList(); // creates an empty collection\n     * var list2 = new ModelList(item1, item2, item3); // adds 3 items\n     * var list3 = new ModelList(arrItems); // adds an array of items\n     * @example\n     * // you can iterate through a ModelList:\n     * var list = new ModelList(3, 1, 2, 5, 4);\n     * while (list.moveNext()) {\n     *     log(list.getActive()); // outputs each item\n     * }\n     * list.setActive(); // back to start\n     * list.orderBy(_.identity);\n     * while (list.moveNext()) {\n     *     log(list.getActive()); // outputs each item in numeric order\n     * }\n     * list.setActive(); // back to start\n     * list.filterBy(function(num){ return num > 2; });\n     * while (list.moveNext()) {\n     *     log(list.getActive()); // outputs 3, 4, and 5 (still in numeric order)\n     * }\n     * @example\n     * // you can implement paging using a filter and your own custom events:\n     * var list = new ModelList(),\n     *     curPage = 0,\n     *     pageSize = 2,\n     *     numPages = 0,\n     *     prevBounds = {start: 0, stop: 0},\n     *     resortItems = function(){\n     *         var items = list.getItems(),\n     *             i = 0,\n     *             l = items.length;\n     *         for(; i < l; i++){\n     *             items[i].index = i;\n     *         }\n     *         // we need to manually notify ModelList\n     *         // when item properties have been modified;\n     *         // this will re-sort, re-filter, and re-\n     *         // group as necessary:\n     *         list.trigger('items-modified', items);\n     *     };\n     *\n     * list.on('collection-changed', function(){\n     *     resortItems();\n     *     numPages = Math.ceil(list.getSize(true) / pageSize);\n     *     curPage = Math.max(0, Math.min(curPage, numPages - 1));\n     *     list.trigger('page-index-changed');\n     * });\n     *\n     * // you can create your own events:\n     * list.on('page-index-changed', function(){\n     *     var newBounds = {\n     *         start : curPage * pageSize,\n     *         stop : startIndex + pageSize - 1\n     *     };\n     *     if (! _.isEqual(prevBounds, newBounds)) {\n     *         prevBounds = newBounds;\n     *         list.filterBy(function(item){\n     *             return item.index >= newBounds.start && item.index <= newBounds.stop;\n     *         });\n     *     }\n     * });\n     *\n     * $('#btnPrevPage').click(function(){\n     *     curPage = Math.max(curPage - 1, 0);\n     *     list.trigger('page-index-changed');\n     * });\n     *\n     * $('#btnNextPage').click(function(){\n     *     curPage = Math.min(curPage + 1, numPages - 1);\n     *     list.trigger('page-index-changed');\n     * });\n     *\n     * list.add([\n     *     {key: 'value 1'},\n     *     {key: 'value 2'},\n     *     {key: 'value 3'},\n     *     {key: 'value 4'},\n     *     {key: 'value 5'}\n     * ]);\n     */\n    return function ModelList() {\n\n        /**\n         * @event paychex.core.ModelList#items-modified\n         * @desc\n         * Triggered *by the developer* to notify ModelList\n         * that the specified items' values have changed\n         * and the grouping, sorting, and filtering should\n         * be re-evaluated.\n         * @example\n         * var item1 = {state: 'AZ', value: 123},\n         *     item2 = {state: 'NY', value: 456},\n         *     list = new ModelList(item1, item2);\n         * list.groupBy('state');\n         * item1.state = 'CA';\n         * // grouping will not update automatically;\n         * // we need to notify ModelList before it\n         * // will re-evaluate any sort, filter, or\n         * // grouping methods\n         * list.trigger('items-modified', item1);\n         */\n\n        /**\n         * @event paychex.core.ModelList#value-of-changed\n         * @desc\n         * Triggered automatically when setValueOf is called.\n         * @example\n         * var item1 = {state: 'AZ', value: 123},\n         *     item2 = {state: 'NY', value: 456},\n         *     list = new ModelList(item1, item2);\n         * list.on('value-of-changed', function(){\n         *     // value-of was set\n         * });\n         * list.setValueOf(function(){\n         *     return this.value;\n         * });\n         */\n\n        /**\n         * @event paychex.core.ModelList#items-added\n         * @desc\n         * Triggered automatically when items are added\n         * to the underlying collection. The first\n         * argument to callbacks will be all of the items\n         * that were added; the second argument is all of\n         * the items that match any currently applied\n         * filter.\n         * @example\n         * var item1 = {state: 'AZ', value: 123},\n         *     item2 = {state: 'NY', value: 456},\n         *     list = new ModelList(item1, item2);\n         * list.filter({'state': 'NY'});\n         * var item3 = {state: 'CA', value: 789},\n         *     item4 = {state: 'NY', value: 012};\n         * list.on('items-added', function(e){\n         *     expect(e.args[0]).toEqual([item3, item4]);\n         *     expect(e.args[1]).toEqual([item4]);\n         * });\n         * list.add(item3, item4);\n         */\n\n        /**\n         * @event paychex.core.ModelList#items-removed\n         * @desc\n         * Triggered automatically when items are removed\n         * from the underlying collection. Callbacks will\n         * receive an array containing the removed item(s).\n         * @example\n         * var item1 = {state: 'AZ', value: 123},\n         *     item2 = {state: 'NY', value: 456},\n         *     list = new ModelList(item1, item2);\n         * list.on('items-removed', function(e){\n         *     expect(e.args[0]).toEqual([item1]);\n         * });\n         * list.remove(item1);\n         */\n\n        /**\n         * @event paychex.core.ModelList#filter-changed\n         * @desc Triggered automatically when the filter method has changed.\n         * @example\n         * var list = new ModelList(1, 2, 3),\n         *     isGT1 = function(num){\n         *         return num > 1;\n         *     };\n         * list.on('filter-changed', function(){\n         *     log('the filter has changed');\n         * });\n         * list.filterBy(isGT1); // triggers the filter-changed event\n         */\n\n        /**\n         * @event paychex.core.ModelList#sort-changed\n         * @desc Triggered automatically when the sort method has changed.\n         * @example\n         * var list = new ModelList(2, 1, 3);\n         * list.on('sort-changed', function(){\n         *     log('the sort has changed');\n         * });\n         * list.sortBy(_.identity); // triggers the sort-changed event\n         */\n\n        /**\n         * @event paychex.core.ModelList#grouping-changed\n         * @desc Triggered automatically when the grouping method has changed.\n         * @example\n         * var list = new ModelList(\n         *     {state: 'AZ', value: 123},\n         *     {state: 'NM', value: 456},\n         *     {state: 'AZ', value: 789}\n         * );\n         * list.on('grouping-changed', function(){\n         *     log('the grouping has changed');\n         * });\n         * list.groupBy('state'); // triggers the grouping-changed event\n         */\n\n        /**\n         * @event paychex.core.ModelList#selection-changed\n         * @desc Triggered automatically when the selected items have changed.\n         * The first argument to any callbacks will be an array containing the\n         * newly selected items and the previous selection.\n         *\n         * **IMPORTANT:** The second argument does *not* represent items to\n         * deselect -- it represents the previously selected items, which could\n         * of course contain some of the newly selected items.\n         *\n         * For this reason, if you want to \"deselect\" items based on the\n         * selection-changed event, see the second example below.\n         * @example\n         * var items = [\n         *         {state: 'AZ', value: 123},\n         *         {state: 'NM', value: 456},\n         *         {state: 'AZ', value: 789}\n         *     ], list = new ModelList(items);\n         * list.on('selection-changed', function(e){\n         *     log(e.args[0]); // [{state: 'AZ', value: 123}];\n         * });\n         * list.setSelected(items[0]); // triggers the selection-changed event\n         * @example\n         * list.on('selection-changed', function(e) {\n         *\n         *   var newSelection = e.args[0],\n         *       oldSelection = e.args[1];\n         *\n         *   // because an item could exist in both\n         *   // lists, deselecting should come first:\n         *   _.forEach(oldSelection, function(item) {\n         *       // update UI by \"deselecting\" item\n         *   });\n         *\n         *   // and selecting should come last:\n         *   _.forEach(newSelection, function(item) {\n         *       // update UI by \"selecting\" item\n         *   });\n         *\n         * });\n         */\n\n        /**\n         * @event paychex.core.ModelList#active-changed\n         * @desc Triggered automatically when the active item has changed.\n         * The first argument to any callbacks will be the newly activated item.\n         * @example\n         * var items = [\n         *         {state: 'AZ', value: 123},\n         *         {state: 'NM', value: 456},\n         *         {state: 'AZ', value: 789}\n         *     ], list = new ModelList(items);\n         * list.on('active-changed', function(e){\n         *     log(e.args[0]); // the newly active item\n         * });\n         * list.setActive(items[0]); // triggers the active-changed event\n         * list.moveNext(); // also triggers the active-changed event\n         */\n\n        /**\n         * @event paychex.core.ModelList#collection-changed\n         * @desc Triggered automatically when the ModelList's underlying collection\n         * is changed (for example, by calling [add](#add) or [remove](#remove), or\n         * when a filter, grouping, or sort function is applied). Callbacks receive\n         * no arguments, but can call [getItems](#getItems) to retrieve the currently\n         * visible items in the ModelList.\n         * @example\n         * var list = new ModelList(1, 2, 3);\n         * list.on('collection-changed', function(){\n         *     log('the collection has been modified');\n         * });\n         * list.add(4, 5, 6); // triggers 'collection-changed'\n         * list.remove(3, 5); // also triggers 'collection-changed'\n         */\n\n        var self = this,\n\n            myId = _.uniqueId(),\n\n            activeItem = null,\n            lastActiveIndex = -1,\n            ignoredGroup = '\\0',\n\n            EMPTY = 0,\n            FIRST_INDEX = 0,\n            LAST_INDEX = 1,\n            MIN_SORT_ARITY = 2,\n            EQUAL_VALUES = 0,\n            META_KEY = '__',\n\n            fnValueOf = null,\n            fnDefaultSort = _.constant(EQUAL_VALUES),\n            fnDefaultGroup = _.constant(ignoredGroup),\n            fnDefaultFilter = _.constant(true),\n\n            fnSort = fnDefaultSort,\n            fnGroup = fnDefaultGroup,\n            fnFilter = fnDefaultFilter,\n\n            groupings = {},\n\n            meta = {},\n            allItems = [],\n            currentItems = [],\n            selectedItems = [],\n\n            internal = {\n\n                getObjMeta: function getObjectMeta(obj) {\n                    var key;\n                    if (_.isObject(obj)) {\n                        obj[META_KEY] = obj[META_KEY] || {};\n                        obj[META_KEY][myId] = obj[META_KEY][myId] || {};\n                        return obj[META_KEY][myId];\n                    } else {\n                        key = _.hash(obj);\n                        meta[key] = meta[key] || {};\n                        return meta[key];\n                    }\n                },\n\n                removeObjMeta: function removeObjectMeta(obj) {\n                    if (_.isObject(obj) && !!obj[META_KEY] && !!obj[META_KEY][myId]) {\n                        delete obj[META_KEY][myId];\n                    } else {\n                        delete meta[_.hash(obj)];\n                    }\n                },\n\n                assignValueOf: function assignValueOf(items) {\n                    _.forEach(_.filter(items || allItems, function isObject(item) {\n                        return item instanceof Object;\n                    }), function assignMethod(item) {\n                        var objMeta = internal.getObjMeta(item);\n                        objMeta.origValueOf = objMeta.origValueOf || item.valueOf;\n                        item.valueOf = fnValueOf || objMeta.origValueOf;\n                    });\n                },\n\n                getNewGroup: function getNewGroup(arr) {\n                    var result = new ModelList(arr);\n                    self.on('items-removed', function itemsRemoved(e) {\n                        // must be a bug in lodash -- docs say invokeMap can be chained,\n                        // but the method is never invoked using the chaining syntax:\n                        // NO LONGER WORKS: Utils(groupings).values().invokeMap('remove', e.args);\n                        _.invokeMap(_.values(groupings), 'remove', e.args);\n                        internal.removeEmptyGroups();\n                    });\n                    self.on('selection-changed', function selectionChanged(e) {\n                        // must be a bug in lodash -- docs say invokeMap can be chained,\n                        // but the method is never invoked using the chaining syntax:\n                        // NO LONGER WORKS: Utils(groupings).values().invokeMap('setSelected', e.args);\n                        _.invokeMap(_.values(groupings), 'setSelected', e.args);\n                    });\n                    result.on('items-added, items-removed', internal.handleItemsChange);\n                    return result;\n                },\n\n                handleItemsChange: function handleItemsChange(e) {\n                    self[e.key === 'items-added' ? 'add' : 'remove'](e.args[0]);\n                },\n\n                removeEmptyGroups: function removeEmptyGroups() {\n                    groupings = _.omitBy(groupings, function isEmpty(list) {\n                        return _.isEqual(list.getSize(), EMPTY);\n                    });\n                },\n\n                mergeFiltered: function mergeFiltered(items) {\n                    currentItems = currentItems.concat(\n                        _.filter(items, fnFilter));\n                },\n\n                reApplyGroup: function reApplyGroup(items) {\n\n                    var groups = _.groupBy(items || allItems, fnGroup);\n\n                    _.forOwn(groups, function updateItemGroups(arr, group) {\n\n                        _.forEach(_.filter(arr, function hasNewGroup(item) {\n                            return internal.getObjMeta(item).group !== group;\n                        }), function removeFromPreviousGroups(item) {\n\n                            var itemMeta = internal.getObjMeta(item);\n                            itemMeta.prevGroup = itemMeta.group;\n                            itemMeta.group = group !== ignoredGroup ? group : null;\n\n                            if (itemMeta.prevGroup) {\n                                _.forEach(itemMeta.prevGroup.split(','), function removeFromPreviousGroup(prev) {\n                                    var groupName = prev.trim();\n                                    if (groupings.hasOwnProperty(groupName)) {\n                                        groupings[groupName].pause();\n                                        groupings[groupName].remove(item);\n                                        groupings[groupName].resume();\n                                    }\n                                });\n                            }\n\n                        });\n\n                        if (group === ignoredGroup) {\n                            return;\n                        }\n\n                        _.forEach(group.split(','), function addItemToGroups(g) {\n\n                            var groupName = g.trim();\n\n                            if (!groupings.hasOwnProperty(groupName)) {\n                                groupings[groupName] = internal.getNewGroup(arr);\n                            } else {\n                                groupings[groupName].add(arr);\n                            }\n\n                            groupings[groupName]\n                                .sortBy(fnSort)\n                                .filterBy(fnFilter);\n\n                        });\n\n                    });\n\n                    internal.removeEmptyGroups();\n\n                },\n\n                doCorrectSort: function doCorrectSort(incoming) {\n                    if (Validator.isFunction(fnSort, MIN_SORT_ARITY)) {\n                        return incoming.sort(fnSort);\n                    } else {\n                        return _.sortBy(incoming, fnSort);\n                    }\n                },\n\n                reApplySort: function reApplySort() {\n                    currentItems = internal.doCorrectSort(currentItems);\n                },\n\n                reApplyFilter: function reApplyFilter() {\n                    currentItems = _.filter(allItems, fnFilter);\n                    if (fnSort !== fnDefaultSort) {\n                        internal.reApplySort();\n                    }\n                },\n\n                updateSelectedItemsIfNecessary: function updateSelectedItemsIfNecessary() {\n                    selectedItems = _.intersection(selectedItems, allItems);\n                },\n\n                updateActiveItemIfNecessary: function updateActiveItem() {\n                    var curIndex,\n                        activeIndex,\n                        newActiveItem = null;\n                    if (!_.isNull(activeItem)) {\n                        curIndex = _.indexOf(currentItems, activeItem);\n                        if (curIndex === -1) {\n                            // previous activeItem no longer in filtered list;\n                            // we need to update activeItem as close to lastActiveIndex as\n                            // possible, or set to null if no items exist in the filtered set\n                            newActiveItem = null;\n                            activeIndex = Math.min(\n                                Math.max(FIRST_INDEX, lastActiveIndex),\n                                currentItems.length - LAST_INDEX\n                            );\n                            if (activeIndex !== -1) {\n                                newActiveItem = currentItems[activeIndex];\n                            }\n                            self.setActiveItem(newActiveItem);\n                        }\n                    }\n                },\n\n                updateLastActiveIndex: function updateLastActiveIndex() {\n                    if (_.isNull(activeItem)) {\n                        lastActiveIndex = -1;\n                    } else {\n                        lastActiveIndex = _.indexOf(currentItems, activeItem);\n                    }\n                }\n\n            };\n\n        TriggerMixin.apply(self);\n\n        /**\n         * Returns the total number of items in the ModelList. If no parameter\n         * is specified, will return the number of items regardless of any\n         * filtering that may be applied. If a parameter is supplied and is\n         * truthy, only items that are in the current filter will be counted.\n         * @function paychex.core.ModelList#getSize\n         * @param {Boolean} [visibleOnly=false] Include filtered items in count?\n         * @returns {Number} The number of items in the collection.\n         * @example\n         * var items = [1, 2, 3],\n         *     list = new ModelList(items),\n         *     isOdd = function isOdd(num){\n         *         return num % 2;\n         *     };\n         * list.filterBy(isOdd);\n         * expect(list.getSize()).toBe(3); // all items\n         * expect(list.getSize(true)).toBe(2); // filtered only\n         */\n        self.getSize = function getSize(visibleOnly) {\n            return (!!visibleOnly ? currentItems : allItems).length;\n        };\n\n        /**\n         * Adds one or more items to the underlying collection, then triggers the\n         * `items-added` event with the newly added items. Ignores items that\n         * already exist in the collection as well as duplicates and null or\n         * undefined items. If a grouping method is applied, the new items will\n         * also be added to any child groups (as well as to any parent ListModel\n         * instances).\n         * @function paychex.core.ModelList#add\n         * @fires paychex.core.ModelList#items-added\n         * @fires paychex.core.ModelList#collection-changed\n         * @returns {undefined}\n         * @example\n         * var list = new ModelList();\n         * list.on('items-added', function(e){\n         *     log(e.args[0]); // all items added\n         *     log(e.args[1]); // added items that also match the filter\n         * });\n         * list.filterBy(function(item){ ... });\n         * list.add(item1); // you can add a single item...\n         * list.add([item2, item3]); // or an array of items...\n         * list.add(item4, item5, item6); // or pass items as arguments\n         * @example\n         * // the add operation is idempotent; calling it multiple times\n         * // with the same arguments has no effect:\n         * var list = new ModelList(1, 2, 3, 4, 5);\n         * list.add(4, 5, 6, 7); // 4 and 5 will NOT be added again\n         * list.getItems(); // 1, 2, 3, 4, 5, 6, 7\n         */\n        self.add = function add() {\n\n            var items = _(arguments)\n                .flattenDeep()\n                .reject(Validator.isNullOrUndefined)\n                .uniq()\n                .value();\n\n            internal.assignValueOf(items);\n            items = _.difference(items, allItems);\n\n            if (items.length > EMPTY) {\n\n                allItems = allItems.concat(items);\n\n                internal.reApplyGroup(items);\n                internal.mergeFiltered(items);\n                internal.reApplySort();\n\n                self.trigger('items-added',\n                    items, // all items that were added\n                    _.intersection(items, currentItems) // subset of items available through getItems\n                );\n\n            }\n\n        };\n\n        /**\n         * Removes the specified items from the underlying collection,\n         * then triggers the `items-removed` event, passing the removed\n         * items to any registered callbacks. If any groupings are applied,\n         * the items will also be removed from those ModelList instances,\n         * as well as from any parent ModelList of *this* instance.\n         * @function paychex.core.ModelList#remove\n         * @fires paychex.core.ModelList#items-removed\n         * @fires paychex.core.ModelList#active-changed if the previously active item was just removed\n         * @fires paychex.core.ModelList#selection-changed if one of the selected items was just removed\n         * @fires paychex.core.ModelList#collection-changed\n         * @returns {undefined}\n         * @example\n         * var list = new ModelList(item1, item2);\n         * list.on('items-removed', function(e){\n         *     log(e.args[0]); // any removed items\n         * });\n         * list.remove(item1);\n         * list.getItems(); // [item2]\n         * list.remove(item1, item2, item3);\n         * list.getItems(); // []\n         */\n        self.remove = function remove() {\n\n            var items = _(arguments)\n                .flattenDeep()\n                .uniq()\n                .value();\n\n            internal.assignValueOf(items);\n            items = _.intersection(items, allItems);\n\n            if (items.length > EMPTY) {\n\n                allItems = _.difference(allItems, items);\n                currentItems = _.difference(currentItems, items);\n                _.forEach(items, internal.removeObjMeta);\n\n                self.trigger('items-removed', items);\n\n            }\n\n        };\n\n        /**\n         * Updates any items that exist in both the current underlying\n         * collection and the incoming collection with the values in the\n         * incoming collection.\n         * @function paychex.core.ModelList#update\n         * @alias ModelList#updateItems\n         * @fires paychex.core.ModelList#items-modified\n         * @returns {undefined}\n         * @example\n         * var list = new ModelList(item1, item2);\n         * list.update(item2, item3);\n         * log(list.getItems()); // [item1, item2]\n         */\n        self.update = self.updateItems = function updateItems() {\n\n            var items = _(arguments)\n                .flattenDeep()\n                .uniq()\n                .value();\n\n            internal.assignValueOf(items);\n\n            items = _.intersection(items, allItems);\n\n            if (items.length > EMPTY) {\n\n                _.forEach([allItems, selectedItems], function processCollections(arr) {\n\n                    _.forEach(items, function replaceIfNecessary(item) {\n                        var index = _.indexOf(arr, item);\n                        if (index !== -1) {\n                            arr.splice(index, LAST_INDEX, item);\n                        }\n                        if (_.isEqual(activeItem, item)) {\n                            activeItem = item;\n                        }\n                    });\n\n                });\n\n                self.trigger('items-modified', items);\n\n            }\n\n        };\n\n        /**\n         * Modifies the underlying collection by:\n         *\n         *  - adding items that only exist in the incoming collection\n         *  - removing items that only exist in the existing collection\n         *  - updating items that exist in both collections (with values from the incoming collection)\n         * @function paychex.core.ModelList#load\n         * @alias ModelList#loadItems\n         * @fires paychex.core.ModelList#items-added if any items were added\n         * @fires paychex.core.ModelList#items-removed if any items were removed\n         * @fires paychex.core.ModelList#items-modified if any items were updated\n         * @fires paychex.core.ModelList#active-changed if the previously active item was removed\n         * @fires paychex.core.ModelList#selection-changed if one of the selected items was removed\n         * @fires paychex.core.ModelList#collection-changed if any items were added or removed\n         * @returns {undefined}\n         * @example\n         * var list = new ModelList(item1, item2);\n         * list.load(item2, item3);\n         * log(list.getItems()); // [item2, item3]\n         */\n        self.load = self.loadItems = function loadItems() {\n\n            var toAdd,\n                toRemove,\n                toUpdate,\n                items = _(arguments)\n                    .flattenDeep()\n                    .uniq()\n                    .value();\n\n            internal.assignValueOf(items);\n\n            toAdd = _.difference(items, allItems);\n            toRemove = _.difference(allItems, items);\n            toUpdate = _.intersection(items, allItems);\n\n            self.add(toAdd);\n            self.remove(toRemove);\n            self.update(toUpdate);\n\n        };\n\n        /**\n         * Removes all items from the underlying collection,\n         * then triggers the `items-removed` event, passing all removed\n         * items to any registered callbacks. If any groupings are applied,\n         * the items will also be removed from those ModelList instances,\n         * as well as from any parent ModelList of *this* instance.\n         * @function paychex.core.ModelList#removeAll\n         * @fires paychex.core.ModelList#items-removed\n         * @fires paychex.core.ModelList#active-changed if there was a previously active item\n         * @fires paychex.core.ModelList#selection-changed if there were one or more previously selected items\n         * @fires paychex.core.ModelList#collection-changed\n         * @returns {undefined}\n         * @example\n         * var list = new ModelList(item1, item2, item3);\n         * list.on('items-removed', function(e){\n         *     log(e.args[0]); // all removed items\n         * });\n         * list.getItems(); // [item1, item2, item3]\n         * list.removeAll();\n         * list.getItems(); // []\n         */\n        self.removeAll = function removeAll() {\n            self.remove(allItems);\n        };\n\n        /**\n         * Returns an array of all currently filtered items in the underlying\n         * collection (or returns all items if no filter is applied). The returned\n         * array is a shallow clone of the underlying items. That means you can modify\n         * the array without affecting the ModelList, but each *item* in the array\n         * is a direct reference to the original item in the ModelList. Any changes\n         * you make to these items will be reflected in the ModelList's collection.\n         * @returns {Array} The current items in the collection.\n         * @function paychex.core.ModelList#getItems\n         * @example\n         * var list = new ModelList(item1, item2);\n         * list.getItems(); // [item1, item2]\n         * list.add(item3);\n         * list.getItems(); // [item1, item2, item3]\n         * list.remove(item2);\n         * list.getItems(); // [item1, item3]\n         * list.filterBy(function(item){\n         *     return item === item1;\n         * });\n         * list.getItems(); // [item1]\n         * list.filterBy(null);\n         * list.getItems(); // [item1, item3]\n         */\n        self.getItems = function getItems() {\n            return _.clone(currentItems);\n        };\n\n        /**\n         * Orders the underlying collection according to the specified value,\n         * then triggers the `sort-changed` event for any registered callbacks.\n         * The value is provided to lo-dash directly, which means you can use\n         * any of the sort features that library provides. See\n         * [here](https://lodash.com/docs#sortBy) for more information.\n         * @function paychex.core.ModelList#sortBy\n         * @alias paychex.core.ModelList#orderBy\n         * @fires paychex.core.ModelList#sort-changed\n         * @param {*|undefined} newFnSort The value to pass to lo-dash to perform\n         * the actual sorting. If `null` or `undefined` is specified, the current\n         * sorting will be removed.\n         * @param {Boolean} [propagate=false] If provided and truthy, will propagate\n         * the sort value to any groupings that may be applied. By default, the\n         * sort only affects the current ModelList's collection.\n         * @returns {paychex.core.ModelList} The current ModelList instance, for chaining.\n         * @example\n         * var list = new ModelList(0, 2, 1, 4, 3);\n         * list.getItems(); // [0, 2, 1, 4, 3]\n         * list.sortBy(_.identity);\n         * list.getItems(); // [0, 1, 2, 3, 4]\n         * list.sortBy(function(num){\n         *     // order by the alphabetical name of the number\n         *     return ['zero', 'one', 'two', 'three', 'four'][num];\n         * });\n         * list.getItems(); // [4, 1, 3, 2, 0]\n         * @example\n         * // you can also use a dual-arity sort function to get access to\n         * // each set of 2 items being compared; your sort function should\n         * // return -1, 1, or 0 based on the comparison being made; see\n         * // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort\n         * var list = new ModelList(0, 2, 1, 4, 3);\n         * list.getItems(); // [0, 2, 1, 4, 3]\n         * list.sortBy(function(a, b){\n         *     if (a < b) {\n         *         return -1;\n         *     } else if (a > b) {\n         *         return 1;\n         *     }\n         *     return 0;\n         * });\n         * list.getItems(); // [0, 1, 2, 3, 4]\n         */\n        self.sortBy = self.orderBy = function sortBy(newFnSort, propagate) {\n            var newSort = newFnSort;\n            if (Validator.isNullOrUndefined(newSort)) {\n                newSort = fnDefaultSort;\n            }\n            if (fnSort !== newSort) {\n                fnSort = newSort;\n                internal.reApplySort();\n                if (!!propagate) {\n                    _.invokeMap(_.values(groupings), 'sortBy', fnSort, propagate);\n                }\n                self.trigger('sort-changed');\n            }\n            return self; // for chaining\n        };\n\n        /**\n         * Groups the underlying collection based on the value passed\n         * in, then triggers the `group-changed` event. Any existing\n         * groupings will be updated (or removed entirely if they no\n         * longer have any items). The value passed in is provided\n         * directly to lo-dash's [groupBy](https://lodash.com/docs#groupBy)\n         * method. If null or undefined is provided, all existing\n         * groupings will be removed (the ModelList's underlying\n         * collection will *not* be affected).\n         *\n         * If you specify a grouping function, and that function returns an\n         * array of values, a group will be created for each returned value,\n         * and the item will exist in both groups (not as clones, but as\n         * the same reference).\n         *\n         * **NOTE:** Although any value can be used to group the collection,\n         * all values will be converted to a string when returning the object\n         * from [getGroups()](#getGroups). See that method for more information.\n         * @function paychex.core.ModelList#groupBy\n         * @fires paychex.core.ModelList#grouping-changed\n         * @param {*|undefined} newFnGroup The value to pass to lo-dash.\n         * @returns {paychex.core.ModelList} The current ModelList instance, for chaining.\n         * @example\n         * var list = new ModelList(1, 2, 3, 4, 5),\n         *     isOdd = function isOdd(num){\n         *         return num % 2;\n         *     };\n         * list.groupBy(isOdd);\n         * var groups = list.getGroups();\n         * groups['0'].getItems(); // [2, 4]\n         * groups['1'].getItems(); // [1, 3, 5]\n         */\n        self.groupBy = function groupBy(newFnGroup) {\n            var newGroup = newFnGroup;\n            if (Validator.isNullOrUndefined(newFnGroup)) {\n                newGroup = fnDefaultGroup;\n            }\n            if (fnGroup !== newGroup) {\n                fnGroup = newGroup;\n                internal.reApplyGroup();\n                self.trigger('grouping-changed');\n            }\n            return self; // for chaining\n        };\n\n        /**\n         * Filters the underlying collection to only those elements that\n         * match the given filter value, then triggers the `filter-changed`\n         * event. The value specified will be passed directly to lo-dash's\n         * [filter](https://lodash.com/docs#filter) method. Specify `null`\n         * or `undefined` to remove any existing filter. If a truthy\n         * value is supplied for the optional `propagate` parameter, the\n         * filter will also be applied to any groupings that may be applied.\n         * @function paychex.core.ModelList#filterBy\n         * @alias paychex.core.ModelList#filter\n         * @fires paychex.core.ModelList#filter-changed\n         * @param {*|undefined} newFnFilter The value to pass to lo-dash's\n         * filter method.\n         * @param {Boolean} [propagate=false] An optional value that specifies\n         * whether to filter any child groupings using the same filter value.\n         * Default is false.\n         * @returns {paychex.core.ModelList} The current ModelList instance, for chaining.\n         * @example\n         * var list = new ModelList(1, 2, 3, 4, 5),\n         *     isOdd = function isOdd(num){\n         *         return num % 2;\n         *     };\n         * list.filterBy(isOdd);\n         * list.getItems(); // [1, 3, 5]\n         * list.filterBy(null);\n         * list.getItems(); // [1, 2, 3, 4, 5]\n         */\n        self.filterBy = self.filter = function filterBy(newFnFilter, propagate) {\n            var newFilter = newFnFilter;\n            if (Validator.isNullOrUndefined(newFnFilter)) {\n                newFilter = fnDefaultFilter;\n            }\n            if (fnFilter !== newFilter) {\n                fnFilter = newFilter;\n                internal.reApplyFilter();\n                if (!!propagate) {\n                    _.invokeMap(_.values(groupings), 'filterBy', fnFilter, propagate);\n                }\n                self.trigger('filter-changed');\n            }\n            return self; // for chaining\n        };\n\n        // in docs, note about all groups being returned, even if filter applied makes look empty\n        // also note that order cannot be guaranteed between calls or browsers\n        /**\n         * Returns an object whose keys are the current grouping values, and whose values are\n         * ModelList instances containing the items in that group. This method returns a shallow\n         * clone of the internal groupings, which means you can modify the object without affecting\n         * the ModelList's internal collection. However, each value in the returned object is a\n         * reference to the underlying ModelList child instance, so any modifications to those\n         * instances will affect this ModelList instance as well. See the example for details.\n         *\n         * **IMPORTANT:** Even if a filter is applied to a child group such that there are no visible\n         * items in that group, the group will still be returned here. If you want to exclude groups\n         * with no visible items, you will need to filter them out after calling this method:\n         *\n         *     var nonEmptyGroups = _.filter(myList.getGroups(), function(list, key){\n         *         return list.getSize(true) > 0;\n         *     });\n         *\n         * **IMPORTANT:** There are no requirements for how a particular browser implements object\n         * key ordering. For that reason, you *cannot* assume a particular order to the keys returned\n         * by this method. If you need to apply a specific sort the keys, you will have to do that\n         * after calling getGroups:\n         *\n         *     var groups = myList.getGroups(),\n         *         sortedKeys = _.sort(_.keys(groups), function(key){\n         *             // sort logic goes here\n         *         });\n         *\n         *     _.forEach(sortedKeys, function(key){\n         *         groups[key].getItems();\n         *     });\n         * @function paychex.core.ModelList#getGroups\n         * @returns {Object} A dictionary where each key is the grouped value and\n         *  each grouped value is a ModelList containing the items in that group.\n         * @example\n         * var list = new ModelList(\n         *   {state: 'AZ', value: 123},\n         *   {state: 'NY', value: 456}\n         * );\n         * list.groupBy('state');\n         * var groups = list.getGroups();\n         * groups['AZ'].getItems(); // [{state: 'AZ', value: 123}]\n         * groups['NY'].getItems(); // [{state: 'NY', value: 456}]\n         */\n        self.getGroups = function getGroups() {\n            return _.clone(groupings);\n        };\n\n        /**\n         * Returns an array of any currently selected items in the underlying collection.\n         * You can set the selected items by calling [setSelected](#setSelected). The\n         * returned array is a shallow clone, which means you can modify the array without\n         * affecting the ModelList's underlying values; however, the actual elements in the\n         * array are references to the actual values in the ModelList collection -- any\n         * modifications you make to them will be reflected in the ModelList.\n         * @function paychex.core.ModelList#getSelected\n         * @alias paychex.core.ModelList#getSelectedItems\n         * @returns {Array} The currently selected items.\n         * @example\n         * var list = new ModelList(1, 2, 3);\n         * list.setSelected(2);\n         * list.getSelected(); // [2]\n         * list.setSelected(1, 3);\n         * list.getSelected(); // [1, 3]\n         * list.setSelected(null);\n         * list.getSelected(); // []\n         */\n        self.getSelected = self.getSelectedItems = function getSelected() {\n            return _.clone(selectedItems);\n        };\n\n        /**\n         * Sets the currently selected items in the ModelList to the values specified.\n         * If a filter is applied, this method will ignore any items not currently visible\n         * in the filter.\n         * @function paychex.core.ModelList#setSelected\n         * @alias paychex.core.ModelList#setSelectedItems\n         * @fires paychex.core.ModelList#selection-changed\n         * @returns {undefined}\n         * @example\n         * var list = new ModelList(1, 2, 3, 4, 5),\n         *     isOdd = function isOdd(num){\n         *        return num % 2;\n         *     };\n         * list.filterBy(isOdd); // only odd values can be selected\n         * list.setSelected(1, 2, 3); // provide one or more arguments\n         * list.getSelected(); [1, 3]\n         * list.setSelected([1, 2]); // or specify an array\n         * list.getSelected(); [1]\n         */\n        self.setSelected = self.setSelectedItems = function setSelected() {\n\n            var trigger,\n                items = _(arguments)\n                    .flattenDeep()\n                    .intersection(currentItems)\n                    .value();\n\n            if (!_.isEqual(items, selectedItems)) {\n                trigger = _.partialRight(self.trigger, selectedItems);\n                selectedItems = internal.doCorrectSort(items);\n                trigger('selection-changed', items);\n            }\n\n        };\n\n        /**\n         * Updates the list of selected items by examining the incoming\n         * elements. If the element is not currently in the list of selected\n         * items, it will be added; if it *is* in the list, it will be\n         * removed. If called with no arguments, this function has no effect.\n         * @function paychex.core.ModelList#toggleSelected\n         * @alias ModelList#toggleSelectedItems\n         * @returns {undefined}\n         * @example\n         * var list = new ModelList(1, 2, 3, 4, 5, 6);\n         * list.setSelected(2, 4, 6);\n         * list.toggleSelected(2, 3);\n         * list.getSelected(); // [3, 4, 6]\n         */\n        self.toggleSelected = self.toggleSelectedItems = function toggleSelected() {\n\n            var toSelect,\n                toDeselect,\n                current = _.clone(selectedItems),\n                incoming = _(arguments)\n                    .flattenDeep()\n                    .intersection(currentItems)\n                    .value();\n\n            toSelect = _.difference(incoming, current);\n            toDeselect = _.intersection(current, incoming);\n\n            this.setSelected(\n                _(current)\n                    .difference(toDeselect)\n                    .union(toSelect)\n                    .value()\n            );\n\n        };\n\n        /**\n         * Returns the currently active item in the ModelList, or `null` if\n         * none was specified.\n         * @function paychex.core.ModelList#getActive\n         * @alias paychex.core.ModelList#getActiveItem\n         * @returns {*} The current active item in the collection.\n         * @example\n         * var list = new ModelList(1, 2, 3);\n         * list.setActive(2);\n         * list.getActive(); // 2\n         */\n        self.getActiveItem = self.getActive = function getActiveItem() {\n            return activeItem;\n        };\n\n        /**\n         * Sets the currently active item in the ModelList.\n         * @function paychex.core.ModelList#setActive\n         * @alias paychex.core.ModelList#setActiveItem\n         * @fires paychex.core.ModelList#active-changed\n         * @param {*} item The item in the collection to make active.\n         * @returns {undefined}\n         * @example\n         * var list = new ModelList(1, 2, 3);\n         * list.setActive(1);\n         * list.getActive(); // 1\n         * list.setActive(null);\n         * list.getActive(); // null\n         */\n        self.setActiveItem = self.setActive = function setActiveItem(item) {\n\n            var trigger,\n                newActiveItem = item;\n\n            if (_.isUndefined(newActiveItem)) {\n                newActiveItem = null;\n            }\n\n            if (newActiveItem !== activeItem && (\n                _.isNull(newActiveItem) ||\n                _.includes(currentItems, newActiveItem)\n            )) {\n                trigger = _.partialRight(self.trigger, activeItem);\n                activeItem = newActiveItem;\n                internal.updateLastActiveIndex();\n                trigger('active-changed', activeItem);\n            }\n\n        };\n\n        /**\n         * Sets the next item in the ModelList as active. Uses the currently\n         * active item as a reference, and respects any filter or sort that\n         * may be applied.\n         * @function paychex.core.ModelList#moveNext\n         * @fires paychex.core.ModelList#active-changed\n         * @param {Boolean} [wrap=false] Optional value to determine if the\n         * first item should be activated when this method is called when the\n         * last item is currently active.\n         * @returns {boolean} `true` if the next item was activated; `false`\n         * if the last item in the list was already active (and `wrap` was\n         * not `true`).\n         * @example\n         * var list = new ModelList(1, 2, 3, 4, 5);\n         * list.setActive(3);\n         * list.moveNext(); // true\n         * list.getActive(); // 4\n         * list.moveNext(); // true\n         * list.getActive(); // 5\n         * list.moveNext(); // false\n         * list.getActive(); // 5\n         * list.moveNext(true); // true\n         * list.getActive(); // 1\n         * @example\n         * // iterate through a ModelList:\n         * var list = new ModelList(3, 1, 2, 5, 4);\n         * while (list.moveNext()) {\n         *     log(list.getActive()); // outputs each item\n         * }\n         * list.setActive(); // back to start\n         */\n        self.moveNext = function moveNext(wrap) {\n\n            var newActiveItem = null;\n\n            if (self.atEnd) {\n                if (!wrap) {\n                    return false;\n                } else {\n                    lastActiveIndex = -1;\n                }\n            }\n\n            if (Validator.isNullOrUndefined(activeItem) && currentItems.length > EMPTY) {\n                newActiveItem = currentItems[FIRST_INDEX];\n            } else {\n                newActiveItem = currentItems[lastActiveIndex + LAST_INDEX];\n            }\n\n            self.setActive(newActiveItem);\n\n            return !_.isNull(activeItem);\n\n        };\n\n        /**\n         * Sets the previous item in the ModelList as active. Uses the currently\n         * active item as a reference, and respects any filter or sort that\n         * may be applied.\n         * @function paychex.core.ModelList#movePrev\n         * @alias paychex.core.ModelList#movePrevious\n         * @fires paychex.core.ModelList#active-changed\n         * @param {Boolean} [wrap=false] Optional value to determine if the\n         * last item should be activated when this method is called when the\n         * first item is currently active.\n         * @returns {boolean} `true` if the previous item was activated; `false`\n         * if the first item in the list was already active (and `wrap` was\n         * not `true`).\n         * @example\n         * var list = new ModelList(1, 2, 3, 4, 5);\n         * list.setActive(3);\n         * list.movePrev(); // true\n         * list.getActive(); // 2\n         * list.movePrev(); // true\n         * list.getActive(); // 1\n         * list.movePrev(); // false\n         * list.getActive(); // 1\n         * list.movePrev(true); // true\n         * list.getActive(); // 5\n         */\n        self.movePrev = self.movePrevious = function movePrev(wrap) {\n\n            if (self.atStart) {\n                if (!wrap) {\n                    return false;\n                } else {\n                    lastActiveIndex = currentItems.length;\n                }\n            }\n\n            self.setActive(currentItems[lastActiveIndex - LAST_INDEX]);\n\n            return !_.isNull(activeItem);\n\n        };\n\n        /**\n         * `true` if the currently active item is the first item in the list.\n         * If no item is currently active, will always return true.\n         * @member {Boolean} paychex.core.ModelList#atStart\n         * @readonly\n         * @example\n         * var list = new ModelList(1, 2, 3);\n         * list.atStart; // true\n         * list.setActive(2);\n         * list.atStart; // false\n         */\n\n        /**\n         * `true` if the currently active item is the last item in the list.\n         * If no item is current active, will always return true.\n         * @member {Boolean} paychex.core.ModelList#atEnd\n         * @readonly\n         * @example\n         * var list = new ModelList(1, 2, 3);\n         * list.atEnd; // true\n         * list.setActive(2);\n         * list.atEnd; // false\n         */\n        self.atStart = self.atEnd = true;\n\n        /**\n         * Describes the current ModelList state, including:\n         *   - the number of items\n         *   - the number of visible items (if filter applied)\n         *   - the number of groups (if grouping applied)\n         *   - if the collection is sorted (if sort applied)\n         * @function paychex.core.ModelList#toString\n         * @override\n         * @returns {string} A human-readable representation of the currently collection\n         *  length, as well as any filtering, sorting, or grouping that is applied.\n         * @example\n         * var list = new ModelList();\n         * list.toString(); // 0 items\n         * list.add(1, 2, 3);\n         * list.toString(); // 3 items\n         * list.filterBy(function(num){ return num > 1; });\n         * list.toString(); // 3 items, filtered to 2 items\n         * list.groupBy(function(num){ return num % 2; });\n         * list.toString(); // 3 items in 2 groups, filtered to 2 items\n         * list.sortBy(function(num){ return Math.sin(num); });\n         * list.toString(); // 3 items in 2 groups, filtered to 2 items, sorted\n         */\n        self.toString = function toString() {\n            var result = self.getSize() + ' items';\n            if (fnGroup !== fnDefaultGroup) {\n                result += ' in ' + _.keys(groupings).length + ' groups';\n            }\n            if (fnFilter !== fnDefaultFilter) {\n                result += ', filtered to ' + self.getItems().length + ' items';\n            }\n            if (fnSort !== fnDefaultSort) {\n                result += ', sorted';\n            }\n            return result;\n        };\n\n        /**\n         * Attaches a valueOf function to each element in the collection. Coupled\n         * with the Utils wrapper for lodash, this allows you to compare various\n         * objects according to the specific criteria you specify (instead of the\n         * default reference equality checks).\n         *\n         * **IMPORTANT:** Your valueOf callback will be invoked multiple times by\n         * lodash when certain operations are performed. For example, adding an item\n         * to the collection will automatically re-evaluate any filter, grouping, and\n         * sorting functions that have been applied, all of which will invoke any valueOf\n         * callback multiple times for each item in the collection. For this reason, you\n         * should make your valueOf function as simple and efficient as possible.\n         * @function paychex.core.ModelList#setValueOf\n         * @returns {paychex.core.ModelList} The current ModelList instance, for chaining.\n         * @param {Function|*} fnNewValueOf The new valueOf function to attach to\n         *  each item in the collection. If a non-function is specified, any original\n         *  valueOf function will be restored.\n         * @fires paychex.core.ModelList#value-of-changed\n         * @example\n         * var item1 = {id: 1, key: 'value'},\n         *     item2 = {id: 2, key: 'value'},\n         *\n         *     // item3 has the same id as item1 but is not the same object:\n         *     item3 = {id: 1, key: 'some-other-value', key2: 'not in original'}\n         *\n         *     // we start by adding items 1 and 2 to the collection:\n         *     list = new ModelList(item1, item2);\n         *\n         * list.setValueOf(function(){\n         *   // `this` is the item in the collection:\n         *   return this.id; // returns 1 for item1 and 2 for item2\n         * });\n         *\n         * list.getItems(); // [item1, item2]\n         * list.add(item3);\n         * list.getItems(); // [item1, item2]\n         * // item3 was not added because id 1 is already in the collection\n         *\n         * list.update(item3);\n         * list.getItems(); // [item3, item2]\n         * // item3 took the place of item1 because the id was the same\n         */\n        self.setValueOf = function setValueOf(fnNewValueOf) {\n\n            var newValueOf = fnNewValueOf;\n            if (!Validator.isFunction(newValueOf)) {\n                newValueOf = null;\n            }\n\n            if (fnValueOf !== newValueOf) {\n                fnValueOf = newValueOf;\n                internal.assignValueOf();\n                // propagate to any child groups automatically\n                _.invokeMap(_.values(groupings), 'setValueOf', fnValueOf);\n                self.trigger('value-of-changed');\n            }\n\n            return self; // for chaining\n\n        };\n\n        /* begin event handlers */\n\n        self.on('sort-changed', internal.updateLastActiveIndex);\n\n        self.on('filter-changed, collection-changed', internal.updateActiveItemIfNecessary);\n        self.on('filter-changed, collection-changed', internal.updateSelectedItemsIfNecessary);\n\n        self.on('items-added', function ensureValueOfIsAssigned(e) {\n            internal.assignValueOf(e.args[0]);\n        });\n\n        self.on(\n            'items-added, items-removed, grouping-changed, sort-changed, filter-changed',\n            function fireCollectionChanged(e) {\n                self.trigger.apply(self, ['collection-changed'].concat(e.args));\n            });\n\n        self.on('collection-changed, active-changed', function updateRangeIndices() {\n            self.atStart = lastActiveIndex <= FIRST_INDEX;\n            self.atEnd = lastActiveIndex === currentItems.length - LAST_INDEX;\n        });\n\n        self.on('items-modified', function reapplyGroupAndFilter(e) {\n\n            var items = _(e.args)\n                .flattenDeep()\n                .intersection(allItems)\n                .uniq()\n                .value();\n\n            if (items.length > EMPTY) {\n                internal.reApplyGroup(items);\n                internal.reApplyFilter(); // also re-sorts\n            }\n\n        });\n\n        /* end event handlers */\n\n        self.add(arguments);\n\n    };\n\n});\n\n","define('paychex.core/native/AppReviewHelper',[\n    'lodash',\n    'paychex.core/Errors',\n    'paychex.core/Promise',\n    'paychex.core/Validator',\n    'paychex.core/Logger',\n    'paychex.core/stores/LocalStorage',\n    'paychex.core/Tracker',\n    'paychex.core/DeviceProfile'\n], function(_,\n            Errors,\n            Promise,\n            Validator,\n            Logger,\n            LocalStorage,\n            Tracker,\n            DeviceProfile) {\n\n    'use strict';\n\n    var log = Logger.get('paychex.core.native.AppReviewHelper'),\n        STORAGE_KEY = 'paychex.native.appReview.data',\n        DEFAULT_DATA = { activities : {}, quietUntil : undefined  },\n        REVIEW_QUIET_PERIOD_IN_DAYS = 120,\n        DEFAULT_REVIEW_THRESHOLD = 3,\n        IN_QUIET_PERIOD = 'IN_QUIET_PERIOD',\n        THRESHOLD_NOT_MET = 'THRESHOLD_NOT_MET',\n        ERROR_OCCURRED = 'ERROR_OCCURRED',\n        NOT_NATIVE_DEVICE = 'NOT_NATIVE_DEVICE';\n\n    /**\n     *  Constructs a new AppReviewHelper which can be used to display review prompts to the user while adhering to the\n     *  business and app-store rules that govern how often a user is allowed to be prompted. Also supports review prompting\n     *  after a certain threshold has met for certain activities (eg. 'Prompt the user to review after they have submitted\n     *  payroll for the third time.')\n     *\n     * @param {Function} reviewHandler The function to invoke when it is determined the user should be prompted for a\n     * review. This function should return a Promise that is resolved when the user has responded to the review dialog.\n     * @constructor\n     */\n    function AppReviewHelper(reviewHandler){\n        log.trace('constructing new AppReviewHelper');\n\n        if (!Validator.isFunction(reviewHandler) ) {\n            Errors.throw(\n                Errors.Types.IllegalArgument,\n                'AppReviewHelper expects a \\'reviewHandler\\' {Function}'\n            );\n        }\n\n\n        /**\n         *\n         * @param {String} activityId The unique id for the activity which prompted this review.\n         * @param {String} userPromptString The prompt to display to the user. May be a localization key.\n         * @param {Object} options Object containing optional imageId and reviewThresholds\n         * @param {String} options.imageId The ID to load a svg image through core-ui\n         * @param {Number} options.reviewThreshold The number of times the activityId must be seen on this device before a user\n         *                  is prompted to review.\n         * @returns {Bloodhound.Promise} A promise that is resolved when the user has responded to the review prompt.\n         */\n        this.showReview = function showReview(activityId, userPromptString, options){  // eslint-disable-line\n            if (DeviceProfile.isNative()) {\n                var now = new Date().getTime(),\n                    optionals = options || {},\n                    threshold = optionals.reviewThreshold || DEFAULT_REVIEW_THRESHOLD,\n                    data = LocalStorage.get(STORAGE_KEY) || _.cloneDeep(DEFAULT_DATA);\n\n                if ( !Validator.isString(activityId, 1) ||  !Validator.isString(userPromptString, 1) ) {\n                    Errors.throw(\n                            Errors.Types.IllegalArgument,\n                            'AppReviewHelper.showReview expects an activityId {String} and userPromptString {String}'\n                        );\n                }\n\n                if(!_.isNil(optionals.reviewThreshold) && !Validator.isNumber(optionals.reviewThreshold, 1) ){\n                    Errors.throw(\n                            Errors.Types.IllegalArgument,\n                            'AppReviewHelper.showReview optional parameter optionals.reviewThreshold must be {Number} greater than 0'\n                        );\n                }\n\n                data.save = function save(){\n                    LocalStorage.set(STORAGE_KEY, this);\n                };\n\n                data.activities[activityId] = data.activities[activityId] ? ++data.activities[activityId] : 1;\n                data.save();\n                log.debug('activity count for ' + activityId + '= ' +  data.activities[activityId]);\n\n                if( data.quietUntil && (now <= data.quietUntil) ){\n                    log.debug('in quiet period, now=' + now + ' until=' + data.quietUntil);\n                    return Promise.resolve(IN_QUIET_PERIOD);\n                }else if(  data.activities[activityId] >= threshold){\n                    data.quietUntil = now + (1000 * 60 * 60 * 24 * REVIEW_QUIET_PERIOD_IN_DAYS);\n                    data.save();\n                    log.debug('invoking review strategy');\n                    return Promise.call(reviewHandler, userPromptString, optionals.imageId, activityId)\n                            .then(function determineClose(obj){\n                                /*\n                                 * .value determines how long the display will not be shown for:\n                                 *   true = 120 days\n                                 *   false = wait until the year 3000\n                                 * */\n                                if (obj.value === false) {\n                                    data.quietUntil = (new Date(3000,1)).getTime();\n                                }\n                                data.save();\n                                return obj;\n                            })\n                            .catch(Errors.rethrowAs('NativeAppReviewError', 'There was a problem displaying the review to the user'))\n                            .catch(function trackAndSwallow(e){\n                                Tracker.errors.log(e);\n                                return ERROR_OCCURRED;\n                            });\n                }else{\n                    log.debug('waiting for threshold');\n                    return Promise.resolve(THRESHOLD_NOT_MET);\n                }\n            } else {\n                log.debug('not native device');\n                return Promise.resolve(NOT_NATIVE_DEVICE);\n            }\n        };\n\n        /**\n         * Resets the stored data used by the helper. The review quiet period will be cleared and all activity hit counts\n         * will be reset.\n         */\n        this.reset = function reset(){\n            LocalStorage.remove(STORAGE_KEY);\n        };\n\n    }\n\n    AppReviewHelper.RESULTS = {\n        THRESHOLD_NOT_MET : THRESHOLD_NOT_MET,\n        IN_QUIET_PERIOD : IN_QUIET_PERIOD,\n        ERROR_OCCURRED : ERROR_OCCURRED,\n        NOT_NATIVE_DEVICE: NOT_NATIVE_DEVICE\n    };\n\n    return AppReviewHelper;\n});\n","/**\n * @author epalermo\n */\ndefine('paychex.core/native/PluginManager',[\n    'paychex.core/Utils',\n    'paychex.core/Errors',\n    'paychex.core/Promise',\n    'paychex.core/Validator',\n    'paychex.core/Eventing',\n    'paychex.core/Logger'\n], function(\n    _,\n    Errors,\n    Promise,\n    Validator,\n    Eventing,\n    Logger\n) {\n\n    'use strict';\n\n    var log = Logger.get('paychex.core.native.pluginManager');\n\n    /**\n     * Helper function to initialize a plugin (once the plugin platform is ready this function will call init() if init\n     * has been defined and then add any plugin events.\n     *\n     * @param {Object}  plugin The plugin to initialize.\n     * @param {String} pluginPlatform The plugin platform objects (needed by some init functions)\n     * @returns {Promise} A promise that is resolved when the plugin initialization completes (either successfully or in error)\n     * @private\n     */\n    function _initPlugin(plugin, pluginPlatform) {\n        /* jshint validthis:true */ // Ignore since we're using this function with .bind()\n        var self = this;\n\n        function _addPluginEvents(newPlugin) {\n            _(newPlugin.events)\n                .pickBy(_.isFunction)\n                .forOwn(function addHandler(eventSubscription, eventName) {\n                    self.addPluginEventHandler(eventName, eventSubscription.bind(newPlugin), newPlugin.id);\n                });\n        }\n\n        // Call the plugin's init if it's defined, (or call a noop).\n        // If init is successful (or if we used the noop) we will end up in initSuccess\n        return Promise.fcall(_.isFunction(plugin.init) ? plugin.init.bind(plugin, pluginPlatform) : _.noop)\n            .tap(function initSuccess() {\n                _addPluginEvents(plugin);\n            })\n            .catch(function initFailure() { // Catch any failures in the init() OR in the addPluginEvents() function.\n                log.error('Failed to initialize plugin: ' + plugin.id );\n                _.remove( self.plugins, {id: plugin.id} );\n                // Clean up if we got partially through adding events... This removes any events belonging to plugin\n                _(self.registeredEvents)\n                    .flatten()\n                    .filter( ['pluginId', plugin.id] )\n                    .forEach(function invokeUnregister(eventReg) {\n                        eventReg.unregister();\n                    });\n                return undefined; // swallow the error\n            });\n    }\n\n    /**\n     * Creates a new PluginManager.\n     *\n     * @class paychex.core.PluginManager\n     * @alias PluginManager\n     */\n    function PluginManager() {\n        this.reset();\n    }\n\n    /**\n     * Resets the PluginManager to it's initial state.\n     * @function paychex.core.PluginManager#reset\n     * @example\n     * PluginManager.reset();\n     */\n    PluginManager.prototype.reset = function reset() {\n        this.eventBroker = Eventing.makeNewEventBroker('paychex.native.plugin.eventChannel');\n        this.plugins = [];\n        _.invokeMap(_.flatMap(this.registeredEvents), 'unregister');\n        this.registeredEvents = {};\n        this.pluginPlatformReady = Promise.defer();\n        this.pendingEvents = [];\n    };\n\n    /**\n     * Registers a plugin with the plugin manager. Calls init() when the plugin platform is registered and adds\n     * event registrations for the event descriptions in the plugin registration object.\n     *\n     * @function paychex.core.PluginManager#registerPlugin\n     * @param {Object} plugin The plugin to register.\n     * @example\n     *  PM.registerPlugin({\n     *      id: 'my-plugin',\n     *      init: function(){\n     *          if( window.myPlugin ){\n     *              log.info('my-plugin initialized');\n     *          }else{\n     *              Errors.throw('my-plugin failed to initialize. myPlugin not found on window.');\n     *          }\n     *      },\n     *      events: {\n     *          'getFooEvent' : function(payload){\n     *              return new Promise(function(resolve){\n     *                  window.myPlugin.getFoo( function successCallback(r){\n     *                      payload.foo = r;\n     *                      resolve();\n     *                  }, function failureCallback(e){\n     *                      payload.failed = true;\n     *                      resolve();\n     *                  });\n     *              }\n     *          },\n     *          'setBarEvent' : function(payload){\n     *              return new Promise(function(resolve){\n     *                  var valueToSet = payload.value;\n     *                  window.myPlugin.setBar( valueToSet, function successCallback(r){\n     *                      payload.success = true;\n     *                      resolve();\n     *                  }, function failureCallback(e){\n     *                      payload.success = false;\n     *                      resolve();\n     *                  });\n     *              }\n     *          }\n     *      }\n     *  });\n     *  @returns {Promise} A promise that is resolved when the plugin has been registered.\n     */\n    PluginManager.prototype.registerPlugin = function registerPlugin( plugin ) {\n        var self = this;\n\n        if ( !_.isObject(plugin) || !plugin.id ) {\n            Errors.throw(\n                Errors.Types.IllegalArgument,\n                'PluginManager.registerPlugin expects a plugin object with an id property'\n            );\n        }\n\n        if ( this.isPluginRegistered(plugin.id) ) {\n            Errors.throw(\n                Errors.Types.Invocation,\n                'PluginManager.registerPlugin received duplicate plugin registration.'\n            );\n        }\n\n        this.plugins[this.plugins.length] = plugin;\n\n        // Wait for the plugin platform (native plugin code) to be ready before we initalize plugins\n        return this.pluginPlatformReady.promise.then(function platformReady(pluginPlatform) {\n            return _initPlugin.call(self, plugin, pluginPlatform);\n        });\n    };\n\n    /**\n     * Fires a plugin event for all registered plugin event handlers to process. If there are no registered event handlers\n     * and failIfNoEventRegistered is false then the PluginManager will queue the event until a handler for the event topic\n     * is registered.\n     *\n     * @function paychex.core.PluginManager#firePluginEvent\n     * @param {String} event The name of the plugin event to announce.\n     * @param {Object} payload The payload object which will be passed to the each subscribed event handler.\n     * @param {Boolean} failIfNoEventRegistered If true, this function will throw an exception if no event handler for the given\n     * name has been registered.\n     * @returns {Promise} A promise which will be resolved when all of the registered event handlers have processed the event.\n     *\n     * @example\n     *  var payload = { dividend: 14, divisor: 2};\n     *  PluginManager.firePluginEvent( 'divideEvent', payload ).then(function(payload){\n     *       log.info(payload.quotient);\n     *  }).catch().done();\n     *\n     */\n    PluginManager.prototype.firePluginEvent = function fireEvent(event, payload, failIfNoEventRegistered) {\n        var self = this,\n            deferredEventFire = Promise.defer();\n\n        if ( failIfNoEventRegistered && !this.isPluginEventRegistered(event) ) {\n            return Promise.reject(Errors.get(\n                Errors.Types.Invocation,\n                'PluginManager.firePluginEvent attempted to fire an event which has not been registered and' +\n                ' failIfNoEventRegistered was true.'));\n        }\n\n        // If there are no listeners for this event topic then we return a promise to the caller which we will fulfil as\n        // soon as someone registers an event handler for this topic.\n        if (  !this.isPluginEventRegistered(event) ) {\n            this.pendingEvents.push({\n                topic: event,\n                defer: deferredEventFire\n            });\n\n            return deferredEventFire.promise.then(function eventRegistered() {\n                // Someone has registered for our event so we announce it now and return to the waiting caller\n                return self.eventBroker.announce('paychex.native.PluginManager', event, payload).then(_.property('payload'));\n            });\n        } else {\n            return this.eventBroker.announce('paychex.native.PluginManager', event, payload).then(_.property('payload'));\n        }\n    };\n\n    /**\n     * @typedef {Object} paychex.core.PluginManager~PluginEventSubscription\n     * @property  unregister {function} The unregister function, used to remove the subscription.\n     * @property  pluginId {String} The id of the plugin.\n     * @property eventTopic {String} The name of the event.\n     */\n\n    /**\n     * Adds a handler for the given event name. The handler will be invoked when the PluginManager.firePluginEvent() is invoked\n     * with a matching event name.\n     *\n     * @function paychex.core.PluginManager#addPluginEventHandler\n     * @param {String} eventName The name of the event to add a handler to.\n     * @param {Function} handler A function to handle the event. This function will be passed the\n     * @param {String} pluginId The id of the plugin which is adding the event handler.\n     * @returns {paychex.core.PluginManager~PluginEventSubscription} An event registration object with an unregister() function that can be invoked to remove the registration.\n     * @example\n     * PluginManager.addPluginEventHandler( 'myEvent', function(){\n     *  return new Promise(function(resolve, reject){\n     *      window.myPlugin.someAsyncTask(resolve,reject);\n     *  });\n     * }, 'my-plugin');\n     */\n    PluginManager.prototype.addPluginEventHandler = function addEventHandler( eventName, handler, pluginId ) {\n        var self = this,\n            eventRegistration,\n            MIN_LENGTH = 1;\n\n        if (!Validator.isFunction(handler) || !Validator.isString(eventName, MIN_LENGTH) ||  !Validator.isString(pluginId, MIN_LENGTH) ) {\n            Errors.throw(\n                Errors.Types.IllegalArgument,\n                'PluginManager.addPluginEventHandler expects an eventName {String}, handler {Function} and pluginId {String}'\n            );\n        }\n\n        if ( !this.registeredEvents[eventName] ) {\n            this.registeredEvents[eventName] = [];\n        }\n\n        // Create an event subscription fom the event broker\n        eventRegistration = this.eventBroker.subscribe(eventName,\n            function eventProcess(event, reject, approve) {\n                Promise.fcall(handler, event.payload )\n                    .then(approve, reject)\n                    .catch(/* swallow */)\n                    .done();\n            },\n            _.noop,\n            _.noop);\n\n        // Decorate it so we know which plugin it belongs to.\n        eventRegistration.pluginId = pluginId;\n\n        this.registeredEvents[eventName].push(eventRegistration);\n\n        // Wrap the unregister function so if anyone calls it we get a chance to clean up our internal bookkeeping.\n        eventRegistration.unregister =  _.wrap( eventRegistration.unregister, function removeRegistrationEntry( originalUnregister ) {\n            _.pull( self.registeredEvents[eventName], eventRegistration );\n            originalUnregister();\n        });\n\n        this.pendingEvents = _.filter(this.pendingEvents, function callAndRemoveAnyPendingEvents(pendingEvent) {\n            if ( eventName === pendingEvent.topic ) {\n                pendingEvent.defer.resolve();\n                return false;\n            } else {\n                return true;\n            }\n        });\n\n        return eventRegistration;\n    };\n\n    /**\n     * Checks if a plugin has been registered.\n     *\n     * @function paychex.core.PluginManager#isPluginRegistered\n     * @param {String} id The id of the plugin to check for registration.\n     * @returns {boolean} True if the plugin is registered.\n     * @example\n     * PluginManager.registerPlugin({id:'my-plugin'});\n     * PluginManager.isPluginRegistered('my-other-plugin'); //false\n     * PluginManager.registerPlugin({id:'my-other-plugin'});\n     * PluginManager.isPluginRegistered('my-other-plugin'); //true\n     */\n    PluginManager.prototype.isPluginRegistered = function isPluginRegistered( id ) {\n        return _.some(this.plugins, {id: id});\n    };\n\n    /**\n     * Returns a plugin if it has been registered.\n     *\n     * @function paychex.core.PluginManager#getPlugin\n     * @param {String} id The id of the plugin to retrieve.\n     * @returns {Object} plugin, if it exists.\n     * @example\n     * PluginManager.registerPlugin({id:'my-plugin'});\n     * PluginManager.getPlugin('my-plugin'); //actual plugin obj\n     */\n    PluginManager.prototype.getPlugin = function getPlugin( id ) {\n        return _.find(this.plugins, {id: id});\n    };\n\n    /**\n     * Checks if a handler exists for a given plugin event name.\n     *\n     * @function paychex.core.PluginManager#isPluginEventRegistered\n     * @param {String} event The plugin event name\n     * @returns {boolean} True if a handle for the given plugin name exists.\n     * @example\n     * PluginManager.isPluginEventRegistered('myPluginEvent'); //false\n     * PluginManager.addPluginEventHandler('myPluginEvent', _.noop, 'my-plugin' );\n     * PluginManager.isPluginEventRegistered('myPluginEvent'); //true\n     */\n    PluginManager.prototype.isPluginEventRegistered = function isPluginEventRegistered( event ) {\n        return this.registeredEvents[event] !== undefined && !_.isEmpty( this.registeredEvents[event] );\n    };\n\n    /**\n     * Signals that the plugin platform is ready. This will initialize any plugins that were registered prior.\n     *\n     * @function paychex.core.PluginManager#platformReady\n     * @param {Object} pluginPlatform The plugin platform object which can be used by plugins.\n     */\n    PluginManager.prototype.platformReady = function platformReady(pluginPlatform) {\n        this.pluginPlatformReady.resolve(pluginPlatform);\n    };\n\n    return new  PluginManager();\n\n});\n\n","define('paychex.core/NotificationData',['lodash'], function(_) {\n\n    'use strict';\n\n    /**\n     * @author Dan Barnes\n     * @date 2014-09-13\n     */\n\n    /**\n     * @class paychex.core.NotificationData\n     * @description Encapsulates information used by the {@link paychex.core.SubscriptionManager SubscriptionManager} component.\n     * @param {String} key The notification key.\n     * @param {Array} callbacks The subscriber callback methods.\n     * @param {Array} args The arguments passed to SubscriptionManager's {@link paychex.core.SubscriptionManager#notify notify}\n     * method.\n     */\n    return function NotificationData(key, callbacks, args) {\n\n        var canceled = false,\n            misc = !!callbacks && _.map(callbacks, 'misc');\n\n        return {\n\n            /**\n             * @member {String} paychex.core.NotificationData#key\n             * @description The key used to notify subscribers.\n             * @readonly\n             */\n            key: key,\n\n            /**\n             * @member {Array} paychex.core.NotificationData#args\n             * @description Any arguments passed to SubscriptionManager's {@link\n             * SubscriptionManager#notify notify} method.\n             * @readonly\n             */\n            args: args,\n\n            /**\n             * @member {Array} paychex.core.NotificationData#callbacks\n             * @description All of the callback methods being notified.\n             * @readonly\n             */\n            callbacks: callbacks || [],\n\n            /**\n             * @member {Array} paychex.core.NotificationData#misc\n             * @description An array of any optional data passed to NotificationManager's\n             * {@link SubscriptionManager#add add} method.\n             * @readonly\n             */\n            misc: misc || [],\n\n            /**\n             * @function paychex.core.NotificationData#cancel\n             * @description Invoke this method to cancel the notification of other subscribers.\n             * @returns {undefined}\n             */\n            cancel: function() {\n                canceled = true;\n            },\n\n            /**\n             * @function paychex.core.NotificationData#isCanceled\n             * @description Returns `true` if the notification has been canceled; otherwise, returns `false`.\n             * @returns {Boolean} Whether the current notification has been canceled.\n             */\n            isCanceled: function() {\n                return canceled;\n            }\n\n        };\n\n    };\n\n});\n\n","define('paychex.core/PaychexError',['lodash'], function(_) {\n\n    'use strict';\n\n    /**\n     * @author: dbarnes1\n     * Email: dbarnes1@paychex.com\n     * Date: 2015-05-18\n     */\n\n    var readwrite = {\n        writable: true,\n        enumerable: true,\n        configurable: true\n    };\n\n    /**\n     * @class paychex.core.PaychexError\n     * @param {String} [message] An optional message to describe the error.\n     * @constructor\n     */\n    function PaychexError(message) {\n        this.name = 'PaychexError';\n        this.message = message;\n    }\n\n    /**\n     * @function paychex.core.PaychexError~formatError\n     * @private\n     * @returns {*} A string with the Error instance name and description.\n     */\n    function formatError() {\n\n        // jshint -W040\n        /* eslint \"no-restricted-syntax\": [0] */\n        // stolen from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/toString\n\n        var msg,\n            name,\n            obj = Object(this);\n\n        if (obj !== this) {\n            throw new TypeError();\n        }\n\n        name = this.name;\n        name = (name === undefined) ? 'Error' : String(name);\n\n        msg = this.message;\n        msg = (msg === undefined) ? '' : String(msg);\n\n        if (name === '') {\n            return msg;\n        }\n\n        if (msg === '') {\n            return name;\n        }\n\n        return name + ': ' + msg;\n\n    }\n\n    /**\n     * @member paychex.core.PaychexError.Severity\n     * @type {{NONE: string, ERROR: string, FATAL: string}}\n     * @description The error level associated with this exception.\n     * The default error level is ERROR.\n     */\n    PaychexError.Severity = {\n        NONE: 'NONE',\n        ERROR: 'ERROR',\n        FATAL: 'FATAL'\n    };\n\n    /* eslint \"lodash/prefer-lodash-method\": [2, {\"ignoreMethods\": [\"create\"]}] */\n    PaychexError.prototype = Object.create(Error.prototype, {\n\n        /**\n         * The name of the error. This typically corresponds to the\n         * error class and so is typically set to 'PaychexError'. If\n         * you create any custom error types (see the\n         * {@link paychex.core.Errors}.throw method), this will be\n         * set to the type name.\n         * @member {String} paychex.core.PaychexError#name\n         * @default PaychexError\n         */\n        name: readwrite,\n\n        /**\n         * A string representation of the execution context/call stack\n         * at the time the error was thrown.\n         * @member {String} paychex.core.PaychexError#stack\n         */\n        stack: readwrite,\n\n        /**\n         * A message with information about what caused the error.\n         * @member {String} paychex.core.PaychexError#message\n         */\n        message: readwrite,\n\n        /**\n         * If this error was caused by another error (e.g. a catch\n         * handler rethrew the original error), then the causedBy\n         * value will be set to the original error.\n         * @member {Error} paychex.core.PaychexError#causedBy\n         * @default undefined\n         */\n        causedBy: readwrite,\n\n        /**\n         * The severity level associated with this error instance. A severity\n         * level of FATAL will result in an immediate CUE.\n         * @member {String} paychex.core.PaychexError#severity\n         * @default paychex.core.PaychexError.Severity.ERROR\n         */\n        severity: {\n            writable: true,\n            enumerable: true,\n            configurable: false,\n            value: PaychexError.Severity.ERROR\n        }\n\n    });\n\n    PaychexError.prototype.name = 'PaychexError';\n    PaychexError.prototype.constructor = PaychexError;\n    PaychexError.prototype.toString = function toString() {\n\n        var result = formatError.call(this),\n            causedBy = this.causedBy;\n\n        if (!!causedBy) {\n            result += '\\n\\tcaused by: ';\n            result += causedBy.toString();\n        }\n\n        return result;\n\n    };\n\n    if (!('toJSON' in Error.prototype)) {\n        /* eslint \"no-extend-native\": 0 */\n        Error.prototype.toJSON = function toJSON() {\n            return _.reduce(this, function copy(result, value, key) {\n                result[key] = value;\n                return result;\n            }, {});\n        };\n    }\n\n    window.PaychexError = PaychexError;\n\n    return PaychexError;\n\n});\n\n","define('paychex.core/ProgressServiceFactory',[\n    'lodash',\n    'lib.rxjs',\n    'paychex.core/Promise',\n    'paychex.core/Validator',\n    'paychex.core/Errors'\n], function(\n    _,\n    Rx,\n    Promise,\n    Validator,\n    Errors\n) {\n\n    /**\n     * @author: epalermo\n     * @author: dbarnes1\n     * Date: 2016-10-18\n     */\n\n    'use strict';\n\n    var EMPTY = 0,\n        defaultPayload = {\n            saving: {totalInProgress: 0},\n            loading: {totalInProgress: 0},\n            processing: {totalInProgress: 0}\n        };\n\n    /**\n     * Invoke this method to create a new ProgressService instance.\n     * @function paychex.core.ProgressServiceFactory\n     * @param {paychex.core.Eventing} broker The event broker to use to fire\n     *  progress change events.\n     * @param {Function} [batchScheduler] An optional scheduler to use to\n     *  batch progress notification announcements. The default scheduler\n     *  is setTimeout, which means any notifications requested within a single\n     *  frame will be sent in one announcement.\n     * @returns {paychex.core.ProgressService}\n     * @example\n     * // create a generic ProgressService using the default event broker\n     * var broker = Eventing.makeNewEventBroker();\n     * var progress = ProgressServiceFactory(broker);\n     * progress.loading.registerActivity('sub-category', someLongRunningOperation());\n     * @example\n     * // create a ProgressService whose announcements go through a specific broker\n     * // and that uses requestImmediate to announce progress changes at the end of\n     * // the current frame\n     * var broker = Eventing.makeNewEventBroker('progress-changes');\n     * var progress = ProgressServiceFactory(broker, requestImmediate);\n     * progress.whenFree().then(function noBlockingTasks() { ... });\n     * @example\n     * // create an Angular wrapper ProgressService that uses rAF for progress change announcements\n     * angular.module('MyProgressModule', ['paychex.framework.angular.eventing'])\n     *   .factory('ProgressService', ['EventingService', function createInstance(EventingService) {\n     *     return ProgressServiceFactory(EventingService, requestAnimationFrame);\n     *   }]);\n     */\n\n    return function ProgressServiceFactory(broker, batchScheduler) {\n\n        var scheduler = _.isFunction(batchScheduler) && batchScheduler || setTimeout,\n            activities = [],\n            activities$ = new Rx.Subject(),\n            deferBlocking = Promise.defer(),\n\n            api = {whenFree: function whenFree() {\n                return deferBlocking.promise;\n            }};\n\n        deferBlocking.resolve();\n\n        /**\n         * This method ensures multiple calls to a function are only invoked once (with\n         * the arguments passed to the most recent invocation) using the scheduler\n         * specified in the factory constructor.\n         * @param {Function} fn The function to debounce one frame.\n         * @returns {undefined}\n         * @private\n         * */\n        function debounceOneFrame(fn) {\n            var isPending = false,\n                operation = _.spread(fn);\n            return function debouncedInvoker() {\n                var args = arguments;\n                if (!isPending) {\n                    isPending = true;\n                    scheduler(function invokeOnce() {\n                        _.attempt(operation, args);\n                        isPending = false;\n                    });\n                }\n            };\n        }\n\n        /**\n         * Announce the current progress status to any listeners.\n         * @param {Array} activeTasks The currently active tasks.\n         * @returns {undefined}\n         */\n        function announceUpdates(activeTasks) {\n            /*\n             *  {\n             *      'saving' : {\n             *          'subCategory' : 1,\n             *          'totalInProgress' : 1\n             *      },\n             *      'loading' : {\n             *          'totalInProgress' : 0\n             *      },\n             *      'processing' : {\n             *          'totalInProgress' : 0\n             *      },\n             *      'totalInProgress' : 1\n             *  }\n             */\n            var payload = _(activeTasks)\n                .groupBy('category')\n                .mapValues(function convertCategoryActivities(items) {\n                    return _(items)\n                        .countBy('subCategory')\n                        .merge({totalInProgress: items.length})\n                        .value();\n                })\n                .defaults(defaultPayload, {totalInProgress: activeTasks.length})\n                .value();\n            broker.announce('ProgressService', 'png.eventing.progressService.progressUpdate', payload);\n        }\n\n        /**\n         * Either create a defer or resolve the previous one so anyone waiting for\n         * blocking tasks to complete can proceed.\n         * @param {Number} prev The previous number of active tasks.\n         * @param {Number} curr The current number of active tasks.\n         * @returns {undefined}\n         */\n        function updateBlockingStatus(prev, curr) {\n            if (prev === EMPTY && curr > EMPTY) {\n                deferBlocking = Promise.defer();\n            } else if (curr === EMPTY && prev > EMPTY) {\n                deferBlocking.resolve();\n            }\n        }\n\n        // re-use the activities observer to both announce progress\n        // changes and to update our blocking status\n        activities$.subscribe(debounceOneFrame(announceUpdates));\n\n        /* eslint \"lodash/prefer-lodash-method\": [2, {\"ignoreObjects\": [\"[\\w\\_]+\\$\"]}] */\n        activities$.startWith([])\n            .map(function getTotalBlocking(currentActivities) {\n                return _.filter(currentActivities, 'config.blocking').length;\n            })\n            .pairwise() // previous and current values\n            .subscribe(_.spread(updateBlockingStatus));\n\n        /**\n         * @class paychex.core.ProgressService\n         * @description\n         * Provides an Angular service to keep track of asynchronous \"activities\" which are occurring within the Angular\n         * application. Promises are registered with the service and are monitored for completion. The service broadcasts\n         * updates to the rest of the application as new promises are registered and existing promises are resolved.\n         * Subscribers to the \"progress update events\" can then update their state based on the number & category of\n         * in-progress activities.\n         * @example\n         * ProgressService.loading.registerActivity('my-activity-namespace', myActivityPromise)\n         * @example\n         * ProgressService.processing.registerActivity('my-blocking-task', myBlockingPromise, {blocking: true});\n         * ProgressService.whenFree().then(function allBlockingTasksResolved() {\n         *     // do stuff here\n         * });\n         */\n\n        /**\n         * @callback paychex.core.ProgressService~RegisterActivity\n         * @description\n         *  Registers an activity to a subcategory within the Loading category.\n         * @param {String} subCategory The specific subcategory or progress namespace to track the activity under.\n         * @param {Promise} promise A promise representing the asynchronous activity to track.\n         * @param {Object} [config] Optional configuration object to specify whether the task is blocking.\n         * @returns {Promise} The promise that was originally passed in.\n         */\n\n        /**\n         * @typedef {Object} paychex.core.ProgressService~ActivityCategory\n         * @description One of the available sub-categories of activities that can be registered.\n         * @property {paychex.core.ProgressService~RegisterActivity} registerActivity Method to register a long-running activity for this category.\n         */\n\n        /**\n         * @member {paychex.core.ProgressService~ActivityCategory} paychex.core.ProgressService#loading\n         * @example\n         * ProgressService.loading.registerActivity('my-blocking-task', myBlockingPromise, {blocking: true});\n         */\n\n        /**\n         * @member {paychex.core.ProgressService~ActivityCategory} paychex.core.ProgressService#processing\n         * @example\n         * return ProgressService.processing.registerActivity('my-processing-task', myProcessingPromise)\n         *   .then(function processingComplete() {\n         *      // do stuff here\n         *   });\n         */\n\n        /**\n         * @member {paychex.core.ProgressService~ActivityCategory} paychex.core.ProgressService#saving\n         * @example\n         * ProgressService.saving.registerActivity('my-saving-task', mySavingPromise).done();\n         */\n\n        _.forEach(['loading', 'saving', 'processing'], function addRegisterMethod(category) {\n            api[category] = {registerActivity: function registerActivity(subCategory, promise, config) {\n\n                if (!Validator.isTypeMatch([subCategory, promise, config], ['string', 'object', 'pojo?'])) {\n                    Errors.throw(Errors.Types.IllegalArgument, 'Method `registerActivity` expects a string, a promise, and an optional configuration object.');\n                }\n\n                /* eslint \"vars-on-top\": 0 */\n                var activity = {\n                    config: category === 'saving' && _.merge(config, {blocking: true}) || config,\n                    promise: promise,\n                    category: category,\n                    subCategory: subCategory\n                };\n\n                activities.push(activity);\n                activities$.onNext(activities);\n\n                promise.finally(function removeCompletedActivity() {\n                    _.pull(activities, activity);\n                    activities$.onNext(activities);\n                });\n\n                return promise;\n\n            }};\n        });\n\n        return api;\n\n    };\n\n});\n\n","define('paychex.core/Promise',[\n    'lodash',\n    'lib.bloodhound',\n    'paychex.core/Errors',\n    'paychex.core/Prototypes' // for Function.bind\n], function(\n    _,\n    Promise,\n    Errors\n) {\n\n    'use strict';\n\n    /**\n     * @class paychex.core.Promise\n     * @description Ensures a consistent Paychex API regardless of which Promise implementation is used.\n     */\n\n    var UNDERLYING_VALUE_KEY = '_data',\n        proto = Object.getPrototypeOf(Promise.resolve());\n\n    proto.$$state = { status: 0 };\n\n    /**\n     * Sets the internal async scheduler used by the promise implementation.\n     * @function paychex.core.Promise.setScheduler\n     * @param {Function} async\n     * @throws Method `setScheduler` expects parameter `async` to be a function.\n     * @example\n     * // synchronize promise resolution to the Angular digest cycle\n     * define([\n     *     'angular',\n     *     'paychex.core/Promise'\n     * ], function(\n     *     angular,\n     *     Promise\n     * ) {\n     *     return angular.\n     *         module('async', ['ng']).\n     *         run(['$rootScope', function($rootScope) {\n     *             Promise.setScheduler($rootScope.$evalAsync.bind($rootScope));\n     *         }]);\n     * });\n     */\n    Promise.setScheduler = Promise.config.setScheduler;\n\n    /**\n     * Returns the resolved value of the promise or the rejection reason.\n     * @function paychex.core.Promise#value\n     * @alias paychex.core.Promise#getValue\n     * @returns {*} The resolved value or rejection reason.\n     */\n    proto.value = proto.getValue = function getValue() {\n        return this[UNDERLYING_VALUE_KEY];\n    };\n\n    Promise.all = _.wrap(Promise.all, function wrappedAll(origAll, promises) {\n        var keys;\n        if (_.isPlainObject(promises)) {\n            /*\n             NOTE:\n             the Angular implementation of `all` allows objects to be passed in;\n             but bloodhound uses `hash` under the hood, which acts like `settle`,\n             allowing any of the promises to be rejected; we need to examine\n             the results of `hash` and reject this promise with the first\n             rejection reason, if any is found\n             */\n            keys = _.keys(promises);\n            return origAll(_.values(promises)).then(function mapValues(values) {\n                return _.keyBy(values, function getKey(value) {\n                    return keys[values.indexOf(value)];\n                });\n            });\n        } else if (_.isEmpty(promises)) {\n            // per MDN, empty promise array should return synchronously resolved promise\n            // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all\n            return Promise.resolve([]);\n        } else {\n            return origAll(promises);\n        }\n    });\n\n    function isErrorType(type) {\n        return _.isFunction(type) && (type === Error || _.isError(type.prototype));\n    }\n\n    function isErrorTypeOnWindow(type) {\n        return _.isString(type) && isErrorType(window[type]);\n    }\n\n    function convertToErrorType(type) {\n        if (_.isError(type)) {\n            return type.constructor || Error;\n        } else if (isErrorType(type)) {\n            return type;\n        } else if (isErrorTypeOnWindow(type)) {\n            return window[type];\n        } else if (_.isString(type) && type.length) {\n            return Errors.get(type, 'temp') && window[type];\n        }\n    }\n\n    /**\n     * Allows developers to specify an optional Error type to associate with\n     * the given rejection handler. If the promise was rejected with an instance\n     * of the given error type, the handler will be invoked; otherwise, the\n     * rejection will be passed unhandled to any subsequent handlers.\n     * @function paychex.core.Promise#catch\n     * @example\n     * Promise.reject(new Error('invalid value'))\n     *   // this handler will NOT be called...\n     *   .catch(SyntaxError, function handler() { ... })\n     *   // this handler also will NOT be called...\n     *   .catch(TypeError, function handler() { ... })\n     *   // but this handler WILL be called...\n     *   .catch(Error, function handler() { ... })\n     *   // and this handler MIGHT be called, but only\n     *   // if the above handler propagated the rejection...\n     *   .catch(function handler() { ... })\n     *   .done();\n     * @example\n     * // you can also use strings that represent Error type names:\n     * myRemoteOperation()\n     *   .catch('HttpError', function handler() { ... })\n     *   .catch('RemoteOperationError', function handler() { ... })\n     *   .done();\n     * @example\n     * // common error types are available through paychex.core/Errors:\n     * myRemoteOperation()\n     *   .catch(Errors.Types.Http, function handler() { ... })\n     *   .catch(Errors.Types.RemoteOperation, function handler() { ... })\n     *   .done();\n     * @example\n     * // you can also specify multiple error types; if any type is a\n     * // match for the rejection error, the callback will be invoked:\n     * myRemoteOperation()\n     *   .catch('HttpError', 'RemoteOperationError', function handler() { ... })\n     *   .catch(function handler() { ... })\n     *   .done();\n     * @example\n     * // finally, you can also pass an array of type names:\n     * var typesToCatch = [\n     *   Errors.Types.Http,\n     *   Errors.Types.RemoteOperation\n     * ];\n     * myRemoteOperation()\n     *   .catch(typesToCatch, function handler() { ... })\n     *   .catch(function handler() { ... })\n     *   .done();\n     */\n    proto.catch = _.wrap(proto.catch, function catchError(origCatch) {\n\n        var args = _.tail(_.flatten(arguments)),\n            callback = args.pop(),\n            types = _.compact(_.map(args, convertToErrorType));\n\n        if (isErrorType(callback)) {\n            return origCatch.call(this);\n        } else if (_.isEmpty(args)) {\n            return origCatch.call(this, callback || _.noop);\n        }\n\n        return origCatch.call(this, function catchIfType(err) {\n\n            function matchesDesiredErrorType(ErrorType) {\n                return err instanceof ErrorType;\n            }\n\n            if (_.isEmpty(types) || _.some(types, matchesDesiredErrorType)) {\n                return callback(err);\n            }\n\n            return err; // propagate\n\n        });\n\n    });\n\n    proto.spread = function wrappedSpread(callback) {\n        var promise = this;\n        return promise.then(function innerSpread(arr) {\n            if (_.isPlainObject(arr)) {\n                return callback.call(promise, arr);\n            } else {\n                return callback.apply(promise, arr);\n            }\n        });\n    };\n\n    /**\n     * Returns a promise that is resolved only if all the passed\n     * promises resolve OR reject. Otherwise, the returned promise\n     * will be rejected.\n     *\n     * Aliased as .settle to provide consistency with former API\n     * @function paychex.core.Promise.allSettled\n     * @returns {Promise}\n     */\n    Promise.allSettled = Promise.settle = _.wrap(Promise.settle, function settle(orig, promises) {\n        if (_.isPlainObject(promises)) {\n            var keys = _.keys(promises);\n            return orig(_.values(promises))\n                .then(function combine(values) {\n                    return _.zipObject(keys, _.invokeMap(values, 'value'));\n                });\n        }\n        return orig(promises);\n    });\n\n    /**\n     * Rejects the given promise if it is not resolved or rejected\n     * within the specified number of milliseconds\n     * @function paychex.core.Promise#timeout\n     * @param {Promise} prom The promise to apply the timeout to.\n     * @param {Number} ms The number of milliseconds before the promise\n     * should be rejected, if it has not already been resolved or rejected.\n     * @param {String} message The message to use as the rejection message\n     *  when the promise times out; defaults to 'timed out' if not provided.\n     * @return {Promise} A promise that will be rejected after the specified\n     *  timeout period (if not settled first).\n     */\n    Promise.timeout = Promise.timeout || function timeout(prom, ms, message) {\n        return prom.timeout(ms, message || 'Timed out after ' + ms + ' ms');\n    };\n\n    Promise.fcall = Promise.call;\n    Promise.fapply = Promise.apply;\n\n    return Promise;\n\n});\n\n","define('lib.safe-json-stringify',['require','exports','module'],function(require, exports, module) {\nexports = module.exports = stringify\nexports.getSerialize = serializer\n\nfunction stringify(obj, replacer, spaces, cycleReplacer) {\n  return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces)\n}\n\nfunction serializer(replacer, cycleReplacer) {\n  var stack = [], keys = []\n\n  if (cycleReplacer == null) cycleReplacer = function(key, value) {\n    if (stack[0] === value) return \"[Circular ~]\"\n    return \"[Circular ~.\" + keys.slice(0, stack.indexOf(value)).join(\".\") + \"]\"\n  }\n\n  return function(key, value) {\n    if (stack.length > 0) {\n      var thisPos = stack.indexOf(this)\n      ~thisPos ? stack.splice(thisPos + 1) : stack.push(this)\n      ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key)\n      if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value)\n    }\n    else stack.push(value)\n\n    return replacer == null ? value : replacer.call(this, key, value)\n  }\n}\n\n});\n\n","/**\n *\n *\n * @author Jerry Bendy <jerry@icewingcc.com>\n * @licence MIT\n *\n */\n\n\n(function(self) {\n    'use strict';\n\n    if (self.URLSearchParams && (new self.URLSearchParams({a:1})).toString() === 'a=1') {\n        return;\n    }\n\n\n    var __URLSearchParams__ = \"__URLSearchParams__\",\n        prototype = URLSearchParams.prototype,\n        iterable = !!(self.Symbol && self.Symbol.iterator);\n\n\n    /**\n     * Make a URLSearchParams instance\n     *\n     * @param {object|string|URLSearchParams} search\n     * @constructor\n     */\n    function URLSearchParams (search) {\n        search = search || \"\";\n\n        this [__URLSearchParams__] = {};\n\n        // support construct object with another URLSearchParams instance\n        if (search instanceof URLSearchParams) {\n            search = search.toString();\n        }\n\n        if (typeof search === \"object\") {\n            for (var i in search) {\n                if (search.hasOwnProperty(i)) {\n                    var str = typeof search [i] === 'string' ? search [i] : JSON.stringify(search [i]);\n                    this.append(i, str);\n                }\n            }\n\n        } else {\n\n            // remove first '?'\n            if (search.indexOf(\"?\") === 0) {\n                search = search.slice(1);\n            }\n\n            var pairs = search.split(\"&\");\n            for (var j = 0; j < pairs.length; j ++) {\n                var value = pairs [j],\n                    index = value.indexOf('=');\n\n                if (-1 < index) {\n                    this.append(\n                        decode(value.slice(0, index)),\n                        decode(value.slice(index + 1))\n                    );\n                }\n            }\n        }\n\n    }\n\n    /**\n     * Appends a specified key/value pair as a new search parameter.\n     *\n     * @param {string} name\n     * @param {string} value\n     */\n    prototype.append = function(name, value) {\n        var dict = this [__URLSearchParams__];\n        if (name in dict) {\n            dict[name].push('' + value);\n        } else {\n            dict[name] = ['' + value];\n        }\n    };\n\n    /**\n     * Deletes the given search parameter, and its associated value,\n     * from the list of all search parameters.\n     *\n     * @param {string} name\n     */\n    prototype.delete = function (name) {\n        delete this [__URLSearchParams__] [name];\n    };\n\n    /**\n     * Returns the first value associated to the given search parameter.\n     *\n     * @param {string} name\n     * @returns {string|null}\n     */\n    prototype.get = function (name) {\n        var dict = this [__URLSearchParams__];\n        return name in dict ? dict[name][0] : null;\n    };\n\n    /**\n     * Returns all the values association with a given search parameter.\n     *\n     * @param {string} name\n     * @returns {Array}\n     */\n    prototype.getAll = function (name) {\n        var dict = this [__URLSearchParams__];\n        return name in dict ? dict [name].slice(0) : [];\n    };\n\n    /**\n     * Returns a Boolean indicating if such a search parameter exists.\n     *\n     * @param {string} name\n     * @returns {boolean}\n     */\n    prototype.has = function (name) {\n        return name in this [__URLSearchParams__];\n    };\n\n    /**\n     * Sets the value associated to a given search parameter to\n     * the given value. If there were several values, delete the\n     * others.\n     *\n     * @param {string} name\n     * @param {string} value\n     */\n    prototype.set = function set(name, value) {\n        this [__URLSearchParams__][name] = ['' + value];\n    };\n\n    /**\n     *\n     *\n     * @param {function} callback\n     * @param {object} thisArg\n     */\n    prototype.forEach = function (callback, thisArg) {\n        var dict = this [__URLSearchParams__];\n        Object.getOwnPropertyNames(dict).forEach(function(name) {\n            dict[name].forEach(function(value) {\n                callback.call(thisArg, value, name, this);\n            }, this);\n        }, this);\n    };\n\n    /**\n     * Returns a string containg a query string suitable for use in a URL.\n     *\n     * @returns {string}\n     */\n    prototype.toString = function () {\n        var dict = this[__URLSearchParams__], query = [], i, key, name, value;\n        for (key in dict) {\n            name = encode(key);\n            for (i = 0, value = dict[key]; i < value.length; i++) {\n                query.push(name + '=' + encode(value[i]));\n            }\n        }\n        return query.join('&');\n    };\n\n\n    /**\n     * Sort all name-value pairs\n     */\n    prototype.sort = function () {\n        var dict = this[__URLSearchParams__], keys = [], k, i, ret = {};\n        for (k in dict) {\n            keys.push(k);\n        }\n        keys.sort();\n        for (i = 0; i < keys.length; i ++) {\n            ret[keys[i]] = dict[keys[i]];\n        }\n        this[__URLSearchParams__] = ret;\n    };\n\n\n    /**\n     * Returns an iterator allowing to go through all keys of\n     * the key/value pairs contained in this object.\n     *\n     * @returns {function}\n     */\n    prototype.keys = function () {\n        var items = [];\n        this.forEach(function (item, name) {\n            items.push([name]);\n        });\n        return makeIterator(items);\n    };\n\n    /**\n     * Returns an iterator allowing to go through all values of\n     * the key/value pairs contained in this object.\n     *\n     * @returns {function}\n     */\n    prototype.values = function () {\n        var items = [];\n        this.forEach(function (item) {\n            items.push([item]);\n        });\n        return makeIterator(items);\n    };\n\n    /**\n     * Returns an iterator allowing to go through all key/value\n     * pairs contained in this object.\n     *\n     * @returns {function}\n     */\n    prototype.entries = function () {\n        var items = [];\n        this.forEach(function (item, name) {\n            items.push([name, item]);\n        });\n        return makeIterator(items);\n    };\n\n\n    if (iterable) {\n        prototype[self.Symbol.iterator] = prototype.entries;\n    }\n\n\n    function encode(str) {\n        var replace = {\n            '!': '%21',\n            \"'\": '%27',\n            '(': '%28',\n            ')': '%29',\n            '~': '%7E',\n            '%20': '+',\n            '%00': '\\x00'\n        };\n        return encodeURIComponent(str).replace(/[!'\\(\\)~]|%20|%00/g, function (match) {\n            return replace[match];\n        });\n    }\n\n    function decode(str) {\n        return decodeURIComponent(str.replace(/\\+/g, ' '));\n    }\n\n    function makeIterator(arr) {\n        var iterator = {\n            next: function () {\n                var value = arr.shift();\n                return {done: value === undefined, value: value};\n            }\n        };\n\n        if (iterable) {\n            iterator[self.Symbol.iterator] = function () {\n                return iterator;\n            };\n        }\n\n        return iterator;\n    }\n\n    self.URLSearchParams = URLSearchParams;\n\n    self.URLSearchParams.polyfill = true;\n\n\n})(typeof global !== 'undefined' ? global : (typeof window !== 'undefined' ? window : this));\n\ndefine(\"lib.url-search-params\", function(){});\n\n","define('paychex.core/Prototypes',[\n    'lodash',\n    'paychex.core/Errors',\n    'paychex.core/lib/usertiming.min',\n    'lib.safe-json-stringify',\n    'lib.url-search-params'\n], function(\n    _,\n    Errors,\n    Performance,\n    safeStringify\n){\n\n    /**\n     * @class paychex.core.Prototypes\n     * @description\n     * Custom JavaScript prototypes (polyfills) useful for Paychex applications.\n     * Current prototypes include:\n     *  - Function.bind\n     *  - Date.parseISO8601\n     *  - Array.every\n     *  - Array.some\n     *  - Array.indexOf\n     *  - Array.map\n     *  - Array.removeAtIndex\n     *  - Array.filter\n     *  - Array.forEach\n     *  - Array.reduce\n     *  - Array.all\n     *  - Array.any\n     *  - Array.find\n     *  - Array.findIndex\n     */\n\n    'use strict';\n\n    /* jshint bitwise : false */\n\n    /* PhantomJS doesn't have a Function.prototype.bind, so we add one here if needed: */\n    if (!Function.prototype.bind) {\n        Function.prototype.bind = function bind(oThis) {\n            if (typeof this !== 'function') {\n                // closest thing possible to the ECMAScript 5 internal IsCallable function\n                Errors.throw(Errors.Types.Type, 'Function.prototype.bind - what is trying to be bound is not callable');\n            }\n\n            var aArgs = Array.prototype.slice.call(arguments, 1),\n                fToBind = this,\n                NOP = function NOP() {},\n                fBound = function fBound() {\n                    return fToBind.apply(this instanceof NOP && oThis ? this : oThis,\n                        aArgs.concat(Array.prototype.slice.call(arguments)));\n                };\n\n            NOP.prototype = this.prototype;\n            fBound.prototype = new NOP();\n\n            return fBound;\n        };\n    }\n\n    if (!Array.prototype.every) {\n\n        Array.prototype.every = function every(fun) {\n\n            if (this === void 0 || this === null) {\n                Errors.throw(Errors.Types.Type, 'this is null or undefined');\n            }\n\n            var t = Object(this),\n                len = t.length >>> 0;\n\n            if (typeof fun !== 'function') {\n                Errors.throw(Errors.Types.Type, 'Argument specified was not a function.');\n            }\n\n            var thisArg = arguments.length >= 2 ? arguments[1] : void 0;\n            for (var i = 0; i < len; i++) {\n                if (i in t && !fun.call(thisArg, t[i], i, t)) {\n                    return false;\n                }\n            }\n\n            return true;\n        };\n    }\n\n    // polyfill for IE8\n    if (!Array.prototype.some) {\n\n        Array.prototype.some = function some(fun) {\n\n            if (this === void 0 || this === null) {\n                Errors.throw(Errors.Types.Type, 'some() called on non-array type.');\n            }\n\n            var t = Object(this),\n                len = t.length >>> 0;\n\n            if (typeof fun !== 'function') {\n                Errors.throw(Errors.Types.Type, 'Argument specified was not a function.');\n            }\n\n            var thisArg = arguments.length >= 2 ? arguments[1] : void 0;\n            for (var i = 0; i < len; i++) {\n                if (i in t && fun.call(thisArg, t[i], i, t)) {\n                    return true;\n                }\n            }\n\n            return false;\n        };\n    }\n\n\n    // Add indexOf method to Array prototype if it doesn't exist\n    if (!Array.prototype.indexOf) {\n\n        /**\n         * [indexOf description]\n         * Mozilla Developer Connection implementation of the indexOf prototype method\n         * for arrays.\n         * https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf\n         *\n         * @param  {Object} searchElement Object to search for\n         * @return {Number}               Object found?\n         */\n        Array.prototype.indexOf = function indexOf(searchElement /*, fromIndex */ ) {\n\n            if (this === null || this === undefined) {\n                Errors.throw(Errors.Types.Type, 'this is null or undefined');\n            }\n            var t = Object(this);\n            var len = t.length >>> 0;\n            if (len === 0) {\n                return -1;\n            }\n            var n = 0;\n            if (arguments.length > 1) {\n                n = Number(arguments[1]);\n                if (n !== n) { // shortcut for verifying if it's NaN\n                    n = 0;\n                } else if (n !== 0 && n !== Infinity && n !== -Infinity) {\n                    n = (n > 0 || -1) * Math.floor(Math.abs(n));\n                }\n            }\n            if (n >= len) {\n                return -1;\n            }\n            var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);\n            for (; k < len; k++) {\n                if (k in t && t[k] === searchElement) {\n                    return k;\n                }\n            }\n            return -1;\n        };\n    }\n\n\n\n    if (!Array.prototype.map) {\n        /**\n         * Add map method\n         * Production steps of ECMA-262, Edition 5, 15.4.4.19\n         * Reference: http://es5.github.com/#x15.4.4.19\n         *\n         * @param  {Function} callback description\n         * @param  {*}   thisArg  description\n         * @return {*}            description\n         */\n        Array.prototype.map = function map(callback, thisArg) {\n            var T, A, k;\n\n            if (this === null || this === undefined) {\n                Errors.throw(Errors.Types.Type, 'this is null or not defined');\n            }\n\n            // 1. Let O be the result of calling ToObject passing the |this| value as the argument.\n            var O = Object(this);\n\n            // 2. Let lenValue be the result of calling the Get internal method of O with the argument \"length\".\n            // 3. Let len be ToUint32(lenValue).\n            var len = O.length >>> 0;\n\n            // 4. If IsCallable(callback) is false, throw a TypeError exception.\n            // See: http://es5.github.com/#x9.11\n            if (typeof callback !== 'function') {\n                Errors.throw(Errors.Types.Type, 'Argument specified is not a function');\n            }\n\n            // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.\n            if (thisArg) {\n                T = thisArg;\n            }\n\n            // 6. Let A be a new array created as if by the expression new Array(len) where Array is\n            // the standard built-in constructor with that name and len is the value of len.\n            A = new Array(len);\n\n            // 7. Let k be 0\n            k = 0;\n\n            // 8. Repeat, while k < len\n            while(k < len) {\n\n                var kValue, mappedValue;\n\n                // a. Let Pk be ToString(k).\n                //   This is implicit for LHS operands of the in operator\n                // b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk.\n                //   This step can be combined with c\n                // c. If kPresent is true, then\n                if (k in O) {\n                    // i. Let kValue be the result of calling the Get internal method of O with argument Pk.\n                    kValue = O[ k ];\n\n                    // ii. Let mappedValue be the result of calling the Call internal method of callback\n                    // with T as the this value and argument list containing kValue, k, and O.\n                    mappedValue = callback.call(T, kValue, k, O);\n\n                    // iii. Call the DefineOwnProperty internal method of A with arguments\n                    // Pk, Property Descriptor {Value: mappedValue, : true, Enumerable: true, Configurable: true},\n                    // and false.\n\n                    // In browsers that support Object.defineProperty, use the following:\n                    // Object.defineProperty(A, Pk, { value: mappedValue, writable: true, enumerable: true, configurable: true });\n\n                    // For best browser support, use the following:\n                    A[ k ] = mappedValue;\n                }\n                // d. Increase k by 1.\n                k++;\n            }\n\n            // 9. return A\n            return A;\n        };\n    }\n\n    /**\n     * Remove array item at index.  Simpler syntax\n     * @param  {Number} arrIndex Index of array item\n     * @return {*}          description\n     */\n    Array.prototype.removeAtIndex = function removeAtIndex(arrIndex) {\n        var t = Object(this);\n        t.splice(arrIndex, 1);\n    };\n\n    if (!Array.prototype.filter) {\n        // TODO: make sure it matches the standard filter\n        Array.prototype.filter = function filter(pred) {\n            var result = [];\n            for (var i=0;i<this.length;i++) {\n                if (pred(this[i])) {\n                    result.push(this[i]);\n                }\n            }\n\n            return result;\n        };\n    }\n    if (!Array.prototype.forEach) {\n        Array.prototype.forEach = function forEach(callback, thisArg) {\n            // unlike map, foreach is only for side effects and does not return a value\n            this.map(callback,thisArg);\n        };\n    }\n\n    if (!Array.prototype.reduce) {\n        Array.prototype.reduce = function reduce() {\n            var i;\n            var callback = arguments[0];\n            var result;\n\n            if (arguments.length > 1) {\n                i = 0;\n                result = arguments[1];\n            } else {\n                if (this.length === 0) {\n                    Errors.throw('InvalidOperationError', 'Reduce of empty array with no initial value');\n                } else if (this.length === 1) {\n                    return this[0];\n                } else {\n                    i = 1;\n                    result = this[0];\n                }\n            }\n\n            for (;i<this.length;i++) {\n                result = callback(result, this[i]);\n            }\n\n            return result;\n        };\n    }\n    // Source - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find#Polyfill\n    if (!Array.prototype.find) {\n        Object.defineProperty(Array.prototype, 'find', {\n            value: function(predicate) {\n                // 1. Let O be ? ToObject(this value).\n                if (this == null) {\n                    throw new TypeError('\"this\" is null or not defined');\n                }\n\n                var o = Object(this);\n\n                // 2. Let len be ? ToLength(? Get(O, \"length\")).\n                var len = o.length >>> 0;\n\n                // 3. If IsCallable(predicate) is false, throw a TypeError exception.\n                if (typeof predicate !== 'function') {\n                    throw new TypeError('predicate must be a function');\n                }\n\n                // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.\n                var thisArg = arguments[1];\n\n                // 5. Let k be 0.\n                var k = 0;\n\n                // 6. Repeat, while k < len\n                while (k < len) {\n                    // a. Let Pk be ! ToString(k).\n                    // b. Let kValue be ? Get(O, Pk).\n                    // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).\n                    // d. If testResult is true, return kValue.\n                    var kValue = o[k];\n                    if (predicate.call(thisArg, kValue, k, o)) {\n                        return kValue;\n                    }\n                    // e. Increase k by 1.\n                    k++;\n                }\n\n                // 7. Return undefined.\n                return undefined;\n            },\n            configurable: true,\n            writable: true\n        });\n    }\n    if (!Array.prototype.findIndex) {\n        Object.defineProperty(Array.prototype, 'findIndex', {\n            value: function(predicate) {\n                // 1. Let O be ? ToObject(this value).\n                if (this == null) {\n                    throw new TypeError('\"this\" is null or not defined');\n                }\n\n                var o = Object(this);\n\n                // 2. Let len be ? ToLength(? Get(O, \"length\")).\n                var len = o.length >>> 0;\n\n                // 3. If IsCallable(predicate) is false, throw a TypeError exception.\n                if (typeof predicate !== 'function') {\n                    throw new TypeError('predicate must be a function');\n                }\n\n                // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.\n                var thisArg = arguments[1];\n\n                // 5. Let k be 0.\n                var k = 0;\n\n                // 6. Repeat, while k < len\n                while (k < len) {\n                    // a. Let Pk be ! ToString(k).\n                    // b. Let kValue be ? Get(O, Pk).\n                    // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).\n                    // d. If testResult is true, return k.\n                    var kValue = o[k];\n                    if (predicate.call(thisArg, kValue, k, o)) {\n                        return k;\n                    }\n                    // e. Increase k by 1.\n                    k++;\n                }\n\n                // 7. Return -1.\n                return -1;\n            },\n            configurable: true,\n            writable: true\n        });\n    }\n\n    if (!Array.prototype.all) {\n        Array.prototype.all = function all(pred) {\n            return this.filter(pred).length === this.length;\n        };\n    }\n    if (!Array.prototype.any) {\n        Array.prototype.any = function any(pred) {\n            return this.filter(pred).length > 0;\n        };\n    }\n\n    //IE11 polyfill for slice not existing on Uint8Array - need for Encryption\n    Uint8Array.prototype.slice = Uint8Array.prototype.slice || function slice() {\n        return new Uint8Array(Array.prototype.slice.apply(this, arguments));\n    };\n\n    Uint8Array.prototype.reduce = Uint8Array.prototype.reduce || Array.prototype.reduce;\n\n    Date.prototype.parseISO8601 = function parseISO8601(str) {\n        // we assume str is a UTC date ending in 'Z'\n\n        var parts = str.split('T'),\n            dateParts = parts[0].split('-'),\n            timeParts = parts[1].split('Z'),\n            timeSubParts = timeParts[0].split(':'),\n            timeSecParts = timeSubParts[2].split('.'),\n            timeHours = Number(timeSubParts[0]),\n            _date = new Date();\n\n        _date.setUTCFullYear(Number(dateParts[0]));\n        _date.setUTCMonth(Number(dateParts[1])-1);\n        _date.setUTCDate(Number(dateParts[2]));\n        _date.setUTCHours(Number(timeHours));\n        _date.setUTCMinutes(Number(timeSubParts[1]));\n        _date.setUTCSeconds(Number(timeSecParts[0]));\n        if (timeSecParts[1]){\n            _date.setUTCMilliseconds(Number(timeSecParts[1]));\n        }\n\n        // by using setUTC methods the date has already been converted to local time(?)\n        return _date;\n    };\n\n    /* jshint ignore:start */\n    // mutationobserver-shim v0.3.1 (github.com/megawac/MutationObserver.js)\n    // Authors: Graeme Yeates (github.com/megawac)\n    window.MutationObserver=window.MutationObserver||window.WebKitMutationObserver||function(r){function w(a){this.g=[];this.k=a}function H(a){(function c(){var d=a.takeRecords();d.length&&a.k(d,a);a.f=setTimeout(c,w._period)})()}function t(a){var b={type:null,target:null,addedNodes:[],removedNodes:[],previousSibling:null,nextSibling:null,attributeName:null,attributeNamespace:null,oldValue:null},c;for(c in a)b[c]!==r&&a[c]!==r&&(b[c]=a[c]);return b}function I(a,b){var c=B(a,b);return function(d){var g=\n            d.length,n;b.a&&c.a&&A(d,a,c.a,b.d);if(b.b||b.e)n=J(d,a,c,b);if(n||d.length!==g)c=B(a,b)}}function A(a,b,c,d){for(var g={},n=b.attributes,h,m,C=n.length;C--;)h=n[C],m=h.name,d&&d[m]===r||(h.value!==c[m]&&a.push(t({type:\"attributes\",target:b,attributeName:m,oldValue:c[m],attributeNamespace:h.namespaceURI})),g[m]=!0);for(m in c)g[m]||a.push(t({target:b,type:\"attributes\",attributeName:m,oldValue:c[m]}))}function J(a,b,c,d){function g(b,c,g,h,y){var r=b.length-1;y=-~((r-y)/2);for(var f,k,e;e=b.pop();)f=\n            g[e.h],k=h[e.i],d.b&&y&&Math.abs(e.h-e.i)>=r&&(a.push(t({type:\"childList\",target:c,addedNodes:[f],removedNodes:[f],nextSibling:f.nextSibling,previousSibling:f.previousSibling})),y--),d.a&&k.a&&A(a,f,k.a,d.d),d.c&&3===f.nodeType&&f.nodeValue!==k.c&&a.push(t({type:\"characterData\",target:f})),d.e&&n(f,k)}function n(b,c){for(var x=b.childNodes,p=c.b,y=x.length,w=p?p.length:0,f,k,e,l,u,z=0,v=0,q=0;v<y||q<w;)l=x[v],u=(e=p[q])&&e.j,l===u?(d.a&&e.a&&A(a,l,e.a,d.d),d.c&&e.c!==r&&l.nodeValue!==e.c&&a.push(t({type:\"characterData\",\n            target:l})),k&&g(k,b,x,p,z),d.e&&(l.childNodes.length||e.b&&e.b.length)&&n(l,e),v++,q++):(h=!0,f||(f={},k=[]),l&&(f[e=D(l)]||(f[e]=!0,-1===(e=E(p,l,q,\"j\"))?d.b&&(a.push(t({type:\"childList\",target:b,addedNodes:[l],nextSibling:l.nextSibling,previousSibling:l.previousSibling})),z++):k.push({h:v,i:e})),v++),u&&u!==x[v]&&(f[e=D(u)]||(f[e]=!0,-1===(e=E(x,u,v))?d.b&&(a.push(t({type:\"childList\",target:c.j,removedNodes:[u],nextSibling:p[q+1],previousSibling:p[q-1]})),z--):k.push({h:e,i:q})),q++));k&&g(k,b,\n            x,p,z)}var h;n(b,c);return h}function B(a,b){var c=!0;return function g(a){var h={j:a};!b.c||3!==a.nodeType&&8!==a.nodeType?(b.a&&c&&1===a.nodeType&&(h.a=F(a.attributes,function(a,c){if(!b.d||b.d[c.name])a[c.name]=c.value;return a})),c&&(b.b||b.c||b.a&&b.e)&&(h.b=K(a.childNodes,g)),c=b.e):h.c=a.nodeValue;return h}(a)}function D(a){try{return a.id||(a.mo_id=a.mo_id||G++)}catch(b){try{return a.nodeValue}catch(c){return G++}}}function K(a,b){for(var c=[],d=0;d<a.length;d++)c[d]=b(a[d],d,a);return c}\n            function F(a,b){for(var c={},d=0;d<a.length;d++)c=b(c,a[d],d,a);return c}function E(a,b,c,d){for(;c<a.length;c++)if((d?a[c][d]:a[c])===b)return c;return-1}w._period=30;w.prototype={observe:function(a,b){for(var c={a:!!(b.attributes||b.attributeFilter||b.attributeOldValue),b:!!b.childList,e:!!b.subtree,c:!(!b.characterData&&!b.characterDataOldValue)},d=this.g,g=0;g<d.length;g++)d[g].m===a&&d.splice(g,1);b.attributeFilter&&(c.d=F(b.attributeFilter,function(a,b){a[b]=!0;return a}));d.push({m:a,l:I(a,\n                c)});this.f||H(this)},takeRecords:function(){for(var a=[],b=this.g,c=0;c<b.length;c++)b[c].l(a);return a},disconnect:function(){this.g=[];clearTimeout(this.f);this.f=null}};var G=1;return w}(void 0);\n\n    /* (The MIT License)\n     *\n     * Copyright (c) 2012 Brandon Benvie <http://bbenvie.com>\n     *\n     * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and\n     * associated documentation files (the 'Software'), to deal in the Software without restriction,\n     * including without limitation the rights to use, copy, modify, merge, publish, distribute,\n     * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is\n     * furnished to do so, subject to the following conditions:\n     *\n     * The above copyright notice and this permission notice shall be included with all copies or\n     * substantial portions of the Software.\n     *\n     * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING\n     * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n     * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  CLAIM,\n     * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n     */\n\n// Original WeakMap implementation by Gozala @ https://gist.github.com/1269991\n// Updated and bugfixed by Raynos @ https://gist.github.com/1638059\n// Expanded by Benvie @ https://github.com/Benvie/harmony-collections\n\n    void function (global, undefined_, undefined) {\n\n        if ('WeakMap' in global) {\n            return;\n        }\n\n        var getProps = Object.getOwnPropertyNames,\n            defProp = Object.defineProperty,\n            toSource = Function.prototype.toString,\n            create = Object.create,\n            hasOwn = Object.prototype.hasOwnProperty,\n            funcName = /^\\n?function\\s?(\\w*)?_?\\(/;\n\n\n        function define(object, key, value) {\n            if (typeof key === 'function') {\n                value = key;\n                key = nameOf(value).replace(/_$/, '');\n            }\n            return defProp(object, key, {configurable: true, writable: true, value: value});\n        }\n\n        function nameOf(func) {\n            return typeof func !== 'function'\n                ? '' : 'name' in func\n                ? func.name : toSource.call(func).match(funcName)[1];\n        }\n\n        // ############\n        // ### Data ###\n        // ############\n\n        var Data = (function () {\n            var dataDesc = {value: {writable: true, value: undefined}},\n                uids = create(null),\n\n                createUID = function () {\n                    var key = Math.random().toString(36).slice(2);\n                    return key in uids ? createUID() : uids[key] = key;\n                },\n\n                globalID = createUID(),\n\n                storage = function (obj) {\n                    if (hasOwn.call(obj, globalID))\n                        return obj[globalID];\n\n                    if (!Object.isExtensible(obj))\n                        throw new TypeError(\"Object must be extensible\");\n\n                    var store = create(null);\n                    defProp(obj, globalID, {value: store});\n                    return store;\n                };\n\n            // common per-object storage area made visible by patching getOwnPropertyNames'\n            define(Object, function getOwnPropertyNames(obj) {\n                var props = getProps(obj);\n                if (hasOwn.call(obj, globalID))\n                    props.splice(props.indexOf(globalID), 1);\n                return props;\n            });\n\n            function Data() {\n                var puid = createUID(),\n                    secret = {};\n\n                this.unlock = function (obj) {\n                    var store = storage(obj);\n                    if (hasOwn.call(store, puid))\n                        return store[puid](secret);\n\n                    var data = create(null, dataDesc);\n                    defProp(store, puid, {\n                        value: function (key) {\n                            if (key === secret) return data;\n                        }\n                    });\n                    return data;\n                }\n            }\n\n            define(Data.prototype, function get(o) {\n                return this.unlock(o).value\n            });\n            define(Data.prototype, function set(o, v) {\n                this.unlock(o).value = v\n            });\n\n            return Data;\n        }());\n\n\n        var WM = (function (data) {\n            var validate = function (key) {\n                if (key == null || typeof key !== 'object' && typeof key !== 'function')\n                    throw new TypeError(\"Invalid WeakMap key\");\n            }\n\n            var wrap = function (collection, value) {\n                var store = data.unlock(collection);\n                if (store.value)\n                    throw new TypeError(\"Object is already a WeakMap\");\n                store.value = value;\n            }\n\n            var unwrap = function (collection) {\n                var storage = data.unlock(collection).value;\n                if (!storage)\n                    throw new TypeError(\"WeakMap is not generic\");\n                return storage;\n            }\n\n            var initialize = function (weakmap, iterable) {\n                if (iterable !== null && typeof iterable === 'object' && typeof iterable.forEach === 'function') {\n                    iterable.forEach(function (item, i) {\n                        if (item instanceof Array && item.length === 2)\n                            set.call(weakmap, iterable[i][0], iterable[i][1]);\n                    });\n                }\n            }\n\n\n            function WeakMap(iterable) {\n                if (this === global || this == null || this === WeakMap.prototype)\n                    return new WeakMap(iterable);\n\n                wrap(this, new Data);\n                initialize(this, iterable);\n            }\n\n            function get(key) {\n                validate(key);\n                var value = unwrap(this).get(key);\n                return value === undefined_ ? undefined : value;\n            }\n\n            function set(key, value) {\n                validate(key);\n                // store a token for explicit undefined so that \"has\" works correctly\n                unwrap(this).set(key, value === undefined ? undefined_ : value);\n            }\n\n            function has(key) {\n                validate(key);\n                return unwrap(this).get(key) !== undefined;\n            }\n\n            function delete_(key) {\n                validate(key);\n                var data = unwrap(this),\n                    had = data.get(key) !== undefined;\n                data.set(key, undefined);\n                return had;\n            }\n\n            function toString() {\n                unwrap(this);\n                return '[object WeakMap]';\n            }\n\n            var src = ('' + Object).split('Object');\n            var stringifier = function toString() {\n                return src[0] + nameOf(this) + src[1];\n            };\n\n            define(stringifier, stringifier);\n\n            var prep = {__proto__: []} instanceof Array\n                ? function (f) {\n                f.__proto__ = stringifier\n            }\n                : function (f) {\n                define(f, stringifier)\n            };\n\n            prep(WeakMap);\n\n            [toString, get, set, has, delete_].forEach(function (method) {\n                define(WeakMap.prototype, method);\n                prep(method);\n            });\n\n            return WeakMap;\n        }(new Data));\n\n        var defaultCreator = Object.create\n            ? function () {\n            return Object.create(null)\n        }\n            : function () {\n            return {}\n        };\n\n        function createStorage(creator) {\n            var weakmap = new WM;\n            creator || (creator = defaultCreator);\n\n            function storage(object, value) {\n                if (value || arguments.length === 2) {\n                    weakmap.set(object, value);\n                } else {\n                    value = weakmap.get(object);\n                    if (value === undefined) {\n                        value = creator(object);\n                        weakmap.set(object, value);\n                    }\n                }\n                return value;\n            }\n\n            return storage;\n        }\n\n        WM.createStorage = createStorage;\n\n        global.WeakMap = WM;\n\n        if (global.WeakMap)\n            global.WeakMap.createStorage = createStorage;\n\n    }(function () {\n        return window;\n    }());\n\n    if (window.Element && !Element.prototype.closest) {\n        Element.prototype.closest =\n            function closest(s) {\n                var matches = (this.document || this.ownerDocument).querySelectorAll(s),\n                    i,\n                    el = this;\n                do {\n                    i = matches.length;\n                    while (--i >= 0 && matches.item(i) !== el) {}\n                } while ((i < 0) && (el = el.parentElement));\n                return el;\n            };\n    }\n\n\n\n    /*\n     * This function is used to find all properties (even properties which have been marked as non-enumerable) on a given\n     * object and it's prototype.\n     * We use this to resolve issues where JSON.stringify was not capturing the stack, name, or message of Error objects\n     * that we were attempting to send to the server.\n     */\n    Error.prototype.toJSON = function(){\n        var result = {},\n            target = this,\n            EXCLUDED_PROPS = ['context', 'promise', 'handled'];\n\n        do {\n            _.reduce(Object.getOwnPropertyNames(target), function copy(foo, key) {\n                if (!(key in result) && !_.includes(EXCLUDED_PROPS, key) ) {\n                    result[key] = target[key];\n                }\n            }, {});\n            target = Object.getPrototypeOf(target);\n        } while (target !== Object.prototype);\n        return result;\n    };\n\n\n    /*\n     * This replaces the default JSON.stringify() with a safe implementation that will handle circular references (cycles)\n     * in the objects that are being stringified.\n     */\n    (function makeStringifySafe(){\n        var originalStringify = JSON.stringify;\n        JSON.stringify = function(){\n            if( arguments.length === 1){\n                return safeStringify(arguments[0]);\n            }else{\n                return originalStringify.apply(JSON, arguments);\n            }\n        };\n    })();\n\n\n    /* jshint ignore:end */\n\n});\n\n","/**\n * @class paychex.core.Repository\n * @description\n * Provides a generic storage service with access to various\n * {@link paychex.core.stores.Store Store} instances.\n */\n\ndefine('paychex.core/Repository',[\n    'paychex.core/stores/CookieStorage',\n    'paychex.core/stores/SessionStorage',\n    'paychex.core/stores/LocalStorage',\n    'paychex.core/stores/EmptyStore'\n], function (cookies,\n             session,\n             local,\n             EmptyStore) {\n\n    'use strict';\n\n    return {\n\n        /**\n         * @member {paychex.core.stores.CookieStorage} paychex.core.Repository#cookies\n         * @description\n         * An instance of {@link paychex.core.stores.CookieStorage CookieStorage} that persists\n         * data to the `document.cookies` collection.\n         */\n        cookies: cookies,\n\n        /**\n         * @member {paychex.core.stores.SessionStorage} paychex.core.Repository#session\n         * @description\n         * An instance of {@link paychex.core.stores.SessionStorage SessionStorage} that persists\n         * data to `window.sessionStorage`. Has additional methods\n         * specific to a user's session.\n         */\n        session: session,\n\n        /**\n         * @member {paychex.core.stores.LocalStorage} paychex.core.Repository#local\n         * @description\n         * An instance of {@link paychex.core.stores.LocalStorage LocalStorage} that persists\n         * data to `window.localStorage`. This data can be retrieved even after\n         * the user has closed the browser window.\n         */\n        local: local,\n\n        empty: new EmptyStore()\n\n        /* LATER: global : globalStore */\n\n    };\n\n});\n\n\n","define('paychex.core/Schedulers',['lodash'], function(_) {\n\n    /**\n     * @author: Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2017-08-30\n     */\n\n    'use strict';\n\n    return function factory(base) {\n\n        var root = base || window,\n\n            nextTick = function scheduler(fn) {\n                root.setTimeout(fn);\n            },\n\n            immediate = (function getImmediate() {\n\n                var obj,\n                    obj2,\n                    trigger,\n                    guard = false,\n                    queue = [];\n\n                /** @private */\n                function process() {\n                    var fns;\n                    while (queue.length) {\n                        fns = queue.concat();\n                        queue.length = 0;\n                        _.forEach(fns, _.attempt);\n                        fns.length = 0;\n                        fns = null;\n                    }\n                    guard = false;\n                }\n\n                if ('setImmediate' in root) { // ie11 + edge\n                    trigger = function invokeSetImmediate() {\n                        root.setImmediate(process);\n                    };\n                } else if ('Promise' in root) { // chrome + firefox + safari\n                    obj = root.Promise.resolve();\n                    trigger = function chainToPromise() {\n                        obj.then(process);\n                    };\n                } else if ('MutationObserver' in root) { // older browsers\n                    obj = new root.MutationObserver(process);\n                    obj2 = document.createElement('span');\n                    root.addEventListener('unload', function dispose() {\n                        obj.disconnect();\n                        obj = null;\n                    }, false);\n                    obj.observe(obj2, {attributes: true, attributeFilter: ['alt']});\n                    trigger = function toggleAttribute() {\n                        obj2.setAttribute('alt', String(obj2.getAttribute('alt') !== 'true'));\n                    };\n                } else {\n                    trigger = function invokeNextTick() {\n                        nextTick(process);\n                    };\n                }\n\n                return function scheduler(fn) {\n                    queue[queue.length] = fn;\n                    if (!guard) {\n                        guard = true;\n                        trigger();\n                    }\n                };\n\n            })();\n\n        /**\n         * Provides cross-browser compatible scheduling methods.\n         * @class paychex.core.Schedulers\n         * @example\n         * var schedulers = Schedulers();\n         * schedulers.nextTick(function nextTick() {\n         *   log.info('next stack frame');\n         * });\n         * schedulers.immediate(function someFunction() {\n         *   log.info('end of the current stack frame');\n         * });\n         * // output:\n         * > end of the current stack frame\n         * > next stack frame\n         */\n        return {\n\n            /**\n             * Schedules the function to be invoked on the next stack frame.\n             * @member {Function} paychex.core.Schedulers#nextTick\n             * @example\n             * Schedulers().nextTick(function onNextFrame() {\n             *   log.info('this code happens on the next stack frame');\n             * });\n             */\n            nextTick: nextTick,\n\n            /**\n             * Schedules the function to be invoked at the end of the current stack frame.\n             * @member {Function} paychex.core.Schedulers#immediate\n             * @example\n             * Schedulers().immediate(function onEndFrame() {\n             *   log.info('this code happens at the end of the current stack frame');\n             * });\n             * @example\n             * Promise.config.setScheduler(Schedulers().immediate);\n             */\n            immediate: immediate\n\n        };\n\n    };\n\n});\n\n","define('paychex.core/signals/AutoResetSignal',[\n    './ManualResetSignal'\n], function(\n    ManualResetSignal\n) {\n\n    'use strict';\n\n    /**\n     * Allows developers to enforce mutual exclusion\n     * in a block of code. See the examples for details.\n     * @class paychex.app.common.AutoResetSignal\n     * @param {Boolean} [signaled=false] Whether the instance should start in the signaled state.\n     */\n    function AutoResetSignal(signaled) {\n        ManualResetSignal.call(this, signaled);\n    }\n\n    AutoResetSignal.prototype = new ManualResetSignal();\n    AutoResetSignal.prototype.constructor = AutoResetSignal;\n\n    /**\n     * Places the instance into a signaled state, permitting\n     * any blocked callers to proceed, then immediately resets\n     * the instance into an un-signaled state.\n     * @function paychex.app.common.AutoResetSignal#signal\n     * @example\n     * var throttle = new AutoResetSignal();\n     * throttle.waitOne().then(doSomething);\n     * throttle.waitOne().then(doSomethingElse);\n     * // ... do other stuff ...\n     * throttle.signal(); // invokes doSomething\n     * throttle.signal(); // invokes doSomethingElse\n     */\n    AutoResetSignal.prototype.signal = function signal() {\n        this.signaled = true;\n        if (this.queued.length) {\n            this.queued.shift().resolve();\n            this.reset();\n        }\n    };\n\n    /**\n     * Waits until the instance enters a signaled state before\n     * resolving. If the instance is already in a signaled state,\n     * the promise will be resolved immediately. Otherwise, the\n     * promise will be resolved in the order signal() is called.\n     * @function paychex.app.common.ManualResetSignal#waitOne\n     * @returns {Promise} A promise that will be resolved in the order waited on, one per signal.\n     * @example\n     * var throttle = new AutoResetSignal();\n     * throttle.waitOne().then(doSomething);\n     * throttle.waitOne().then(doSomethingElse);\n     * // ... do other stuff ...\n     * throttle.signal(); // invokes doSomething\n     * throttle.signal(); // invokes doSomethingElse\n     */\n    AutoResetSignal.prototype.waitOne = function waitOne() {\n        var promise = ManualResetSignal.prototype.waitOne.call(this);\n        if (promise.isResolved()) {\n            this.reset();\n        }\n        return promise;\n    };\n\n    return AutoResetSignal;\n\n});\n","define('paychex.core/signals/CountdownSignal',[\n    './ManualResetSignal'\n], function(\n    ManualResetSignal\n) {\n\n    'use strict';\n\n    /* jshint -W016 */\n    // using bitwise operators to cast numbers to integers\n\n    /**\n     * Allows developers to enforce mutual exclusion\n     * in a block of code. See the examples for details.\n     * @class paychex.app.common.CountdownSignal\n     * @param {Number} [initialCount=0] The initial value\n     *  of the internal counter. Once the counter hits 0,\n     *  the signal will be in an UN-blocked state, allowing\n     *  any queued callers to proceed and any future callers\n     *  to proceed. Once the counter is above 0, the signal\n     *  will be in a blocked state. Any future callers will\n     *  be queued until and unless the counter hits 0 again.\n     * @example\n     * // DownloadManager.js\n     * define(['paychex.app.common/utils/signals/CountdownSignal'], function(CountdownSignal) {\n     *\n     *   'use strict';\n     *\n     *   var filesToDownload = [];\n     *   var downloadSignal = new CountdownSignal();\n     *\n     *   function downloadFile(uri) {\n     *     filesToDownload.push(uri);\n     *     downloadSignal.increment();\n     *   }\n     *\n     *   function whenReady() {\n     *     return downloadSignal.waitOne();\n     *   }\n     *\n     *   function startDownloading() {\n     *     var uri = filesToDownload.shift();\n     *     !!uri && require([uri], function() {\n     *       // file download complete\n     *       downloadSignal.decrement();\n     *     });\n     *   }\n     *\n     *   setInterval(startDownloading, 100);\n     *\n     *   return {\n     *     whenReady: whenReady,\n     *     downloadFile: downloadFile\n     *   };\n     *\n     * });\n     *\n     * // caller.js:\n     * DownloadManager.downloadFile('/some/file/to/download');\n     * DownloadManager.whenReady().then(function allFilesDownloaded() {\n     *   // okay to proceed\n     * }).done();\n     */\n    function CountdownSignal(initialCount) {\n        Object.defineProperty(this, 'counter', {\n            value: Math.max(0, initialCount >> 0),\n            writable: true,\n            enumerable: false,\n            configurable: false\n        });\n        ManualResetSignal.call(this, this.counter === 0);\n    }\n\n    CountdownSignal.prototype = new ManualResetSignal();\n    CountdownSignal.prototype.constructor = CountdownSignal;\n\n    /**\n     * Decrements the signal counter. Once the counter hits 0,\n     * any blocked callers will be allowed to proceed. NOTE: the\n     * counter can never be less than 0.\n     * @function paychex.app.common.CountdownSignal#decrement\n     * @param {Number} [count=1] An optional amount to decrement by.\n     *  The number must be greater than or equal to 1.\n     * @example\n     * var counter = new CountdownSignal(5); // starts blocking\n     * counter.decrement();  // count = 4, still blocking\n     * counter.decrement(3); // count = 1, still blocking\n     * counter.decrement();  // count = 0, no longer blocking\n     * @example\n     * var counter = new CountdownSignal(); // starts unblocked\n     * counter.decrement(); // no effect, still unblocked\n     * counter.increment(3); // count = 3, now blocking\n     * counter.decrement(5); // count = 0, now unblocked\n     */\n    CountdownSignal.prototype.decrement = function decrement(count) {\n        var number = Math.max(count >> 0, 1);\n        this.counter = Math.max(0, this.counter - number);\n        if (this.counter === 0 && !this.signaled) {\n            ManualResetSignal.prototype.signal.call(this);\n        }\n    };\n\n    /**\n     * Increments the signal counter, which will place the\n     * signal into a blocked state.\n     * @function paychex.app.common.CountdownSignal#increment\n     * @param {Number} [count=1] An optional amount to increment by.\n     *  The number must be greater than or equal to 1.\n     * @example\n     * var signal = new CountdownSignal(); // counter = 0, unblocked\n     * signal.increment(); // counter = 1, now blocked\n     * signal.increment(4); // counter = 5, still blocked\n     * signal.decrement(2); // counter = 3, still blocked\n     */\n    CountdownSignal.prototype.increment = function increment(count) {\n        this.counter = this.counter + Math.max(count >> 0, 1);\n        ManualResetSignal.prototype.reset.call(this); // blocked\n    };\n\n    /**\n     * Does nothing. Use increment() and decrement() instead.\n     * @function paychex.app.common.CountdownSignal#signal\n     */\n    CountdownSignal.prototype.signal = function signal() {\n        // does nothing; call increment and decrement instead\n    };\n\n    /**\n     * Sets the counter back to 0, placing it in an unblocked state.\n     * @function paychex.app.common.CountdownSignal#reset\n     * @example\n     * var signal = new CountdownSignal(5); // count = 5, blocked\n     * signal.increment(); // count = 6, still blocked\n     * signal.decrement(3); // count = 3, still blocked\n     * signal.reset(); // count = 0, unblocked\n     */\n    CountdownSignal.prototype.reset = function reset() {\n        this.decrement(this.counter); // set back to 0, unblocked\n    };\n\n    return CountdownSignal;\n\n});\n","define('paychex.core/signals/ManualResetSignal',[\n    'lodash',\n    'paychex.core/Errors',\n    'paychex.core/Promise'\n], function(\n    _,\n    Errors,\n    Promise\n) {\n\n    'use strict';\n\n    /**\n     * Allows developers to enforce mutual exclusion\n     * in a block of code. See the examples for details.\n     * @class paychex.app.common.ManualResetSignal\n     * @param {Boolean} [signaled=false] Whether the instance should start in the signaled state.\n     */\n    function ManualResetSignal(signaled) {\n        this.queued = [];\n        this.signaled = !!signaled;\n    }\n\n    /**\n     * Sets the instance into an un-signaled state. Anyone\n     * calling waitOne or waitAll at this point will be blocked.\n     * @function paychex.app.common.ManualResetSignal#reset\n     */\n    ManualResetSignal.prototype.reset = function reset() {\n        this.signaled = false;\n    };\n\n    /**\n     * Sets the instance into a signaled state. All previous callers\n     * to waitOne will be allowed to proceed. Future callers will also\n     * be allowed to proceed, until and unless reset is called again.\n     * @function paychex.app.common.ManualResetSignal#signal\n     * @throws 'InvocationError' Cannot call signal twice.\n     * @example\n     * var throttle = new ManualResetSignal();\n     * throttle.waitOne().then(doSomething);\n     * throttle.waitOne().then(doSomethingElse);\n     * // ... do other stuff ...\n     * throttle.signal(); // invokes doSomething and doSomethingElse\n     * @example\n     * var throttle = new ManualResetSignal();\n     * throttle.waitOne().then(doSomething);\n     * throttle.signal(); // invokes doSomething\n     * throttle.reset(); // blocks future callers\n     * throttle.waitOne().then(doSomethingElse);\n     * throttle.signal(); // invokes doSomethingElse\n     */\n    ManualResetSignal.prototype.signal = function signal() {\n        if (this.signaled) {\n            Errors.throw(Errors.Types.Invocation, 'Cannot call signal twice.');\n        }\n        this.signaled = true;\n        while (this.queued.length && this.signaled) {\n            this.queued.shift().resolve();\n        }\n    };\n\n    /**\n     * Waits until the instance enters a signaled state before\n     * resolving. If the instance is already in a signaled state,\n     * the promise will be resolved immediately.\n     * @function paychex.app.common.ManualResetSignal#waitOne\n     * @returns {Promise} A promise that will be resolved when signal is called.\n     * @example\n     * var throttle = new ManualResetSignal();\n     * throttle.waitOne().then(doSomething);\n     * throttle.signal(); // invokes doSomething\n     * throttle.reset(); // blocks future callers\n     * throttle.waitOne().then(doSomethingElse);\n     * throttle.signal(); // invokes doSomethingElse\n     */\n    ManualResetSignal.prototype.waitOne = function waitOne() {\n        var defer, promise;\n        if (this.signaled) {\n            promise = Promise.resolve();\n        } else {\n            defer = Promise.defer();\n            this.queued.push(defer);\n            promise = defer.promise;\n        }\n        return promise;\n    };\n\n    return ManualResetSignal;\n\n});\n","define('paychex.core/StateMachine',[\n    'paychex.core/Utils',\n    'paychex.core/Errors',\n    'paychex.core/Promise',\n    'paychex.core/Validator',\n    'paychex.core/TriggerMixin'\n], function (\n    _,\n    Errors,\n    Promise,\n    Validator,\n    TriggerMixin\n) {\n\n    'use strict';\n\n    /**\n     * @author: Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2015-07-16\n     */\n\n    var NONE = 0;\n\n    /**\n     * @param {String} from The state name to transition from.\n     * @param {String} to The state name to transition to.\n     * @param {Object|Function} criteria An object specifying conditions\n     *  and values that must all match, or a function that will be invoked\n     *  with the current conditions and should return true (if the state\n     *  transition should occur) or false.\n     * @constructor\n     */\n    function Transition(from, to, criteria) {\n        this.from = from;\n        this.to = to;\n        this.criteria = criteria;\n    }\n\n    /**\n     * Represents a state for the StateMachine. A machine can only be\n     * in one state at a time.\n     * @typedef {Object} paychex.core.StateMachine~State\n     * @property {Function} [init] Always runs before execute is first invoked; it is NOT run\n     *  if execute fails and retry succeeds; in that case, execute is invoked again without init\n     *  being called.\n     * @property {Function} [execute] The main execution logic goes here. Values returned from execute\n     *  will be added to the `this.results` collection and made available to other states.\n     * @property {Function} [retry] If execute throws an exception or returns promise that is rejected,\n     *  retry will be invoked. Throwing an error or returning a rejected promise from this method tells\n     *  the machine NOT to re-run execute and to fail the machine (this is the default behavior). Any\n     *  other return value (or returning no value) will cause execute to be invoked again.\n     * @property {Function} [rollback] This method is called if any other state execute method fails\n     *  *and* this state was executed at some point.\n     * @property {Function} [failure] This method runs if any state in the machine fails, regardless of\n     *  whether or not this state was ever executed.\n     * @property {Function} [success] This method runs if the machine completes without error, regardless\n     *  of whether or not this state was ever executed.\n     */\n\n    /**\n     * Function that returns a State instance.\n     * @callback paychex.core.StateMachine~StateFunction\n     * @returns {paychex.core.StateMachine~State}\n     */\n\n    /**\n     * Function that determines if a state-change should occur.\n     * @callback paychex.core.StateMachine~Predicate\n     * @param {Object} state A key-value map of the machine's current state.\n     * @returns {Boolean} Whether a transition should occur, given the current machine state.\n     */\n\n    /**\n     * @function\n     * @private\n     * @param {paychex.core.StateMachine} machine The StateMachine instance.\n     * @param {Object} context The context in which to invoke the specified state methods.\n     * @param {Array.<String|paychex.core.StateMachine~State>} states The collection of states whose method should be invoked.\n     * @param {String} methodName The method on the state to invoke.\n     */\n    function invokeInContext(machine, context, states, methodName) {\n        var NUM_ARGS = 4,\n            args = _.toArray(arguments).slice(NUM_ARGS);\n        _([states])\n            .flatten()\n            .map(function getStateObject(state) {\n                if (_.isString(state)) {\n                    return machine.states[state];\n                }\n                return state;\n            })\n            .map(methodName)\n            .forEach(function invoke(method) {\n                _.attempt(_.spread(method.bind(context)), args);\n            });\n    }\n\n    /**\n     * @class paychex.core.StateMachine\n     * @mixes paychex.core.TriggerMixin\n     * @alias StateMachine\n     * @param {String} name The name of the state machine instance. NOTE: Unlike\n     *  workflows, there can be multiple StateMachine instances with the same\n     *  name; however, best practice is to use namespaces to clearly identify your\n     *  StateMachine instance.\n     * @throws Argument `name` must be provided.\n     */\n    function StateMachine(name) {\n\n        if (!_.isString(name) || _.isEmpty(name)) {\n            Errors.throw(Errors.Types.IllegalArgument, 'Argument `name` must be provided.');\n        }\n\n        var machine = this;\n\n        machine.current = {\n            state: null,\n            conditions: {},\n            results: {},\n            executed: [],\n            invocation: null,\n            withinState: false\n        };\n\n        machine.name = name;\n        machine.states = {};\n        machine.transitions = [];\n\n        TriggerMixin.apply(this);\n\n        /**\n         * @param {Boolean} withinState Whether the state is being entered (true) or left (false).\n         * @returns {Function} An event handler that sets the current `withinState` property to true or false.\n         * @private\n         **/\n        function getHandler(withinState) {\n            return function handler() {\n                machine.current.withinState = withinState;\n            };\n        }\n\n        machine.on(StateMachine.Events.STATE_ENTER, getHandler(true));\n        machine.on(StateMachine.Events.STATE_LEAVE, getHandler(false));\n\n    }\n\n    /**\n     * @returns {null | paychex.core.StateMachine~State} The next state to transition to, or `null` if no next state exists.\n     */\n    function getNextState() {\n\n        var machine = /* jshint -W040 */ this,\n            state = machine.current.state,\n            conditions = _.clone(machine.current.conditions),\n            transitions = _.filter(machine.transitions, {from: state.name}),\n            match = _.find(transitions, function matchesConditions(transition) {\n                return transition.criteria(conditions);\n            });\n\n        return !!match ? machine.states[match.to] : null;\n\n    }\n\n    function getStateMachineError(machine, reason) {\n        var args = ['StateMachineError', 'An error occurred in the state machine.', {\n            machine: machine.name,\n            state: machine.current.state.name,\n            executed: machine.current.executed,\n            conditions: machine.current.conditions,\n            handled: false\n        }];\n        if (!_.isError(reason)) {\n            args.unshift(Errors.get(reason));\n        } else {\n            args.unshift(reason);\n        }\n        return Errors.get.apply(null, args);\n    }\n\n    function handleError(machine, error) {\n        machine.trigger(StateMachine.Events.ERROR_OCCURRED, error);\n        return !!error.handled;\n    }\n\n    /**\n     * @param {paychex.core.StateMachine~State} state The state to transition to.\n     * @returns {Promise} A promise that is settled with the current state's execution.\n     */\n    function setCurrentState(state) {\n\n        var result,\n            machine = /* jshint -W040 */ this,\n\n            update = function update() {\n                var args = [].slice.call(arguments);\n                return machine.update.apply(machine, args);\n            },\n\n            signal = function signal() {\n                return machine.signal();\n            },\n\n            context = _.merge({}, state, {\n                args: machine.current.args,\n                results: machine.current.results,\n                machine: {\n                    name: machine.name,\n                    update: update,\n                    signal: signal,\n                    conditions: _.clone(machine.current.conditions),\n                    stop: function stop(value) {\n                        machine.results = _.merge({}, machine.results, value || {});\n                        machine.current.invocation.resolve(machine.results);\n                    }\n                }\n            }),\n\n            execute = function execute() {\n                machine.current.executed.push(state.name);\n                machine.current.executed = _.uniq(\n                    machine.current.executed\n                );\n                return Promise.call(state.execute.bind(context))\n                    .catch(function executeFailed(reason) {\n                        return Promise.call(state.retry.bind(context), reason).then(execute);\n                    });\n            },\n\n            fail = function fail(reason) {\n                var error = getStateMachineError(machine, reason);\n                if (handleError(machine, error)) {\n                    return;\n                }\n                invokeInContext(machine, context, machine.current.executed, 'rollback', reason);\n                invokeInContext(machine, context, _.keys(machine.states), 'failure', reason);\n                machine.current.invocation.reject(error);\n            },\n\n            setResult = function setResult(value) {\n                machine.current.results[state.name] = value;\n            },\n\n            finish = function finish() {\n                machine.trigger(StateMachine.Events.STATE_LEAVE, state.name);\n            };\n\n        machine.current.state = state;\n        machine.trigger(StateMachine.Events.STATE_ENTER, state.name);\n\n        result = Promise.call(state.init)\n            .then(execute)\n            .tap(setResult)\n            .catch(fail)\n            .finally(finish);\n\n        return result;\n\n    }\n\n    /**\n     * Adds the specified state definition to the StateMachine instance.\n     * @function paychex.core.StateMachine#addState\n     * @param {String} stateName The name of the state to add. State names\n     *  must be unique within a particular StateMachine instance.\n     * @param {paychex.core.StateMachine~State|paychex.core.StateMachine~StateFunction} stateDef An object literal whose keys\n     *  represent the state's lifecycle and whose key values are functions\n     *  to invoke during the state's lifecycle. All methods are optional.\n     *\n     *      {\n     *         init: function init() { ...called before the state executes... },\n     *         execute: function exec() { ...executes the state logic... },\n     *         retry: function retry() { ...called if execute fails... },\n     *         rollback: function init() { ...only called if the machine fails and execute ran... },\n     *         success: function init() { ...always called if the machine succeeds... },\n     *         failure: function init() { ...always called if the machine fails... }\n     *      }\n     *\n     *  If a function is provided, the function should return a state object\n     *  matching the above criteria.\n     *\n     *  All step functions have access to a `this` context which contains\n     *  the following properties:\n     *\n     *   - args {Array} Any arguments passed to the start() method.\n     *   - results {Object} The results of any previously executed states.\n     *   - machine {Object} A collection of the following properties and methods:\n     *     - name {String} The name of the machine instance this step belongs to.\n     *     - stop {Function} Method to invoke to successfully resolve the machine.\n     *     - update {Function} Method to invoke to transition to another state.\n     *     - conditions {Object} The current set of state conditions.\n     *\n     *  See the examples for more details.\n     * @throws Method `addState` expects a string and a function or object literal.\n     * @throws State `stateName` already exists.\n     * @throws A state name must be specified.\n     * @throws The state definition function did not return an object.\n     * @returns {paychex.core.StateMachine} The current StateMachine instance, for chaining.\n     * @example\n     * var machine = new StateMachine('my.machine.name')\n     *   .addState('start', {\n     *     var: '', // states can have instance members\n     *     init: function init() {\n     *       // this always runs before execute\n     *       // is first invoked; it is NOT run\n     *       // if execute fails and retry succeeds;\n     *       // in that case, execute is invoked\n     *       // again without init being called\n     *       this.var = 'initial value';\n     *     },\n     *     execute: function exec() {\n     *       if (this.machine.conditions.conditionA) {\n     *         this.var = 'condition A value';\n     *       } else {\n     *         this.var = 'some default value';\n     *       }\n     *       // values returned from execute\n     *       // will be added to the `this.results`\n     *       // collection and made available to\n     *       // other states\n     *       return 'results: ' + this.var;\n     *       // you can also return a Promise; if\n     *       // you return a Promise, the state will\n     *       // not complete until that promise\n     *       // instance resolves\n     *     },\n     *     retry: function retry() {\n     *       // throwing an error or returning\n     *       // a rejected promise tells the\n     *       // machine NOT to re-run execute\n     *       // and to fail the machine (this\n     *       // is the default behavior); any\n     *       // other return value will cause\n     *       // execute to be invoked again\n     *       return Promise.reject();\n     *     },\n     *     rollback: function rollback() {\n     *       // only called if the machine failed\n     *       // (e.g. some other step failed)\n     *       // and this step's execute method\n     *       // was invoked\n     *       this.var = 'initial value';\n     *     },\n     *     success: function success() {\n     *       log('the machine ran to completion');\n     *     },\n     *     failure: function failure(reason) {\n     *       log('some step failed', reason);\n     *     }\n     *   });\n     */\n    StateMachine.prototype.addState = function addState(stateName, stateDef) {\n\n        var stateToAdd = stateDef;\n\n        if (!Validator.validateArgs([stateName, stateDef], ['string', 'function|pojo'])) {\n            Errors.throw(\n                Errors.Types.IllegalArgument,\n                'Method `addState` expects a string and a function or object literal.'\n            );\n        }\n\n        if (stateName in this.states) {\n            Errors.throw(Errors.Types.Invocation, 'State already exists.', {stateName: stateName});\n        }\n\n        if (_.isEmpty(stateName)) {\n            Errors.throw(Errors.Types.IllegalArgument, 'A state name must be specified.');\n        }\n\n        if (_.isFunction(stateToAdd)) {\n            stateToAdd = stateToAdd();\n        }\n\n        if (!_.isPlainObject(stateToAdd)) {\n            Errors.throw(Errors.Types.IllegalArgument, 'The state definition function did not return an object.');\n        }\n\n        stateToAdd.name = stateName;\n\n        this.states[stateName] = _.merge({\n            init: _.noop,\n            execute: _.noop,\n            retry: Promise.reject,\n            success: _.noop,\n            failure: _.noop,\n            rollback: _.noop\n        }, stateToAdd);\n\n        return this;\n\n    };\n\n    /**\n     * Adds multiple states to the machine at once.\n     * @function paychex.core.StateMachine#addStates\n     * @param {Object.<String,paychex.core.StateMachine~State>} states An object literal whose keys represent\n     *  state names and whose values represent state objects (or\n     *  functions that return state objects). Each key-value pair\n     *  will be passed to the {@link paychex.core.StateMachine#addState\n     *  addState} method.\n     * @returns {paychex.core.StateMachine} The current StateMachine instance, for chaining.\n     * @example\n     * var machine = new StateMachine('my.machine.name')\n     *   .addStates({\n     *     start: { execute: function exec() { ... } },\n     *     next: function next() {\n     *       return {\n     *         execute: function exec() { ... },\n     *         success: function success() { ... }\n     *       };\n     *     }\n     *   });\n     */\n    StateMachine.prototype.addStates = function addStates(states) {\n\n        var machine = this;\n\n        _.forOwn(states, function addState(stateDef, stateName) {\n            machine.addState(stateName, stateDef);\n        });\n\n        return machine;\n\n    };\n\n    /**\n     * Defines a set of transition criteria that must be met to\n     * transition from one state to another.\n     * @function paychex.core.StateMachine.addTransition\n     * @param {String} fromState The state name to transition from.\n     * @param {String} toState The state name to transition to.\n     * @param {paychex.core.StateMachine~Predicate|Object} [criteria] The set of criteria that must be matched\n     *  before the transition will occur. Can be a function that accepts an object\n     *  representing the current state of the machine and returns true or false to\n     *  determine if the state transition should occur.\n     * @returns {paychex.core.StateMachine} The current StateMachine instance, for chaining.\n     * @example\n     * var machine = new StateMachine('my.machine.name')\n     *   .addState('init', { ... })\n     *   .addState('first', { ... })\n     *   .addState('second', { ... })\n     *   .addState('maybeA', { ... })\n     *   .addState('maybeB', { ... })\n     *   // set simple transitions:\n     *   .addTransition('init', 'first', {action: 'start'})\n     *   .addTransition('first', 'second', {action: 'continue'})\n     *   // set combination transitions:\n     *   .addTransition('second', 'maybeA', {action: 'maybe', a: true})\n     *   .addTransition('second', 'maybeB', {action: 'maybe', a: false})\n     *   // kick us off:\n     *   .start('init');\n     *\n     * // transition from 'init' to 'first':\n     * machine.update({action: 'start'});\n     *\n     * // transition from 'first' to 'second':\n     * machine.update({action: 'continue'});\n     *\n     * // this won't transition because both criteria were not met:\n     * machine.update({action: 'maybe'});\n     *\n     * // this will transition from 'second' to 'maybeB':\n     * // NOTE: updates are cumulative and do not overwrite\n     * // previously updated conditions unless explicitly\n     * // told to (see `update` documentation for details)\n     * machine.update({a: false});\n     * @example\n     * var machine = new StateMachine('my.machine.name')\n     *   .addState('init', { ... })\n     *   .addState('first', { ... })\n     *   .addTransition('init', 'first', function shouldGo(criteria) {\n     *     return criteria.action === 'proceed';\n     *   });\n     */\n    StateMachine.prototype.addTransition = function addTransition(fromState, toState, criteria) {\n\n        var localCriteria = criteria || {};\n\n        if (!Validator.validateArgs([fromState, toState, criteria], ['string', 'string', 'pojo?|function?'])) {\n            Errors.throw(\n                Errors.Types.IllegalArgument,\n                'Method `addTransition` expects 2 strings and an optional function or object literal.'\n            );\n        }\n\n        if (!_.isFunction(localCriteria)) {\n            localCriteria = _.matches(localCriteria);\n        }\n\n        this.transitions[this.transitions.length] = new Transition(fromState, toState, localCriteria);\n\n        return this;\n\n    };\n\n    /**\n     * Begins the state machine in the specified state.\n     * @function paychex.core.StateMachine#start\n     * @param{String}  stateName The state to start in.\n     * @param {Array} [args] An optional array of arguments. Steps can access these\n     *  arguments in their lifecycle methods through the `this.args` member.\n     * @param {Number} [timeout] An optional timeout (in milliseconds) to apply to\n     *  the StateMachine execution. If provided and the machine does not resolve before\n     *  the timeout elapses, the promise returned by this method will be rejected.\n     * @throws Method `start` expects a string and an optional array and timeout.\n     * @throws State `stateName` does not exist.\n     * @fires paychex.core.StateMachine#MACHINE_START\n     * @returns {Promise} A promise that is resolved when a state calls\n     *  `this.machine.stop()` or rejected if a step fails or the optional\n     *  timeout elapses. The promise will always be rejected with an instance of\n     *  StateMachineError containing information about the machine at the time the\n     *  error occurred, and whose causedBy property will either be the Error that\n     *  failed the machine or a PaychexError with a message describing the reason\n     *  for the failure.\n     * @example\n     * var machine = new StateMachine('my.machine.name')\n     *   .addState('start', { ... })\n     *   .addState('stop', { ... });\n     *\n     * machine.start('start', ['arg1', 'arg2'], 60000)\n     *   .then(function success(results) {\n     *     log('machine completed', results);\n     *   }, function failure(reason) {\n     *     log('machine failed', reason);\n     *   })\n     *   .done();\n     */\n    StateMachine.prototype.start = function start(stateName, args, timeout) {\n\n        var result,\n            nextState,\n            invocation,\n            machine = this,\n            localStateName = stateName;\n\n        if (!Validator.validateArgs([stateName, args, timeout], ['string', 'array?', 'number?'])) {\n            Errors.throw(\n                Errors.Types.IllegalArgument,\n                'Method `start` expects a string and an optional array and timeout.'\n            );\n        }\n\n        localStateName = _.sluggify('css', localStateName);\n        nextState = machine.states[localStateName];\n\n        if (!nextState) {\n            Errors.throw(Errors.Types.Invocation, 'State does not exist.', {stateName: localStateName});\n        }\n\n        invocation = Promise.defer();\n\n        machine.current.invocation = invocation;\n        machine.current.args = (args || []).concat();\n\n        /**\n         * Invokes the `success` method on every state in the machine.\n         * @param {*} results The results from each state.\n         * @returns {undefined}\n         */\n        function success(results) {\n            invokeInContext(machine, {\n                args: machine.current.args,\n                results: machine.current.results,\n                machine: {\n                    name: machine.name,\n                    stop: _.noop,\n                    update: _.noop,\n                    signal: _.noop,\n                    conditions: _.clone(machine.current.conditions)\n                }\n            }, _.keys(machine.states), 'success', results);\n        }\n\n        /**\n         * Sets the machine into the STOPPED state.\n         * @param {* | Error} resultsOrError The results of the state machine, or the error if a state failed.\n         * @returns {undefined}\n         */\n        function complete(resultsOrError) {\n            machine.trigger(StateMachine.Events.MACHINE_STOP, resultsOrError);\n        }\n\n        result = invocation.promise;\n\n        if ((timeout || NONE) > NONE) {\n            result = result.timeout(timeout);\n        }\n\n        result = result.tap(success)\n            .finally(complete);\n\n        machine.trigger(StateMachine.Events.MACHINE_START, {\n            name: machine.name,\n            args: machine.current.args,\n            promise: machine.current.invocation.promise\n        });\n\n        setCurrentState.call(machine, nextState);\n\n        return result;\n\n    };\n\n    /**\n     * Updates the current set of conditions used by the machine\n     * to determine state transitions. If the machine is started\n     * and the current set of conditions matches any of the pre-\n     * defined transitions, a transition will be made.\n     * @function paychex.core.StateMachine#update\n     * @param {Object} conditions An object literal containing\n     *  key-value pairs.\n     * @param {Boolean} [overwrite=false] If truthy, the incoming\n     *  set of conditions will overwrite any previously set\n     *  conditions. The default is to merge the incoming set of\n     *  conditions with any previously set conditions.\n     * @returns {Promise} A promise that is resolved\n     *  when the state change occurs, or resolved immediately if\n     *  no state change would occur.\n     * @example\n     * var machine = new StateMachine('my.machine.name')\n     *   .addState('start', { ... })\n     *   .addState('stop', { ... })\n     *   .addTransition('start', 'stop', {\n     *      a: true,\n     *      b: false\n     *   });\n     *\n     * // no transition will occur because the machine\n     * // has not yet been started:\n     * machine.update({b: false}).then(function() {\n     *   log(machine.current.state); // null\n     * });\n     *\n     * // once started, the machine can be updated:\n     * machine.start('start').done();\n     *\n     * // stays in the `start` state because both\n     * // conditions have not yet been met:\n     * machine.update({a: true}).then(function() {\n     *   log(machine.current.state.name); // 'start'\n     * });\n     *\n     * // stays in the 'start' state because we\n     * // just overwrote the existing conditions\n     * // with these new conditions:\n     * machine.update({b: false}, true).then(function() {\n     *   log(machine.current.state.name); // 'start'\n     * });\n     *\n     * // transitions to 'stop' state because now\n     * // we merge the incoming conditions with\n     * // the previously set conditions, and the\n     * // combination matches the transition criteria\n     * // we defined for transitioning from 'start'\n     * // to 'stop':\n     * machine.update({a: true}).then(function() {\n     *   log(machine.current.state.name); // 'stop'\n     * });\n     */\n    StateMachine.prototype.update = function update(conditions, overwrite) {\n\n        if (!Validator.validateArgs([conditions, overwrite], ['pojo', 'boolean?'])) {\n            Errors.throw(\n                Errors.Types.IllegalArgument,\n                'Method `update` expects an object literal and optional boolean.'\n            );\n        }\n\n        if (!!overwrite) {\n            this.current.conditions = conditions;\n        } else {\n            _.merge(this.current.conditions, conditions);\n        }\n\n        /* eslint \"vars-on-top\": 0 */\n        var defer,\n            machine = this,\n            machineStarted = !!machine.current.invocation,\n            withinState = machine.current.withinState;\n\n        if (!machineStarted) {\n            return Promise.resolve();\n        }\n\n        /**\n         * Try to move to the next state.\n         * @returns {Promise} A promise that will be settled with the\n         *  results of attempting to set the next state.\n         */\n        function tryMoveNext() {\n            var nextState = getNextState.call(machine);\n            if (!!nextState) {\n                return setCurrentState.call(machine, nextState);\n            }\n            return Promise.resolve();\n        }\n\n        if (!withinState) {\n            return tryMoveNext();\n        } else {\n            // we can't use Promise constructor pattern here because it\n            // executes on the next clock tick, and the current state\n            // could change in the meantime; to prevent this timing issue,\n            // we need to subscribe to the STATE_LEAVE event immediately\n            defer = Promise.defer();\n            machine.one(StateMachine.Events.STATE_LEAVE, function leftCurrentState() {\n                tryMoveNext()\n                    .then(defer.resolve, defer.reject)\n                    .catch()\n                    .done();\n            });\n            return defer.promise;\n        }\n\n    };\n\n    /**\n     * Tell the state machine to evaluate any current conditions and\n     * proceed to the next state, if any matches.\n     * @function paychex.core.StateMachine#signal\n     * @returns {Promise} A promise that is resolved\n     *  when the state change occurs, or resolved immediately if\n     *  no state change would occur.\n     */\n    StateMachine.prototype.signal = function signal() {\n        return this.update({}, false);\n    };\n\n    /**\n     * @function paychex.core.StateMachine#waitForState\n     * @param {String} stateName The name of the state to wait for.\n     * @returns {Promise} A promise that will be resolved if the\n     *  machine is currently in the requested state or when the\n     *  machine moves into the requested state.\n     * @example\n     * var machine = new StateMachine('my.machine.name')\n     *   .addState('start', { ... })\n     *   .addState('stop', { ... })\n     *   .start('start');\n     *\n     * machine.waitForState('start').then(function() {\n     *   log('machine already in start state');\n     * }).done();\n     *\n     * machine.waitForState('stop').timeout(10000).catch(function() {\n     *   log('machine did not stop within 10 seconds');\n     * }).done();\n     */\n    StateMachine.prototype.waitForState = function waitForState(stateName) {\n        var defer,\n            unsubscribe,\n            machine = this;\n        if (!!this.current.state && this.current.state.name === stateName) {\n            return Promise.resolve(stateName);\n        }\n        // switch to defer; fixes defect where if the machine starts\n        // after waitForState is called, the old promise constructor\n        // would subscribe to the state-enter event on the next clock\n        // tick, missing the initial state and never resolving this\n        // promise; using defer allows us to subscribe immediately\n        defer = Promise.defer();\n        unsubscribe = machine.on(StateMachine.Events.STATE_ENTER,\n            function resolvePromise(e) {\n                if (e.args[0] === stateName) {\n                    defer.resolve(stateName);\n                    unsubscribe();\n                }\n            });\n        return defer.promise;\n    };\n\n    /**\n     * @member paychex.core.StateMachine.Events\n     * @type {{MACHINE_START: string, MACHINE_STOP: string, STATE_ENTER: string, STATE_LEAVE: string}}\n     */\n    StateMachine.Events = {\n        MACHINE_START: 'machine-start',\n        MACHINE_STOP: 'machine-stop',\n        STATE_ENTER: 'state-enter',\n        STATE_LEAVE: 'state-leave',\n        ERROR_OCCURRED: 'error-occurred'\n    };\n\n    /**\n     * Fires when [start]{@link paychex.core.StateMachine#start} is called.\n     * @event paychex.core.StateMachine#MACHINE_START\n     * @type {Object}\n     * @property {string} name The name of the state machine.\n     * @property {Array} args Any optional arguments passed to start.\n     * @property {Promise} promise A promise that represents the current invocation\n     *  and will be resolved or rejected when the machine settles.\n     */\n\n    /**\n     * Fires when the machine dispatch settles. Handlers should examine the single\n     * argument to see if it is an Error instance. If not an Error, it will be a map\n     * of state names to the value returned by the state execute method.\n     * @event paychex.core.StateMachine#MACHINE_STOP\n     * @type {Object|Error}\n     */\n\n    /**\n     * Fires each time the machine enters a state. The single argument is the state name entered.\n     * @event paychex.core.StateMachine#STATE_ENTER\n     * @type {String}\n     */\n\n    /**\n     * Fires each time the machine leaves a state. The single argument is the state name left.\n     * @event paychex.core.StateMachine#STATE_LEAVE\n     * @type {String}\n     */\n\n    /**\n     * Fires when a machine encounters an error and is about to fail.\n     * @event paychex.core.StateMachine#ERROR_OCCURRED\n     * @type {Error}\n     */\n\n    return StateMachine;\n\n});\n\n","define('paychex.core/stores/AsyncStore',[\n    'lodash',\n    'paychex.core/Errors',\n    'paychex.core/Validator',\n    'paychex.core/stores/Store'\n], function (\n    _,\n    Errors,\n    Validator,\n    Store\n) {\n\n    'use strict';\n\n    /**\n     * @author: Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2017-01-26\n     */\n\n    /**\n     * Represents an asynchronous data store to set and retrieve key/value pairs.\n     * @class paychex.core.stores.AsyncStore\n     * @implements {paychex.core.stores.IStore}\n     * @param {Promise} ready Promise that will be resolved when it is safe to use the AsyncStore instance.\n     * @param {paychex.core.stores.AsyncStore~AsyncGet} get The getter function to retrieve a named value.\n     * @param {paychex.core.stores.AsyncStore~AsyncSet} set The setter function to persist a name/value pair.\n     * @param {paychex.core.stores.AsyncStore~AsyncRemove} remove A function to remove the value for the specified name.\n     * @param {paychex.core.stores.AsyncStore~AsyncClear} clear A function to remove all stored entries.\n     * @param {paychex.core.stores.AsyncStore~AsyncItems} items A function to return all stored entries.\n     * @param {paychex.core.stores.AsyncStore~AsyncObserve} observe Returns an observable that will receive updates\n     *  for the specified key.\n     * @throws AsyncStore requires 6 functions to be provided: get, set, remove, clear, items, and observe.\n     */\n    function AsyncStore(ready, get, set, remove, clear, items, observe) {\n\n        /**\n         * @callback paychex.core.stores.AsyncStore~AsyncGet\n         * @param {String} key The key to retrieve.\n         * @param {*} [defaultValue] An optional default value to return if the key does not exist in the store.\n         * @returns {Promise.<*>} A promise that will be resolved with the value in the store for the specified key.\n         */\n\n        /**\n         * @callback paychex.core.stores.AsyncStore~AsyncObserve\n         * @param {String} key The key to observe.\n         * @returns {Observable} An observable that should notify subscribers every time the value is changed.\n         */\n\n        /**\n         * @callback paychex.core.stores.AsyncStore~AsyncSet\n         * @param {String} key The key to store.\n         * @param {*} value The value to store for the specified key.\n         * @returns {Promise} A Promise that will be resolved or rejected when the operation completes.\n         */\n\n        /**\n         * @callback paychex.core.stores.AsyncStore~AsyncRemove\n         * @param {String} key The key to remove.\n         * @returns {Promise} A promise that will be resolved or rejected when the operation completes.\n         */\n\n        /**\n         * @callback paychex.core.stores.AsyncStore~AsyncClear\n         * @returns {Promise} A promise that will be resolved or rejected when the operation completes.\n         */\n\n        /**\n         * @callback paychex.core.stores.AsyncStore~AsyncItems\n         * @returns {Promise.<Array.<*>>} A promise that will be resolved with an array of items in the store. The\n         *  actual format of the items may depend on the store implementation. Refer to the specific AsyncStore\n         *  subclass documentation for details.\n         */\n\n        if (!Validator.validateArgs(arguments, ['object'].concat(_.fill(new Array(6), 'function')))) {\n            Errors.throw(\n                Errors.Types.IllegalArgument,\n                'AsyncStore requires a Promise and 6 functions to be provided: ready, get, set, remove, clear, items, and observe.'\n            );\n        }\n\n        /**\n         * Resolves when the AsyncStore instance is safe to use.\n         * @type {Promise}\n         */\n        this.ready = ready;\n\n        /**\n         * Retrieves the specified item.\n         * @type {paychex.core.stores.AsyncStore~AsyncGet}\n         */\n        this.get = get;\n\n        /**\n         * Stores the value for the specified item.\n         * @type {paychex.core.stores.AsyncStore~AsyncSet}\n         */\n        this.set = set;\n\n        /**\n         * Removes the specified item, if it exists.\n         * @type {paychex.core.stores.AsyncStore~AsyncRemove}\n         */\n        this.remove = remove;\n\n        /**\n         * Removes any and all items in the store.\n         * @type {paychex.core.stores.AsyncStore~AsyncClear}\n         */\n        this.clear = clear;\n\n        /**\n         * Retrieves all items in the store as an array of key/value pairs.\n         * @type {paychex.core.stores.AsyncStore~AsyncItems}\n         */\n        this.items = items;\n\n        /**\n         * Subscribe to changes for the specified key.\n         * @type {paychex.core.stores.AsyncStore~AsyncObserve}\n         */\n        this.observe = observe;\n\n    }\n\n    AsyncStore.isAsyncStore = function isAsyncStore(store) {\n        return Store.isStore(store) && _.hasIn(store, 'ready') && _.hasIn(store, 'observe');\n    };\n\n    return AsyncStore;\n\n});\n\n","define('paychex.core/stores/CookieStorage',[\n    'lodash',\n    'paychex.core/stores/Store',\n    'paychex.core/Errors'\n], function (\n    _,\n    Store,\n    Errors\n) {\n\n    /**\n     * @author Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2014-05-29\n     */\n\n    'use strict';\n\n    var SKIP_CHAR = 1,\n        COOKIE_DOMAIN = '', // TODO: .paychex.com\n        INVALID_CHARS = /[=;,\\t]+/g,\n        ErrorMessages = {\n            STORE_GET: 'Store.get requires a name string to be provided.',\n            STORE_SET: 'Store.set requires a name string and value to be provided. ' +\n                'A null value is not valid; to clear an existing value, call ' +\n                'Store.remove() and pass in the name of the item to be removed',\n            STORE_REMOVE: 'Store.remove requires a name string to be provided.'\n        };\n\n    // remove invalid cookie characters\n    function replaceInvalidChars(part) {\n        return part.replace(INVALID_CHARS, '-');\n    }\n\n    function getName(cookie) {\n        return _(cookie)\n            .split('=')\n            .head()\n            .trim();\n    }\n\n    function setValueForName(name, value, options) {\n        var expired = options.expires && new Date(options.expires) < new Date(),\n            cookie = name + '=' + (expired ? '' : value);\n        _.forOwn(options, function addToCookie(option, key) {\n            if (!!option && option.length) {\n                cookie += ';' + key + '=' + option;\n            }\n        });\n        document.cookie = cookie;\n    }\n\n    function getValueForName(name) {\n        return _(document.cookie)\n            .split(';')\n            .filter(function isMatchingCookie(cookie) {\n                return _.startsWith(cookie.trim(), name);\n            })\n            .map(function formatJSONValue(cookie) {\n                var value,\n                    json = cookie.trim().substring(name.length);\n                if (_.startsWith(json, '\"{') || _.startsWith(json, '{')) {\n                    if (_.startsWith(json, '\"')) {\n                        json = json.slice(SKIP_CHAR, -SKIP_CHAR)\n                            .replace(/\\\\\"/g, '\"');\n                    }\n                }\n                value = _.attempt(JSON.parse, json);\n                if (_.isError(value)) {\n                    return json;\n                }\n                return value;\n            })\n            .head();\n    }\n\n    /**\n     * Retrieves a persisted value using the specified key name.\n     * @function paychex.core.stores.CookieStorage#get\n     * @param {String} name The name of the stored key/value pair to retrieve.\n     * @returns {(*|undefined)} The original value that was stored for the specified key name,\n     *  or `undefined` if no value was found.\n     */\n    function get(name) {\n        if (!_.isString(name)) {\n            Errors.throw(Errors.Types.IllegalArgument, ErrorMessages.STORE_GET);\n        }\n        return getValueForName(replaceInvalidChars(name) + '=');\n    }\n\n    /**\n     * Persists a value using the specified key name. The value can be retrieved\n     * later using the {@link paychex.core.stores.CookieStorage#get get} method. To remove a value,\n     * *do not* provide a `null` value; instead, call the {@link\n            paychex.core.stores.CookieStorage#remove remove} method.\n     * @function paychex.core.stores.CookieStorage#set\n     * @param {String} name The name of the value to store. This can be used to\n     *  retrieve the value later, using {@link paychex.core.stores.Store#get get}.\n     * @param {Object} value The value to persist. Will be converted to a string.\n     * @param {Object} [options] An optional map of key/value pairs to append to\n     *  the cookie. The default options are `{path: '/', domain: '.paychex.com'}`.\n     *  Additional parameters include `max-age`, `expires`, and `secure`.\n     * @returns {undefined}\n     */\n    function set(name, value, options) {\n        if (!_.isString(name) || _.isNil(value)) {\n            Errors.throw(Errors.Types.IllegalArgument, ErrorMessages.STORE_SET);\n        }\n        var itemName = replaceInvalidChars(name),\n            itemValue = _.isString(value) ?\n                replaceInvalidChars(value) :\n                JSON.stringify(value);\n        if (!!itemName.length) {\n            setValueForName(itemName, itemValue, _.merge({\n                path: '/',\n                domain: COOKIE_DOMAIN\n            }, options));\n        }\n    }\n\n    /**\n     * Removes any values stored for the specified key.\n     * @function paychex.core.stores.CookieStorage#remove\n     * @param {String} name The key to remove from storage.\n     * @param {Object} [options] An optional map of cookie properties\n     *  that were passed to {@link paychex.core.stores.Store#set set}. The default\n     *  options are `{path: '/', domain: '.paychex.com'}`. Additional\n     *  parameters include `max-age`, `expires`, and `secure`.\n     * @returns {undefined}\n     */\n    function remove(name, options) {\n        if (!_.isString(name)) {\n            Errors.throw(Errors.Types.IllegalArgument, ErrorMessages.STORE_REMOVE);\n        }\n        setValueForName(replaceInvalidChars(name), '', _.merge({\n            path: '/',\n            domain: COOKIE_DOMAIN,\n            expires: 'Thu, 01-Jan-1970 00:00:01 GMT'\n        }, options));\n    }\n\n    /**\n     * Removes all name/value pairs persisted in this Store.\n     * @function paychex.core.stores.CookieStorage#clear\n     * @returns {undefined}\n     */\n    function clear() {\n        _(document.cookie)\n            .split(';')\n            .map(getName)\n            .forEach(remove);\n    }\n\n    /**\n     * Returns an array of all cookie name/values persisted in this store.\n     * @function paychex.core.stores.CookieStorage#items\n     * @returns {paychex.core.stores.NameValuePair[]} An array of objects with name and value properties.\n     */\n    function items() {\n        return _(document.cookie)\n            .split(';')\n            .map(function getNameValuePair(cookie) {\n                var name = getName(cookie);\n                return {\n                    name: name,\n                    value: getValueForName(name + '=')\n                };\n            })\n            .filter(function isDefined(kvp) {\n                return !!kvp.name;\n            })\n            .value();\n    }\n\n    /**\n     * @class paychex.core.stores.CookieStorage\n     * @inherits paychex.core.stores.Store\n     * @see paychex.core.stores.Store\n     * @description Stores data in the `document.cookies` collection. An instance of the\n     * {@link paychex.core.stores.Store Store} object. Available through the {@link paychex.core.Repository Repository}\n     * instance.\n     */\n    return new Store(get, set, remove, clear, items);\n\n});\n\n","define('paychex.core/stores/EmptyStore',['lodash'], function(_) {\n\n    /**\n     * @author: Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2016-01-29\n     */\n\n    'use strict';\n\n    /**\n     * Provides a {@link paychex.core.stores.IStore} implementation that\n     * does not actually save any state. No values will ever be\n     * returned by `get`, and `set` has no effect. This entire\n     * class acts a null-type value.\n     * @class paychex.core.stores.EmptyStore\n     * @implements {paychex.core.stores.IStore}\n     */\n    function EmptyStore() {\n        _.forEach(['get', 'set', 'remove', 'clear'], function addInterfaceMethods(method) {\n            this[method] = Function.prototype;\n        }.bind(this));\n        this.items = function getItems() {\n            return [];\n        };\n\n        // ['get', 'set', 'remove', 'clear'].forEach(function(method) {\n        //     this[method] = Function.prototype; // no op\n        // }.bind(this));\n        // this.items = function getItems() { return []; };\n    }\n\n    /**\n     * A static singleton that can be used anywhere.\n     * @member paychex.core.stores.EmptyStore.instance\n     * @type {paychex.core.stores.EmptyStore}\n     */\n    EmptyStore.instance = new EmptyStore();\n\n    return EmptyStore;\n\n});\n\n","define('paychex.core/stores/HTML5Storage',[\n    'lodash',\n    'paychex.core/Errors',\n    'paychex.core/stores/Store'\n], function (\n    _,\n    Errors,\n    Store\n) {\n\n    /**\n     * @author Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2014-05-29\n     */\n\n    'use strict';\n\n    var INVALID_CHARS = /[^(\\u0020-\\uD7FF)|(\\uE000-\\uFFFD)|\\u0009|\\u000A|\\u000D]+/g,\n        ErrorMessages = {\n            STORE_GET: 'Store.get requires a name string to be provided.',\n            STORE_SET: 'Store.set requires a name string and value to be provided. ' +\n                'A null value is not valid; to clear an existing value, call ' +\n                'Store.remove() and pass in the name of the item to be removed',\n            STORE_REMOVE: 'Store.remove requires a name string to be provided.'\n        };\n\n    return function HTML5Storage(storage) {\n\n        // replace invalid characters with a hyphen, per this StackOverflow question:\n        // http://stackoverflow.com/questions/11170716/are-there-any-characters-that-are-not-allowed-in-localstorage\n        function replaceInvalidChars(input) {\n            return input.replace(INVALID_CHARS, '-');\n        }\n\n        function getValueFromName(name) {\n            var val = storage.getItem(name),\n                res = _.attempt(JSON.parse, val);\n            if (_.isError(res)) {\n                return val;\n            }\n            return res === null ? undefined : res;\n        }\n\n        /**\n         * An instance of the {@link paychex.core.stores.Store Store} object. Acts as a base class for\n         * {@link paychex.core.stores.LocalStorage LocalStorage} and {@link paychex.core.stores.SessionStorage SessionStorage}.\n         *\n         * **NOTE:** HTML5 storage is available on IE8+, Firefox, Opera, Chrome, and Safari.\n         * @class paychex.core.stores.HTML5Storage\n         * @inherits paychex.core.stores.Store\n         * @see paychex.core.stores.Store\n         * @param {Object} storage The HTML5 storage object to use. E.g. `window.sessionStorage`.\n         */\n        return new Store(\n\n            /**\n             * Retrieves a persisted value using the specified key name.\n             * @function paychex.core.stores.HTML5Storage#get\n             * @param {String} name The name of the stored key/value pair to retrieve.\n             * @returns {*|Undefined} The original value that was stored for the specified key name,\n             *  or `undefined` if no value was found.\n             */\n            function get(name) {\n                if (!_.isString(name)) {\n                    Errors.throw(Errors.Types.IllegalArgument, ErrorMessages.STORE_GET);\n                }\n                var itemName = replaceInvalidChars(name);\n                if (!!itemName && itemName.length) {\n                    return getValueFromName(itemName);\n                }\n            },\n\n            /**\n             * Persists a value using the specified key name. The value can be retrieved\n             * later using the {@link paychex.core.stores.HTML5Storage#get get} method. To remove a value,\n             * *do not* provide a `null` value; instead, call the {@link paychex.core.stores.HTML5Storage#remove remove}\n             * method.\n             * @function paychex.core.stores.HTML5Storage#set\n             * @param {String} name The name of the value to store. This can be used to\n             *  retrieve the value later, using {@link paychex.core.stores.Store#get get}.\n             * @param {Object} value The value to persist. Will be converted to a string.\n             * @returns {undefined}\n             */\n            function set(name, value) {\n                if (!_.isString(name) || _.isNil(value)) {\n                    Errors.throw(Errors.Types.IllegalArgument, ErrorMessages.STORE_SET);\n                }\n                var itemName = replaceInvalidChars(name),\n                    itemValue = _.isString(value) ?\n                        replaceInvalidChars(value) :\n                        JSON.stringify(value);\n                if (!!itemName.length) {\n                    storage.setItem(itemName, itemValue);\n                }\n            },\n\n            /**\n             * Removes any values stored for the specified key.\n             * @function paychex.core.stores.HTML5Storage#remove\n             * @param {String} name The key to remove from storage.\n             * @returns {undefined}\n             */\n            function remove(name) {\n                if (!_.isString(name)) {\n                    Errors.throw(Errors.Types.IllegalArgument, ErrorMessages.STORE_REMOVE);\n                }\n                var item = replaceInvalidChars(name);\n                if (!!item && item.length) {\n                    storage.removeItem(item);\n                }\n            },\n\n            /**\n             * Removes all name/value pairs persisted in this Store.\n             * @function paychex.core.stores.HTML5Storage#clear\n             * @returns {undefined}\n             */\n            function clear() {\n                storage.clear();\n            },\n\n            /**\n             * Returns an array of all items persisted in this store.\n             * @function paychex.core.stores.HTML5Storage#items\n             * @returns {paychex.core.stores.NameValuePair[]} An array of objects with name and value properties.\n             */\n            function items() {\n                return _(storage.length)\n                    .range()\n                    .map(function getKVP(index) {\n                        var key = storage.key(index);\n                        return {\n                            name: key,\n                            value: getValueFromName(key)\n                        };\n                    })\n                    .value();\n            }\n\n        );\n\n    };\n\n});\n\n","define('paychex.core/stores/IndexedDBStore',[\n    'lodash',\n    'lib.rxjs',\n    'paychex.core/Errors',\n    'paychex.core/Promise',\n    'paychex.core/stores/AsyncStore'\n], function (\n    _,\n    Rx,\n    Errors,\n    Promise,\n    AsyncStore\n) {\n\n    'use strict';\n\n    /**\n     * @author: Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2017-01-26\n     */\n\n    function setPrefixedGlobal(name, defaultValue) {\n        if (name in window) {\n            return;\n        }\n        var proper = name[0].toUpperCase() + name.slice(1);\n        window[name] = window[name] || window['moz' + proper] || window['webkit' + proper] || window['ms' + proper] || defaultValue;\n    }\n\n    setPrefixedGlobal('indexedDB');\n    setPrefixedGlobal('IDBKeyRange');\n    setPrefixedGlobal('IDBTransaction', {READ_WRITE: 'readwrite'});\n\n    /**\n     * See https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase for more information.\n     * @typedef {Object} IDBDatabase\n     * @property {Function} transaction\n     */\n\n    /**\n     * @typedef {Object} IDBTransaction\n     * @property {Function} objectStore\n     */\n\n    /**\n     * @typedef {Object} IDBCursor\n     * @property {Function} continue\n     */\n\n    /**\n     * @callback paychex.core.stores.IndexedDBStore~CreateUpgradeCallback\n     * @param {IDBDatabase} database The database that should either be created or upgraded. See\n     *  https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase for more information.\n     */\n\n    /**\n     * @typedef {Object} paychex.core.stores.IndexedDBStore~Meta\n     * @property {String} objectStore The name of the object store to open.\n     * @property {String} [database=Paychex] The name of the database to open.\n     * @property {Number} [version=1] The version of the database to open. Must be a positive 64-bit integer.\n     * @property {paychex.core.stores.IndexedDBStore~CreateUpgradeCallback} createUpgrade A callback that\n     *  will be invoked when the underlying database needs to be created *or* upgraded. You should check the `version`\n     *  and/or `objectStoreNames` members of the database instance passed to your handler to determine how to proceed.\n     *  See https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase for more information.\n     */\n\n    /**\n     * @class paychex.core.stores.IndexedDBStore\n     * @extends paychex.core.stores.AsyncStore\n     * @param {paychex.core.stores.IndexedDBStore~Meta} meta Information needed to access the database.\n     * @throws Parameter `version` must be a positive integer.\n     * @example\n     * require([\n     *     'paychex.core/stores/IndexedDBStore',\n     *     'paychex.framework.angular.data/caching/EncryptedStoreWrapper'\n     * ], function(\n     *     IDBStore,\n     *     EncryptedStoreWrapper\n     * ) {\n     *\n     *     var store = new IDBStore({\n     *         database: 'paychex',\n     *         objectStore: 'my-objects',\n     *         createUpgrade: function upgradeRequired(db) {\n     *             if (!db.objectStoreNames.contains('my-objects')) {\n     *                 db.createObjectStore('my-objects');\n     *             } else {\n     *                 // version upgrade required\n     *             }\n     *         }\n     *     });\n     *\n     *     store.ready.then(function onStoreReady() {\n     *\n     *         store.set('unique-key', {key: 'some value', anotherKey: 123})\n     *             .then(function objectSet(result) {\n     *                 log('set successful', JSON.stringify(result));\n     *                 return store.get('unique-key')\n     *                     .then(function objectGet(obj) {\n     *                         log('get successful', JSON.stringify(obj));\n     *                     });\n     *             })\n     *             .catch(function errorOccurred(err) {\n     *                 log('could not set or get object:', err);\n     *             });\n     *\n     *         Promise.all([\n     *             store.set('def', {someKey: 'def value'}),\n     *             store.set('ghi', {someKey: 'ghi value'})\n     *         ]).then(function() {\n     *             return store.items().tap(function(result) {\n     *                 log('store items:', result);\n     *             });\n     *         });\n     *\n     *         store.observe('abc')\n     *             .subscribe(function(value) {\n     *                 log('current value for abc:', value);\n     *             });\n     *\n     *         return store.set('abc', {value: 'brand new value'})\n     *             .then(function() {\n     *                 return Promise.all([\n     *                     store.remove('ghi'),\n     *                     store.remove('def')\n     *                 ]).then(function() {\n     *                     log('removed 2 items');\n     *                     return store.clear().tap(function() {\n     *                         log('store cleared');\n     *                     });\n     *                 });\n     *             });\n     *         });\n     *\n     *     });\n     *\n     *     var encrypted = new EncryptedStoreWrapper(store, 'AES-CBC');\n     *\n     *     encrypted.ready.then(function testEncrypted() {\n     *\n     *         return encrypted.set('key', {secret: 'this is uber secret!'})\n     *             .then(function(value) {\n     *                 log('encrypted value:', value);\n     *                 return encrypted.get('encrypted')\n     *                     .tap(function(result) {\n     *                         log('decrypted value:', result);\n     *                     });\n     *             });\n     *\n     *     });\n     *\n     * });\n     */\n    return function IndexedDBStore(meta) {\n\n        if (_.isUndefined(this)) {\n            Errors.throw(Errors.Types.Invocation, 'Please use `new` to construct an instance of IndexedDBStore.');\n        }\n\n        if (!_.isObject(meta) || !_.isString(meta.objectStore) || _.isEmpty(meta.objectStore.trim())) {\n            Errors.throw(Errors.Types.IllegalArgument, 'Property `objectStore` on `meta` argument is required.');\n        }\n\n        var /** @type {IDBDatabase} */ db,\n            transactionStrategy,\n            subjects = {},\n            version = _.get(meta, 'version', 1),\n            database = _.get(meta, 'database', 'Paychex');\n\n        if (!_.isSafeInteger(version) || version < 1) {\n            Errors.throw(Errors.Types.IllegalArgument, 'Parameter `version` must be a positive integer.');\n        }\n\n        /**\n         * @callback IDBSuccessHandler\n         * @param {Function} resolve A method to invoke to resolve the transaction promise.\n         * @param {Function} reject A method to invoke to reject the transaction promise.\n         * @param {*} [result] The optional result of the IDBDataStore operation.\n         */\n\n        /**\n         * Encapsulates basic IndexedDB transaction logic, including connecting to the object store,\n         * invoking the specified method, and handling any errors that might occur.\n         * @param {String} mode Either 'readonly' or 'readwrite', depending on the access level required for the method.\n         * @param {String} method The name of the IDBObjectStore method to invoke.\n         * @param {Array} args The arguments to pass to the IDBObjectStore method.\n         * @param {IDBSuccessHandler} [successHandler] An optional handler that can be invoked to further process\n         *  the results of the operation before resolving the returned promise.\n         * @returns {Promise} A promise that will be resolved with the result of the operation, or rejected with\n         *  a DataError instance describing the failure.\n         */\n        function indexedDBTransaction(mode, method, args, successHandler) {\n            return new Promise(function IndexedDBTransactionPromise(resolve, reject) {\n\n                var transaction = db.transaction([meta.objectStore], mode),\n                    objectStore = transaction.objectStore(meta.objectStore),\n                    operation = objectStore[method].apply(objectStore, args);\n\n                operation.onerror = function transactionErrorOccurred() {\n                    var errorArgs = [\n                        Errors.Types.Data,\n                        'Could not complete IndexedDB operation.',\n                        {\n                            mode: mode,\n                            args: args,\n                            method: method\n                        }\n                    ];\n                    if (_.isError(transaction.error)) {\n                        errorArgs.unshift(transaction.error);\n                    }\n                    reject(Errors.get.apply(null, errorArgs));\n                };\n\n                operation.onabort = function transactionAborted(event) {\n                    transaction.error = event.target.error; // DOMError;\n                    operation.onerror();\n                };\n\n                operation.onsuccess = function transactionSucceeded() {\n                    if (_.isFunction(successHandler)) {\n                        successHandler(resolve, reject, operation.result);\n                    } else {\n                        resolve(operation.result);\n                    }\n                };\n\n            });\n        }\n\n        /**\n         * Maps IndexedDB IDBObjectStore operations to localStorage operations.\n         * @param {String} mode (unused)\n         * @param {String} method The method name to map to a localStorage operation.\n         * @param {Array} args Any arguments to pass to the operation.\n         * @param {IDBSuccessHandler} [successHandler] Optional success handler that can be used to\n         *  process the operation results before resolving or rejecting the transaction promise.\n         * @returns {Promise} A promise that will be resolved with the transaction results or rejected\n         *  with a DataError instance describing the failure reason.\n         */\n        function localStorageTransaction(mode, method, args, successHandler) {\n            return new Promise(function LocalStorageTransactionPromise(resolve, reject) {\n                var i, results, prefix = meta.objectStore + '-' + version + '-';\n                function invokeAgain() {\n                    if (i < results.length) {\n                        successHandler(resolve, reject, {\n                            'value': results[i++],\n                            'continue': invokeAgain\n                        });\n                    } else {\n                        successHandler(resolve, reject);\n                    }\n                }\n                switch (method) {\n                    case 'get':\n                        resolve(JSON.parse(localStorage.getItem(prefix + args[0])));\n                        break;\n                    case 'put':\n                        localStorage.setItem(prefix + args[1], JSON.stringify(args[0]));\n                        resolve(args[0]);\n                        break;\n                    case 'delete':\n                        resolve(localStorage.removeItem(prefix + args[0]));\n                        break;\n                    case 'clear':\n                        _(localStorage.length)\n                            .range()\n                            .map(localStorage.key.bind(localStorage))\n                            .filter(function hasPrefix(key) {\n                                return _.startsWith(key, prefix);\n                            })\n                            .forEach(function removeItem(key) {\n                                localStorage.removeItem(key);\n                            });\n                        resolve();\n                        break;\n                    case 'openCursor':\n                        i = 0;\n                        results = _(localStorage.length)\n                            .range()\n                            .map(localStorage.key.bind(localStorage))\n                            .filter(function hasPrefix(key) {\n                                return _.startsWith(key, prefix);\n                            })\n                            .map(function getItem(key) {\n                                return JSON.parse(localStorage.getItem(key));\n                            })\n                            .value();\n                        invokeAgain();\n                        break;\n                }\n            });\n        }\n\n        function get(key) {\n            return transactionStrategy('readonly', 'get', [key]);\n        }\n\n        function set(key, value) {\n            return transactionStrategy('readwrite', 'put', [value, key])\n                .then(function notifyObservers(result) {\n                    if (key in subjects) {\n                        subjects[key].onNext(value);\n                    }\n                    return result;\n                });\n        }\n\n        function remove(key) {\n            return transactionStrategy('readwrite', 'delete', [key])\n                .then(function endSubscriber(value) {\n                    if (key in subjects) {\n                        subjects[key].onCompleted();\n                        delete subjects[key];\n                    }\n                    return value;\n                });\n        }\n\n        function clear() {\n            return transactionStrategy('readwrite', 'clear', [])\n                .then(function endSubscribers(value) {\n                    _.invokeMap(_.values(subjects), 'onCompleted');\n                    subjects = {};\n                    return value;\n                });\n        }\n\n        function items() {\n            var results = [];\n            function successHandler(resolve, reject, /** @type {IDBCursor} */ cursor) {\n                if (cursor) {\n                    results.push(cursor.value);\n                    cursor.continue();\n                } else {\n                    resolve(results);\n                }\n            }\n            return transactionStrategy('readonly', 'openCursor', [], successHandler);\n        }\n\n        function observe(key) {\n            if (!(key in subjects)) {\n                subjects[key] = new Rx.Subject();\n                get(key)\n                    .then(function publishInitialValue(value) {\n                        subjects[key].onNext(value);\n                        return value;\n                    })\n                    .catch()\n                    .done();\n            }\n            return subjects[key].asObservable();\n        }\n\n        function InitializeIndexedDBStore(resolve) {\n            var request = window.indexedDB.open(database, version);\n            request.onupgradeneeded = function upgradeNeeded(event) {\n                if (!_.isFunction(meta.createUpgrade)) {\n                    Errors.throw(\n                        Errors.Types.IllegalArgument,\n                        'Missing `createUpgrade` callback when creating a new IndexedDBStore.'\n                    );\n                }\n                meta.createUpgrade(event.target.result);\n            };\n            request.onsuccess = function success(event) {\n                db = event.target.result;\n                transactionStrategy = indexedDBTransaction;\n                resolve();\n            };\n            request.onerror = function fallbackToLocalStorage() {\n                transactionStrategy = localStorageTransaction;\n                resolve();\n            };\n        }\n\n        AsyncStore.call(this, new Promise(InitializeIndexedDBStore), get, set, remove, clear, items, observe);\n\n    };\n\n});\n\n","define('paychex.core/stores/LocalStorage',['paychex.core/stores/HTML5Storage'], function (HTML5Store) {\n    /**\n     * @author Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2014-05-29\n     */\n\n    'use strict';\n\n    /**\n     * @class paychex.core.stores.LocalStorage\n     * @implements paychex.core.stores.IStore\n     * @see paychex.core.stores.HTML5Storage\n     * @description\n     * Stores data that should remain available even after the user's\n     * session ends (e.g. the browser window is closed). An instance of the\n     * {@link paychex.core.stores.HTML5Storage HTML5Storage} object. Available through the\n     * {@link paychex.core.Repository Repository} service.\n     */\n    return new HTML5Store(window.localStorage);\n});\n\n","define('paychex.core/stores/SessionStorage',['paychex.core/stores/HTML5Storage'], function (HTML5Store) {\n\n    /**\n     * @author Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2014-05-29\n     */\n\n    'use strict';\n\n    /**\n     * @class paychex.core.stores.SessionStorage\n     * @implements paychex.core.stores.IStore\n     * @see paychex.core.stores.HTML5Storage\n     * @description\n     * Stores data that should be removed automatically when the user's\n     * session ends (e.g. the browser window is closed). An instance of the\n     * {@link paychex.core.stores.HTML5Storage HTML5Storage} object. Available through the\n     * {@link paychex.core.Repository Repository} service.\n     */\n    var store = new HTML5Store(window.sessionStorage);\n\n    /**\n     * @function paychex.core.stores.SessionStorage#abandon\n     * @description\n     * Clears any persisted data in `window.sessionStorage` and abandons\n     * the user's session.\n     * @returns {void}\n     */\n    store.abandon = function clearPersistentData() {\n        store.clear();\n    };\n\n    return store;\n\n});\n\n","define('paychex.core/stores/Store',['paychex.core/Validator', 'paychex.core/Errors', 'lodash'], function(validator, Errors, _) {\n\n    /**\n     * @author Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2014-05-29\n     */\n\n    'use strict';\n\n    /**\n     * Contains various implementations of the IStore interface.\n     * @namespace paychex.core.stores\n     */\n\n    /**\n     * Specifies the methods that are expected of any Store.\n     * @interface paychex.core.stores.IStore\n     */\n\n    /**\n     * Retrieves the value for the specified key.\n     * @function\n     * @name paychex.core.stores.IStore#get\n     * @param {String} key The key whose value should be retrieved.\n     */\n\n    /**\n     * Sets the value for the specified key.\n     * @function\n     * @name paychex.core.stores.IStore#set\n     * @param {String} key The key whose value should be set.\n     * @param {*} value The value to associate with the given key.\n     */\n\n    /**\n     * Removes the specified key from the store.\n     * @function\n     * @name paychex.core.stores.IStore#remove\n     * @param {String} key The key to remove.\n     */\n\n    /**\n     * Removes all entries from the store.\n     * @function\n     * @name paychex.core.stores.IStore#clear\n     */\n\n    /**\n     * Returns an array of name/value pairs representing\n     * the contents of the store.\n     * @function\n     * @name paychex.core.stores.IStore#items\n     * @returns {Array}\n     */\n\n    /**\n     * An object representing the values in the Store\n     * @typedef {Object} paychex.core.stores.NameValuePair\n     * @property {String} name The name of the stored value.\n     * @property {*} value The stored value.\n     */\n\n    /**\n     * @class paychex.core.stores.Store\n     * @implements {paychex.core.stores.IStore}\n     * @param {Function} get The getter function to retrieve a named value.\n     * @param {Function} set The setter function to persist a name/value pair.\n     * @param {Function} remove A function to remove the value for the specified name.\n     * @param {Function} clear A function to remove all stored entries.\n     * @param {Function} items A function to return all stored entries.\n     * @description\n     * Represents a basic data store used to store and retrieve key/value pairs.\n     * Used primarily by the {@link paychex.core.Repository Repository} service. Base class\n     * for {@link paychex.core.stores.CookieStorage CookieStorage} and {@link paychex.core.stores.HTML5Storage\n     * HTML5Storage}.\n     * @throws Store requires 5 functions to be provided: get, set, remove, clear, and items.\n     */\n    function Store(get, set, remove, clear, items) {\n\n        if (!validator.validateArgs( arguments,\n            ['function', 'function', 'function', 'function', 'function'])) {\n            Errors.throw(Errors.Types.IllegalArgument, 'Store requires 5 functions to be provided: get, set, remove, clear, and items');\n        }\n\n        /**\n         * @function paychex.core.stores.Store#get\n         * @param {String} name The name of the stored key/value pair to retrieve.\n         * @param {Object} [options] Any optional data that may be used by the store.\n         * @returns {(*|undefined)} The original value that was stored for the specified key name,\n         *  or `undefined` if no value was found.\n         * @description\n         * Retrieves a persisted value using the specified key name.\n         */\n        this.get = get;\n\n        /**\n         * @function paychex.core.stores.Store#set\n         * @param {String} name The name of the value to store. This can be used to\n         *  retrieve the value later, using {@link paychex.core.stores.Store#get get}.\n         * @param {Object} value The value to persist. Will be converted to a string.\n         * @param {Object} [options] Any optional data that may be used by the store.\n         * @description\n         * Persists a value using the specified key name. The value can be retrieved\n         * later using the {@link paychex.core.stores.Store#get get} method. To remove a value,\n         * *do not* provide a `null` value; instead, call the {@link\n            paychex.core.stores.Store#remove remove} method.\n         */\n        this.set = set;\n\n        /**\n         * @function paychex.core.stores.Store#remove\n         * @param {String} name The key to remove from storage.\n         * @param {Object} [options] Any optional data that may be used by the store.\n         * @description\n         * Removes any values stored for the specified key.\n         */\n        this.remove = remove;\n\n        /**\n         * @function paychex.core.stores.Store#clear\n         * @description\n         * Removes all name/value pairs persisted in this Store.\n         */\n        this.clear = clear;\n\n        /**\n         * @function paychex.core.stores.Store#items\n         * @description\n         * Returns an array of all name/value pairs persisted in this Store.\n         */\n        this.items = items;\n\n    }\n\n    /**\n     * Static method to determine if the provided instance implements\n     * the required Store methods (get, set, remove, clear, and items).\n     * paychex.core.stores.Store.isStore\n     * @param {Object} instance The instance to test.\n     * @returns {boolean} `true` if the instance implements the required\n     *  Store methods; otherwise, `false`.\n     */\n    Store.isStore = function isStore(instance) {\n        return !!instance && _.every(['get', 'set', 'remove', 'clear', 'items'], function checkIsFunction(key) {\n            return _.isFunction(instance[key]);\n        });\n    };\n\n    return Store;\n\n});\n\n","define('paychex.core/stores/StoreToAsyncStoreWrapper',[\n    'lodash',\n    'lib.rxjs',\n    'paychex.core/Errors',\n    'paychex.core/Promise',\n    'paychex.core/stores/Store',\n    'paychex.core/stores/AsyncStore'\n], function(\n    _,\n    Rx,\n    Errors,\n    Promise,\n    Store,\n    AsyncStore\n) {\n\n    'use strict';\n\n    /**\n     * @author: Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2017-01-31\n     */\n\n    /**\n     * @class paychex.core.stores.AsyncStoreWrapper\n     * @param {paychex.core.stores.IStore} store An IStore implementation.\n     * @example\n     * var asyncLocalStorage = new AsyncStoreWrapper(new LocalStore());\n     * asyncLocalStorage.set('key', 'value').then(...);\n     */\n    return function AsyncStoreWrapper(store) {\n\n        var subjects = {};\n\n        if (!(this instanceof AsyncStoreWrapper)) {\n            Errors.throw(Errors.Types.Invocation, 'AsyncStoreWrapper must be invoked with `new`.');\n        }\n\n        if (!Store.isStore(store)) {\n            Errors.throw(Errors.Types.IllegalArgument, 'Parameter `store` must be a Store instance.');\n        }\n\n        AsyncStore.call(this,\n\n            Promise.resolve(), // ready immediately\n\n            function get() {\n                return Promise.resolve(store.get.apply(store, arguments));\n            },\n\n            function set(key, value) {\n                return Promise.resolve(store.set.apply(store, arguments))\n                    .then(function notifyObservers(result) {\n                        if (key in subjects) {\n                            subjects[key].onNext(value);\n                        }\n                        return result;\n                    });\n            },\n\n            function remove(key) {\n                return Promise.resolve(store.remove.apply(store, arguments))\n                    .then(function endSubscriber(value) {\n                        if (key in subjects) {\n                            subjects[key].onCompleted();\n                            delete subjects[key];\n                        }\n                        return value;\n                    });\n            },\n\n            function clear() {\n                return Promise.resolve(store.clear.apply(store, arguments))\n                    .then(function endSubscribers(value) {\n                        _.invokeMap(_.values(subjects), 'onCompleted');\n                        subjects = {};\n                        return value;\n                    });\n            },\n\n            function items() {\n                return Promise.resolve(store.items.apply(store, arguments));\n            },\n\n            function observe(key) {\n                if (!(key in subjects)) {\n                    subjects[key] = new Rx.Subject();\n                    subjects[key].onNext(store.get(key));\n                }\n                return subjects[key].asObservable();\n            }\n\n        );\n\n    };\n\n});\n\n","define('paychex.core/stores/TemporaryStore',['lodash'], function(_) {\n\n    /**\n     * @author: Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2016-01-29\n     */\n\n    'use strict';\n\n    /**\n     * Represents a {@link paychex.core.stores.Store} instance whose\n     * values only exist while the instance is in memory. This\n     * can be useful as a fallback for when HTML5 local storage\n     * is disabled, for unit testing, or for when you don't want\n     * to store values that will persist.\n     * @class paychex.core.stores.TemporaryStore\n     * @implements {paychex.core.stores.IStore}\n     */\n    return function TemporaryStore() {\n        var items = {};\n        this.get = function getItem(key) {\n            return items[key];\n        };\n        this.set = function setItem(key, value) {\n            items[key] = value;\n        };\n        this.remove = function removeItem(key) {\n            delete items[key];\n        };\n        this.clear = function clearItems() {\n            items = {};\n        };\n        this.items = function getItems() {\n            return _.map(items, function temporaryStoreMapper(value, key) {\n                return {\n                    name: key,\n                    value: value\n                };\n            });\n        };\n    };\n\n});\n\n","define('paychex.core/SubscriptionManager',[\n    'lodash',\n    'paychex.core/Errors',\n    'paychex.core/Logger',\n    'paychex.core/Validator',\n    'paychex.core/NotificationData'\n], function (_,\n             Errors,\n             Logger,\n             Validator,\n             NotificationData) {\n\n    'use strict';\n\n    /**\n     * @author Dan Barnes\n     * @date 2014-09-13\n     */\n\n    var MIN_KEY_LENGTH = 1;\n\n    /**\n     * @class paychex.core.SubscriptionManager\n     * @description Manages key-based subscription and notification.\n     * @example\n     * var manager = new SubscriptionManager();\n     * var optionalData = {key: 'value'};\n     * var unsubscribe = manager.add('topic', function(arg1, arg2){\n     *   log(arg1, arg2);\n     * }, optionalData);\n     * var notificationData = manager.notify('topic', 'value1', 'value2');\n     * log(notificationData.misc); // > [{key: 'value'}]\n     */\n    return function SubscriptionManager() {\n\n        var callbacks = {},\n            isPaused = false,\n            log = Logger.get('paychex.core/SubscriptionManager');\n\n        return {\n\n            /**\n             * @function paychex.core.SubscriptionManager#add\n             * @description Associates a callback with the specified key.\n             * @param {string} key The key to associated with the given callback.\n             * @param {function} callback Method to invoke when {@link paychex.core.SubscriptionManager#notify notify}\n             * is called with the specified key.\n             * @param {object=} misc Optional data to return as part of the notification process.\n             * @returns {Function} Method to invoke to unsubscribe the specified callback from the given key.\n             * @throws Parameter `key` must be a non-empty string.\n             * @throws Parameter `callback` must be a function.\n             * @throws The callback is already subscribed to this event.\n             * @example\n             * var manager = new SubscriptionManager();\n             * var unsubscribe = manager.add('topic', function(){ ... });\n             * unsubscribe(); // removes callback from manager\n             */\n            add: function add(key, callback, misc) {\n\n                var lists = [],\n                    localKey = key;\n\n                if (!Validator.isString(localKey, MIN_KEY_LENGTH)) {\n                    Errors.throw(Errors.Types.Type, 'Parameter `key` must be a non-empty string.');\n                } else {\n                    localKey = localKey.toLowerCase();\n                }\n\n                if (!Validator.isFunction(callback)) {\n                    Errors.throw(Errors.Types.Type, 'Parameter `callback` must be a function.');\n                }\n\n                _.forEach(localKey.split(','), function subscribeToEvent(eventName) {\n                    var event = eventName.trim(),\n                        fns = callbacks[event];\n                    if (!Validator.isArray(fns)) {\n                        callbacks[event] = [];\n                        fns = callbacks[event];\n                    } else if (_.includes(fns, callback)) {\n                        Errors.throw(\n                            Errors.Types.Invocation,\n                            'The callback is already subscribed to this event.',\n                            {event: event}\n                        );\n                    }\n                    fns.push(callback);\n                    if (!_.includes(lists, fns)) {\n                        lists.push(fns);\n                    }\n                });\n\n                callback.misc = misc;\n\n                return function unsubscribe() {\n                    _.forEach(lists, function removeCallback(list) {\n                        _.pull(list, callback);\n                    });\n                };\n\n            },\n\n            /**\n             * @function paychex.core.SubscriptionManager#notify\n             * @description Invokes any callbacks associated with the given key. Any additional parameters passed\n             * to notify will be passed as arguments to the callback methods.\n             * @param {string} key The key whose callbacks should be invoked.\n             * @returns {NotificationData} An instance of the {@link NotificationData NotificationData} class.\n             * @throws Parameter `key` must be a non-empty string.\n             * @example\n             * var manager = new SubscriptionManager();\n             * var notificationData = manager.notify('some-topic', 'argument1', 'argument2');\n             */\n            notify: function notify(key) {\n\n                var notificationData,\n                    localKey = key;\n\n                if (!Validator.isString(localKey, MIN_KEY_LENGTH)) {\n                    Errors.throw(Errors.Types.Type, 'Parameter `key` must be a non-empty string.');\n                } else {\n                    localKey = localKey.trim().toLowerCase();\n                }\n\n                notificationData = new NotificationData(\n                    localKey,\n                    isPaused ? [] : callbacks[localKey],\n                    _.tail(arguments)\n                );\n\n                _.forEach(notificationData.callbacks.concat(), function invokeSubscriber(callback) {\n                    var err;\n                    if (!notificationData.isCanceled()) {\n                        err = _.attempt(callback, notificationData);\n                        if (_.isError(err)) {\n                            log.error(err);\n                        }\n                    }\n                });\n\n                return notificationData;\n\n            },\n\n            /**\n             * Temporarily stop notifying registered callbacks. To resume notifying\n             * callbacks again, call `resume()`.\n             * @function paychex.core.SubscriptionManager#pause\n             * @returns {undefined}\n             * @example\n             * var manager = new SubscriptionManager();\n             * manager.pause();\n             * var notificationData = manager.notify('some-topic', 'argument1', 'argument2');\n             * log(notificationData.callbacks); // should always be an empty array []\n             * manager.resume();\n             */\n            pause: function pause() {\n                isPaused = true;\n            },\n\n            /**\n             * Resume notifying registered callbacks after a `pause`.\n             * @function paychex.core.SubscriptionManager#resume\n             * @returns {undefined}\n             * @example\n             * var manager = new SubscriptionManager();\n             * manager.pause();\n             * var notificationData = manager.notify('some-topic', 'argument1', 'argument2');\n             * log(notificationData.callbacks); // should always be an empty array []\n             * manager.resume();\n             */\n            resume: function resume() {\n                isPaused = false;\n            }\n\n        };\n\n    };\n\n});\n\n","/* jshint -W117 */\n/* eslint \"requirejs/enforce-define\": 0 */\n\nwindow.performance = window.performance || {};\nwindow.performance.addEventListener = window.performance.addEventListener || Function.prototype;\n\ndefine('paychex.core/Tracker',['lib.tracking'], function(Tracking) {\n\n    /**\n     * @author: Dan Barnes\n     * Email: dbarnes1@paychex.com\n     * Date: 2015-09-04\n     */\n\n    'use strict';\n\n    // in the future, if we use another library, we can provide\n    // code here to keep the API consistent\n\n    return Tracking;\n\n});\n\n","define('paychex.core/TriggerMixin',['paychex.core/SubscriptionManager'], function(Subscriptions) {\n\n    'use strict';\n\n    /**\n     * @author Dan\n     * @date 2014-10-04\n     */\n\n    /**\n     * @constructor\n     * @mixin paychex.core.TriggerMixin\n     * @desc Provides simple subscription and notification of custom events for\n     * any implementing components.\n     *\n     *     var MyClass = function(){\n     *         TriggerMixin.apply(this); // adds on(...) and trigger(...) methods\n     *     });\n     */\n    return function TriggerMixin() {\n\n        var pubSub = new Subscriptions();\n\n        /**\n         * Associates a callback with one or more events.\n         * @function paychex.core.TriggerMixin#on\n         * @param {String} eventName One or more events to listen for. Specify\n         * multiple events using a comma-separated list. See the example for\n         * details.\n         * @param {Function} callback The method to invoke when an event with\n         * the specified name is triggered.\n         * @returns {Function} A method to invoke to un-register the callback\n         * for the specified event.\n         * @example\n         * var myTriggerObj = new MyTriggerClass();\n         * var unReg = myTriggerObj.on('my-event-1, my-event-2', function(e){\n         *     expect(e.args[0]).toBe(123);\n         *     expect(e.args[1]).toBe('abc');\n         * });\n         * myTriggerObj.trigger('my-event-1', 123, 'abc');\n         * unReg(); // un-registers the callback\n         * myTriggerObj.trigger('my-event-2', 456, 'def');\n         */\n        this.on = function on(eventName, callback) {\n            return pubSub.add(eventName, callback);\n        };\n\n        /**\n         * Invokes the specified handler only once, then immediately\n         * unsubscribes the callback.\n         * @function paychex.core.TriggerMixin#one\n         * @param {String} eventName One or more events to listen for. Specify\n         *  multiple events using a comma-separated list. See the example for\n         *  details.\n         * @param {Function} callback The method to invoke when an event\n         *  with the specified name is triggered. The method will only be\n         *  invoked once, then immediately unsubscribed.\n         * @returns {Function} A method to invoke to un-register the callback\n         *  for the specified event.\n         * @example\n         * var myTriggerObj = new MyTriggerClass();\n         * myTriggerObj.one('my-event-1, my-event-2', function(e){\n         *     expect(e.args[0]).toBe(123);\n         *     expect(e.args[1]).toBe('abc');\n         * });\n         * myTriggerObj.trigger('my-event-1', 123, 'abc'); // runs the above callback\n         * myTriggerObj.trigger('my-event-2', 456, 'def'); // does not run the above callback\n         */\n        this.one = function one(eventName, callback) {\n            var remove = pubSub.add(eventName, function oneTimeCallback() {\n                callback.apply(null, [].slice.call(arguments));\n                remove();\n            });\n            return remove;\n        };\n\n        /**\n         * Notifies any callbacks registered for the given event, passing\n         * any additional arguments to those event handlers.\n         * @function paychex.core.TriggerMixin#trigger\n         * @returns {undefined}\n         * @example\n         * var myTriggerObj = new MyTriggerClass();\n         * myTriggerObj.on('my-custom-event', function(e){\n         *     log(e.key); // my-custom-event\n         *     log(e.args.join(', ')); // hello, world\n         * });\n         * myTriggerObj.trigger('my-custom-event', 'hello', 'world');\n         */\n        this.trigger = function trigger() {\n            pubSub.notify.apply(pubSub, arguments);\n        };\n\n        /**\n         * Temporarily stop notifying registered callbacks. To resume\n         * notifying callbacks again, call `resume()`.\n         * @function paychex.core.TriggerMixin#pause\n         * @returns {undefined}\n         * @example\n         * var myTriggerClass = new MyTriggerClass();\n         * myTriggerClass.pause();\n         * myTriggerObj.on('my-custom-event', function(e){\n         *     throw new Error('this will not be invoked');\n         * });\n         * myTriggerObj.trigger('my-custom-event', 'hello', 'world');\n         * myTriggerClass.resume();\n         * @alias paychex.core.TriggerMixin#suspend\n         */\n        this.pause = this.suspend = function pause() {\n            pubSub.pause();\n        };\n\n        /**\n         * Resume notifying registered callbacks after a pause.\n         * @function paychex.core.TriggerMixin#resume\n         * @returns {undefined}\n         * @example\n         * var myTriggerClass = new MyTriggerClass();\n         * myTriggerClass.pause();\n         * myTriggerObj.on('my-custom-event', function(e){\n         *     throw new Error('this will not be invoked');\n         * });\n         * myTriggerObj.trigger('my-custom-event', 'hello', 'world');\n         * myTriggerClass.resume();\n         */\n        this.resume = function resume() {\n            pubSub.resume();\n        };\n\n    };\n\n});\n\n","define('paychex.core/UserFeedback',[\n    'paychex.core/Errors',\n    'paychex.core/Promise',\n    'paychex.core/Validator'\n], function(\n    Errors,\n    Promise,\n    Validator\n) {\n\n    'use strict';\n\n    /**\n     * @typedef {object} UserFeedback\n     * @property {string} email The e-mail address of the user submitting feedback.\n     * @property {string} name The name of the user submitting feedback.\n     * @property {string} message The user's feedback.\n     * @property {object} [custom] Optional custom data you wish to include in the request, as key-value pairs.\n     */\n\n    /**\n     * @callback UserFeedbackProvider\n     * @param {UserFeedback} feedback The feedback to submit.\n     * @returns {Promise} A promise that resolves when the feedback is submitted successfully, or rejects if the\n     *  feedback could not be sent.\n     */\n\n    /**\n     * @typedef {object} UserFeedbackAPI\n     * @property {UserFeedbackProvider} submit Method to invoke to submit user feedback.\n     */\n\n    /**\n     * @class paychex.core.UserFeedback\n     * @param {UserFeedbackProvider} provider The provider to use to submit user feedback.\n     * @returns {UserFeedbackAPI} The API to use to submit user feedback.\n     * @example\n     * angular.module('feedback', [])\n     *   .factory('UserFeedbackService', ['$http', function($http) {\n     *     function UserVoiceProvider(feedback) {\n     *       // parse feedback and send to UserVoice endpoint\n     *       return $http({...}); // return promise to caller\n     *     }\n     *     return UserFeedback(UserVoiceProvider);\n     *   }]);\n     *\n     * // later, in Angular code:\n     * UserFeedbackService.submit({\n     *   name: 'user name\",\n     *   email: 'user@isp.com',\n     *   message: 'user feedback goes here'\n     * }).then(success, failure).done();\n     */\n    return function create(provider) {\n\n        if (!Validator.isFunction(provider)) {\n            Errors.throw('Argument \\'provider\\' should be a function that accepts a feedback object and returns a promise.');\n        }\n\n        function getErrorMessage(feedback) {\n            if (!Validator.isTypeMatch([feedback], ['pojo'])) {\n                return 'Parameter \\'feedback\\' must be a plain object.';\n            } else if (!Validator.isString(feedback.email, 1, /.+@.+\\..+/i)) {\n                return 'Field \\'email\\' is missing or invalid.';\n            } else if (!Validator.isString(feedback.name, 1)) {\n                return 'Field \\'name\\' is missing or empty.';\n            } else if (!Validator.isString(feedback.message, 1)) {\n                return 'Field \\'message\\' is missing or empty.';\n            }\n        }\n\n        function submit(feedback) {\n            var msg = getErrorMessage(feedback);\n            msg && Errors.throw(Errors.Types.IllegalArgument, msg);\n            return Promise.call(provider, feedback);\n        }\n\n        return {\n            submit: submit\n        };\n\n    };\n\n});\n\n","define('paychex.core/Utils',[\n    'lodash',\n    'paychex.core/Errors',\n    'paychex.core/Promise',\n    'paychex.core/Validator',\n    'lib.safe-json-stringify'\n], function (_,\n        Errors,\n        Promise,\n        Validator,\n        jsonSafeStringify) {\n\n    'use strict';\n\n    /**\n     * @author Dan Barnes\n     * @date 2014-09-21\n     */\n\n    /**\n     * @namespace paychex.core.Utils\n     * @desc Extends lo-dash with the following additional methods:\n     *  - cross: combines 2 or more arrays into a single array of all possible combinations\n     *  - sluggify: converts a string into the desired format\n     */\n\n    _.mixin({\n            /**\n             * @desc returns a new array with combined unique values and can also be used as a customizer function\n             * to other lodash methods such as _.mergeWith which allows us to merge complex objects that have array properties - https://lodash.com/docs/4.17.5#mergeWith\n             * @function paychex.core.Utils#arrayUnionCustomizer\n             * @param {Array} objValue Array to inspect.\n             * @param {Array} srcValue Array to inspect.\n             * @returns {Array} Returns new array with combined unique values\n             * @example\n             * var objValue = ['a', 'b'],\n             *     srcValue = ['a', 'd'];\n             * Utils.arrayUnionCustomizer(objValue, srcValue); -> ['a','b','d']\n             */\n        arrayUnionCustomizer: function arrayUnion(objValue, srcValue) {\n            if (_.isArray(objValue)) {\n                return _.union(objValue, srcValue);\n            }\n        },\n        /**\n         * @desc returns a new array with combined values and can also be used as a customizer function\n         * to other lodash methods such as _.mergeWith which allows us to merge complex objects that have array properties - https://lodash.com/docs/4.17.5#mergeWith\n         * @function paychex.core.Utils#arrayConcatCustomizer\n         * @param {Array} objValue Array to inspect.\n         * @param {Array} srcValue Array to inspect.\n         * @returns {Array} Returns new array with combined values\n         * @example\n         * var objValue = ['a', 'b'],\n         *     srcValue = ['a', 'd'];\n         * Utils.arrayConcatCustomizer(objValue, srcValue); -> ['a','b','a','d']\n         */\n        arrayConcatCustomizer: function arrayConcat(objValue, srcValue) {\n            if (_.isArray(objValue)) {\n                return objValue.concat(srcValue);\n            }\n        },\n\n        /**\n         * Converts an object to a string, recursively.\n         * @function paychex.core.Utils#serialize\n         * @param {Object} obj the object to serialize\n         * @returns {String} the serialized string\n         */\n        serialize: function serialize(obj) {\n\n            var type = typeof obj,\n                result = '';\n\n            switch (type) {\n                case 'object':\n                    result = _.reduce(obj, function convertToString(str, value, key) {\n                        return str + '[' + type + ':' + key + _.serialize(value) + ']';\n                    }, '');\n                    break;\n\n                case 'function':\n                    result += '[' + type + ':' + obj.toString() + ']';\n                    break;\n\n                default:\n                    result += '[' + type + ':' + obj + ']';\n            }\n\n            return result.replace(/\\s/g, '');\n\n        },\n\n        /**\n         * @function paychex.core.Utils#hash\n         * @desc\n         * Creates a hash code from a string.\n         * @param {String} str the string to hash\n         * @returns {number} the hash code\n         */\n        hash: function hash(str) {\n\n            var s = str,\n                EMPTY = 0,\n                SHIFT_AMOUNT = 5;\n\n            if (_.isPlainObject(s)) {\n                s = _.serialize(s);\n            } else {\n                s = String(s);\n            }\n\n            if (_.isEmpty(s)) {\n                return EMPTY;\n            }\n\n            /* jshint bitwise:false */\n            return _.reduce(_.toArray(s), function doHash(res, chr) {\n                return (((res << SHIFT_AMOUNT) - res) + chr.charCodeAt(EMPTY)) | EMPTY;\n            }, EMPTY);\n\n        },\n\n        /**\n         * @function paychex.core.Utils#cloneTrue\n         * @desc Performs a deep clone of an object that includes inherited\n         *  properties and methods from the prototype object. Normal clone\n         *  copies object-types by reference and cloneDeep does not include\n         *  inherited properties and methods. This method clones *all*\n         *  properties and methods of an object, including inherited ones.\n         * @param {Object} from The object to clone.\n         * @param {Object} [to] An optional object to clone to; not required.\n         * @returns {Object} A deep clone of the provided object, including\n         *  prototypal properties and methods.\n         * @example\n         * var original = new Date(),\n         *     clone = Utils.cloneTrue(original);\n         * assert.areEqual(original, clone);\n         * assert.exists(clone.getDate);\n         */\n        cloneTrue: function cloneTrue(from, to) {\n\n            var result;\n\n            if (!_.isObject(from) || from.constructor !== Object && from.constructor !== Array) {\n                return from;\n            }\n\n            if (_.includes([Date, RegExp, Function, String, Number, Boolean], from.constructor)) {\n                return new from.constructor(from);\n            }\n\n            if (from.constructor === Array) {\n                return [].concat(from);\n            }\n\n            result = to || new from.constructor();\n\n            _.forIn(from, function copyValue(value, key) {\n                result[key] = _.isUndefined(result[key]) && cloneTrue(from[key]) || result[key];\n            });\n\n            return result;\n\n        },\n\n        /**\n         * Combines 2 or more arrays into a single array of all possible combinations.\n         * @function paychex.core.Utils#cross\n         * @returns {Array} An array containing all possible combinations.\n         * @example\n         * Utils.cross([1, 2], [3, 4, 5])\n         *   -> [[1, 3], [1, 4], [1, 5], [2, 3], [2, 4], [2, 5]]\n         */\n        cross: function cross() {\n            return _.reduce(arguments, function reduce(a, b) {\n                /* eslint \"lodash/prefer-flat-map\": 0 */\n                return _.flatten(_.map(a, function mapA(x) {\n                    return _.map(b, function mapB(y) {\n                        return x.concat([y]);\n                    });\n                }));\n            }, [[]]);\n        },\n\n        /**\n         * Converts a string into the desired format. You should pass the desired format\n         * along with one or more strings to concatenate together. Possible values for format are:\n         *  - css: convert a string into a CSS class name\n         *  - var: convert a string into a camelCased variable name\n         * @function paychex.core.Utils#sluggify\n         * @returns {String} The sluggified string.\n         * @example\n         * Utils.sluggify('css', 'my', 'CSS', 'class')\n         *   -> my-css-class\n         * Utils.sluggify('var', 'my', 'variable', 'name')\n         *   -> myVariableName\n         */\n        sluggify: function sluggify() {\n\n            if (!Validator.isTypeMatch(arguments, ['string', 'string'])) {\n                Errors.throw(Errors.Types.Type, '_.sluggify expects at least 2 string parameters.');\n            }\n\n            /* eslint \"vars-on-top\": 0 */\n            var FIRST = 0,\n                rxWS = /\\s+/g,\n                rxVar = /\\w\\S*/g,\n                rxCSS = /[~!@$%^&*()_+=,./';:\"?><[\\\\\\]{}|`#]+/g,\n                args = Array.prototype.slice.call(arguments),\n                type = args.shift().toLowerCase();\n\n            return ({\n\n                'css': function cssSlug() {\n                    return _.reduce(arguments, function reduce(a, b, i) {\n                        return a + (i === FIRST ? '' : '-') +\n                            b.toLowerCase().trim()\n                                .replace(rxCSS, '')\n                                .replace(rxWS, '-');\n                    }, '');\n                },\n\n                'var': function varSlug() {\n                    return _.reduce(arguments, function reduce(a, b, i) {\n                        return a + b.trim()\n                            .replace(rxVar, function replace(match, index) {\n                                if ((i + index) === FIRST) {\n                                    return match.toLowerCase();\n                                }\n                                return _.upperFirst(match);\n                            })\n                            .replace(rxWS, '')\n                            .replace(rxCSS, '');\n                    }, '');\n                }\n\n            }[type] || _.identity).apply(null, args);\n\n        },\n\n        /**\n         * Given a list of arguments, returns the first argument that is defined, or returns undefined if none are defined.\n         * @function paychex.core.Utils#firstDefined\n         * @returns {Object} The first defined argument.\n         * @example\n         * Utils.firstDefined('foo', 'bar')\n         *   -> 'foo'\n         * Utils.firstDefined(undefined, 'foo', 'bar')\n         *   -> 'foo'\n         */\n        firstDefined: function firstDefined() {\n            return _.find(arguments, _.negate(_.isUndefined));\n        },\n\n        /**\n         * Calls JSON.stringify with a replacer that detects any cycles in the object graph and replaces them with \"[Circular]\".\n         * @function paychex.core.Utils#stringify\n         * @param {Object} obj The object to serialize to a string.\n         * @param {Function=} replacer An optional conversion function that receives the key and value being serialized\n         *  and should return a serialized string. This string will be further serialized by JSON.stringify.\n         * @param {Number} [spaces=0] The number of spaces to use as indentation when serializing the object to a string.\n         * @param {Function=} cycleReplacer An optional function that takes a key and a value and returns the value\n         *  to serialize when a circular reference is detected. The default cycleReplacer returns \"[Circular]\".\n         */\n        stringify: jsonSafeStringify,\n\n        /**\n         * Invokes the second function if the first function is truthy. This method can be used with partially\n         * applied arguments to create pure functional logic flows. See the second example for details.\n         * @function paychex.core.Utils#invokeIf\n         * @param {Function} predicate The function to invoke to determine if the second function should be invoked.\n         * @param {Function} fn The function to invoke if predicate is truthy.\n         * @param {Function} [alt] The function to invoke if predicate is NOT truthy. Default is to return undefined.\n         * @returns {Function} A function that can be invoked multiple times. Only when predicate returns truthy\n         *  will fn be invoked, passing any arguments along.\n         * @example\n         * var signaled = false;\n         * var isReady = function() {\n         *   return signaled;\n         * }\n         * var invokeIfReady = _.invokeIf(isReady, function hello(who) {\n         *   log('hello, ' + who);\n         * });\n         * invokeIfReady('world'); // does nothing\n         * signaled = true;\n         * invokeIfReady('world'); // \"hello, world\"\n         * @example\n         *  var retry2times = _.partial( // so we can provide the last argument later\n         *      _.invokeIf, // the function to partially apply\n         *      _.negate(_.invokeLimitReached(3)) // the first (predicate) argument\n         *  );\n         *\n         *  var HTTP_FAILURE = Errors.get(Errors.Types.Http, 'example HTTP failure');\n         *\n         *  // this method will retry twice or until it succeeds:\n         *  function somePromiseMethod() {\n         *      log('invoking');\n         *      return Promise.delay(100, HTTP_FAILURE) // simulate a network failure\n         *          .catch(Errors.Types.Http, retry2times(somePromiseMethod, _.identity))\n         *          .catch(Errors.rethrowAs(Errors.Types.Data, 'Failed after 3 attempts!'));\n         *  }\n         *\n         *  somePromiseMethod().catch(log);\n         *  > invoking\n         *  > invoking\n         *  > invoking\n         *  > DataError {message: \"Failed after 3 attempts!\", name: \"DataError\", causedBy: DataError, severity: \"ERROR\"}\n         */\n        invokeIf: function invokeIf(predicate, fn, alt) {\n            if (!Validator.validateArgs([predicate, fn], ['function', 'function'])) {\n                Errors.throw(Errors.Types.IllegalArgument, 'invokeIf expects 2 function arguments');\n            }\n            return function innerInvokeIf() {\n                if (!!predicate.apply(null, arguments)) {\n                    return fn.apply(null, arguments);\n                }\n                return alt && alt.apply(null, arguments);\n            };\n        },\n\n        /**\n         * Returns a method that can be invoked up to `count` times before returning `true`. This method is meant\n         * to be used with the invokeIf method (and other pure functional methods) to help construct complex control\n         * flows. See the second example of invokeIf for details.\n         * @function paychex.core.Utils#invokeLimitReached\n         * @param {Number} count The number of times the returned method should be invoked before returning `true`.\n         * @returns {Function} A method that can be invoked any number of times. Once the invoke limit is reached,\n         *  the returned value will be `true`. Until then, the returned value will be `false`.\n         * @example\n         * var invoker = _.invokeLimitReached(5);\n         * log('invoked 5 times?', invoker()); // false\n         * log('invoked 5 times?', invoker()); // false\n         * log('invoked 5 times?', invoker()); // false\n         * log('invoked 5 times?', invoker()); // false\n         * log('invoked 5 times?', invoker()); // true\n         * log('invoked 5 times?', invoker()); // true\n         */\n        invokeLimitReached: function invokeLimitReached(count) {\n            var invokeCount = 0,\n                MINIMUM = 0;\n            if (!Validator.isNumber(count, MINIMUM)) {\n                Errors.throw(Errors.Types.IllegalArgument, 'invokeLimitReached expects a non-negative number');\n            }\n            return function innerInvokeLimitReached() {\n                return ++invokeCount >= count;\n            };\n        },\n\n        /**\n         * Returns a function that will invoke the provided function with an ever-increasing delay between calls.\n         * @function paychex.core.Utils#exponentialFalloff\n         * @param {Function} fn The function to invoke with ever-increasing delays between calls.\n         * @param {Number} [multiplier=250] The number of milliseconds to exponentially increase between failed calls.\n         * @returns {Function} A function whose arguments will be passed to `fn` on each invocation and returns a\n         *  Promise that will be resolved with the return value of `fn`.\n         * @example\n         * var start = Date.now();\n         * var myMethod = function(arg) {\n         *   log(arg, Date.now() - start);\n         * }\n         * var expFalloff = _.exponentialFalloff(myMethod);\n         * // note: the real milliseconds will be slightly different\n         * expFalloff('a'); // a 0\n         * expFalloff('b'); // b 500\n         * expFalloff('c'); // c 1000\n         * expFalloff('d'); // d 2000\n         * expFalloff('e'); // e 4000\n         * expFalloff('f'); // f 8000\n         */\n        exponentialFalloff: function expFalloff(fn, multiplier) {\n\n            var invokeCount = 0,\n                BASE = 2,\n                FIRST = 1,\n                OFFSET = 1,\n                DEFAULT_MULTIPLER = 250,\n                MULTIPLIER = multiplier || DEFAULT_MULTIPLER;\n\n            if (!Validator.isFunction(fn)) {\n                Errors.throw(Errors.Types.IllegalArgument, 'exponentialFalloff expects a function argument');\n            }\n\n            /**\n             * Invokes the outer function and calls the success or failure callbacks based on the result.\n             * @param {Function} success The callback to invoke if the function succeeded.\n             * @param {Function} failure The callback to invoke if the function failed.\n             * @param {Array} [args] An optional array of arguments to invoke function with.\n             * @returns {*} Whatever the success or failure callback returns.\n             */\n            function invoke(success, failure, args) {\n                var result = _.attempt(_.spread(fn), args);\n                if (_.isError(result)) {\n                    return failure(result);\n                } else {\n                    return success(result);\n                }\n            }\n\n            /**\n             * Returns the appropriate delay in milliseconds based on the invoke count.\n             * @returns {number} The number of milliseconds to delay.\n             */\n            function getDelay() {\n                return Math.pow(BASE, (invokeCount - OFFSET)) * MULTIPLIER;\n            }\n\n            return function innerExpFalloff() {\n                if (_.isEqual(++invokeCount, FIRST)) {\n                    // invoke with no scheduler delay\n                    return invoke(Promise.resolve, Promise.reject, arguments);\n                }\n                return new Promise(function ExponentialFalloffPromise(resolve, reject) {\n                    // invoke after exponential delay\n                    // 500ms, 1000ms, 2000ms, 4000ms, 8000ms, ...\n                    setTimeout(invoke, getDelay(), resolve, reject, arguments);\n                });\n            };\n        }\n\n    });\n\n    _.isEqual = _.wrap(_.isEqual, function wrappedIsEqual(fn, a, b, callback) {\n        var predicate = callback;\n        if (!callback && !!a && a.hasOwnProperty('valueOf') && !!b && b.hasOwnProperty('valueOf')) {\n            predicate = function equalValueOf(lhs, rhs) {\n                return lhs.valueOf() === rhs.valueOf();\n            };\n        }\n        return _.isEqualWith(a, b, predicate);\n    });\n\n    _.indexOf = _.wrap(_.indexOf, function wrappedIndexOf(fn, array, value, fromIndex) {\n        var toFind = value,\n            collection = array;\n        if (!!value && value.hasOwnProperty('valueOf')) {\n            toFind = value.valueOf();\n            collection = _.invokeMap(array, 'valueOf');\n        }\n        return fn(collection, toFind, fromIndex);\n    });\n\n    _.uniq = _.wrap(_.uniq, function wrappedUniq(fn, arr) {\n        return _.uniqWith(arr, _.isEqual);\n    });\n\n    _.includes = _.wrap(_.includes, function wrappedIncludes(fn, collection, value, fromIndex) {\n        /* eslint \"lodash/prefer-includes\": 0 */\n        if (_.isArray(collection)) {\n            // lodash's indexOf expects Arrays only\n            return _.indexOf(collection, value, fromIndex) > -1;\n        } else {\n            // otherwise use the built-in -- we shouldn't have\n            // valueOf overrides on object or string collection\n            // values, so this *shouldn't* affect ModelLists\n            return fn(collection, value, fromIndex);\n        }\n    });\n\n    _.difference = _.wrap(_.difference, function wrappedDifference(fn, array, values) {\n        return _.differenceWith(array, values, _.isEqual);\n    });\n\n    _.intersection = _.wrap(_.intersection, function wrappedIntersection(fn, array, values) {\n        return _.intersectionWith(array, values, _.isEqual);\n    });\n\n    return _;\n\n});\n\n","define('paychex.core/utils/FileUtils',[\n    'lodash',\n    'paychex.core/Errors',\n    'paychex.core/Promise',\n    'paychex.core/DeviceProfile',\n    'paychex.core/lib/pica'\n], function(\n    _,\n    Errors,\n    Promise,\n    DeviceProfile,\n    Pica\n) {\n    'use strict';\n\n    var DEFAULT_HEIGHT_AND_WIDTH = 200,\n        QUALITY_MAX = 0.99,\n        DEFAULT_QUALITY = 0.9;\n\n    /**\n     * Helper function used to determine if the submitted image is a blob\n     * @param {*} image Image to test if a blob\n     * @returns {boolean} If the image is a blob\n     */\n    function isBlob(image) {\n        return image instanceof Blob;\n    }\n\n    /**\n     * Helper function used to determine if the submitted image is a canvas\n     * @param {*} image Image to test if a canvas\n     * @returns {boolean} If the image is a canvas\n     */\n    function isCanvas(image){\n        return image instanceof HTMLCanvasElement;\n    }\n\n    /**\n     * Takes a blob, converts it to an image, then resizes that image based on the parameters. Then calls\n     * the consumer's callback function in order to give them access to the newly resized blob.\n     * @param {blob | canvas} image Blob/Canvas for the image to be resized\n     * @param {object} options Object of parameters consisting of: image, height, width, mimeType, and quality\n     * @returns {Promise} Promise chain resolved with the resized image\n     */\n    function resizeImage(image, options) {\n        var pica,\n            features = ['js'],\n            height = options && _.isFinite(options.height) ? options.height : DEFAULT_HEIGHT_AND_WIDTH,\n            width = options && _.isFinite(options.width) ? options.width : DEFAULT_HEIGHT_AND_WIDTH,\n            mimetype = options && _.isString(options.mimeType) ? options.mimeType : 'image/png',\n            quality = options && _.inRange(options.quality, 0, QUALITY_MAX) ? options.quality : DEFAULT_QUALITY,\n            canvas = document.createElement('canvas'),\n            img = new Image();\n\n        if (!DeviceProfile.isIPhone()) {\n            features.push('wasm');\n        }\n        if(!DeviceProfile.isInternetExplorer()) {\n            features.push('ww');\n        }\n\n        pica = new Pica({\n            features: features\n        });\n\n        canvas.height = height;\n        canvas.width = width;\n\n\n        return new Promise(function resizePromise(resolve, reject){\n            img.onload = function onload(){\n                Promise.cast(pica.resize(img, canvas))\n                    .then(function getResizedCanvas(resized){\n                        resolve(pica.toBlob(resized, mimetype, quality));\n                        return;\n                    })\n                    .catch(function catchError(err){\n                        reject(err);\n                        return;\n                    })\n                    .done();\n            };\n            img.onerror = reject;\n\n            if(isBlob(image)) {\n                img.src = window.URL.createObjectURL(image);\n            } else if(isCanvas(image)) {\n                img.src = image.toDataURL();\n            } else {\n                Errors.throw(Errors.IllegalArgument, 'image must a blob or canvas');\n            }\n        });\n    }\n\n    /**\n     * Converts the blob to a base64 object\n     * @param {blob} blob Blob to convert\n     * @returns {Promise} Conversion promise\n     */\n    function convertBlobToBase64(blob){\n        return new Promise(function convertBlobToB64(resolve, reject){\n            var reader = new FileReader(),\n                errorResult;\n            reader.onload = function conversionSuccess() {\n                resolve(reader.result);\n            };\n            reader.onerror = function conversionFailed(r) {\n                reject(Errors.get('FileReaderException', 'Failed to convert blob to base64', {result: r}));\n            };\n\n            errorResult = _.attempt(reader.readAsDataURL.bind(reader, blob));\n            if( _.isError(errorResult)){\n                reject(Errors.get('FileReaderException', 'Failed to convert blob to base64', {result: errorResult}));\n            }\n        });\n    }\n\n    return {\n        resizeImage: resizeImage,\n        convertBlobToBase64: convertBlobToBase64\n    };\n});\n","define('paychex.core/utils/Overloader',['lodash'], function(_) {\n\n    'use strict';\n\n    /**\n     * @author: dbarnes1\n     * Email: dbarnes1@paychex.com\n     * Date: 2015-05-18\n     */\n\n    /**\n     * Contains JavaScript components that have no dependencies on any particular web framework.\n     * @namespace paychex.core\n     */\n\n    /**\n     * Allows developers to create overloaded methods in JavaScript.\n     * @class paychex.core.Overloader\n     * @param {*} [context] An optional context in which to invoke the overloaded methods.\n     * @example\n     * define(['paychex.core/Overloader'], function(Overloader) {\n     *\n     *   var methods = new Overloader(),\n     *       self = this;\n     *\n     *   self.prop = 'my private member';\n     *\n     *   // use the self variable to access private instance members from your method:\n     *   methods.overload('myMethodName', 'string', function myStringMethod(str) {\n     *      // implementation goes here\n     *      // we can access self.prop from this method\n     *   });\n     *\n     *   // or bind your overloaded method directly to `this` to access private instance members:\n     *   methods.overload('myMethodName', 'string', 'Date', function myStringDateMethod(str, dt) {\n     *     // implementation goes here\n     *     // we can access this.prop from this method\n     *  }.bind(this));\n     *\n     *  return {\n     *    myMethod: function() {\n     *      return methods.invoke('myMethodName', arguments);\n     *    }\n     *  };\n     *\n     * });\n     * @example\n     * define(['paychex.core/Overloader'], function(Overloader) {\n     *\n     *   // bind all overloaded methods to `this`:\n     *   var methods = new Overloader(this);\n     *\n     *   // now all overloaded methods will have access to `this.prop`\n     *   this.prop = 'my private member';\n     *\n     *   methods.overload('myMethodName', 'string', function myStringMethod(str) {\n     *      // implementation goes here\n     *      // we can access this.prop from this method\n     *   });\n     *\n     *  return {\n     *    myMethod: function() {\n     *      return methods.invoke('myMethodName', arguments);\n     *    }\n     *  };\n     *\n     * });\n     */\n    function Overloader(context) {\n        this.methods = {};\n        this.methodKeys = {};\n        this.context = context || null;\n    }\n\n    /**\n     * Invokes the specified overloaded method with the given arguments.\n     * @method paychex.core.Overloader#invoke\n     * @param {String} methodName The method name to invoke. This should match\n     * the methodName registered using the {@link #overload overload} method.\n     * @param {Array|arguments} [args] An optional array of arguments to pass\n     * to the overloaded method. The argument types will be examined to determine\n     * which overloaded method to invoke. Overloads are sorted in order of most\n     * parameters to least, so a call matching both [date] and [date, string] will\n     * invoke the [date, string] method.\n     * @returns {*} The return value of the overloaded method, or `undefined` if\n     * no matching overload can be found.\n     */\n    Overloader.prototype.invoke = function invoke(methodName, args) {\n        var method,\n            overload,\n            localArgs = args;\n        if (_.isArguments(args)) {\n            localArgs = _.toArray(args);\n        } else if (!_.isArray(args)) {\n            localArgs = _.tail(arguments);\n        }\n        if (!!this.methods[methodName]) {\n            overload = _.find(this.methodKeys[methodName], function isMatch(key) {\n                return _.every(key.split('|'), function isTypeMatch(type, index) {\n                    return type === '' || typeof localArgs[index] === type ||\n                        (!!window[type] && localArgs[index] instanceof window[type]);\n                });\n            });\n            method = this.methods[methodName][overload];\n            if (!!method) {\n                return method.apply(this.context, localArgs);\n            }\n        }\n    };\n\n    /**\n     * Overload the specified method name so the given function will be invoked\n     * when values matching the specified types are passed to {@link #invoke invoke}.\n     * The first parameter should be the method name and the last parameter should be\n     * the function to invoke. The middle parameters should be strings representing\n     * the types that should be matched in order to invoke the specified method. See\n     * the example code for details\n     * @method paychex.core.Overloader#overload\n     * @param {String} methodName The name of the method to overload.\n     * @returns {undefined}\n     * @example\n     * define(['paychex.core/Overloader'], function(Overloader) {\n     *\n     *   var methods = new Overloader();\n     *\n     *   methods.overload('methodA', function() { ... });\n     *   methods.overload('methodA', 'string', function(str) { ... });\n     *   methods.overload('methodA', 'Date', function(dt) { ... });\n     *   methods.overload('methodA', 'string', 'Date', function(str, dt) { ... });\n     *\n     *   methods.invoke('methodA'); // invokes 1st overload\n     *   methods.invoke('methodA', 'hello'); // invokes 2nd overload\n     *   methods.invoke('methodA', new Date()); // invokes 3rd overload\n     *   methods.invoke('methodA', 'hello', 'world'); // nothing invoked\n     * });\n     */\n    Overloader.prototype.overload = function overload(methodName) {\n        var types = _.tail(arguments),\n            method = types.pop();\n        if (_.isString(methodName) && !_.isEmpty(methodName) && _.isFunction(method)) {\n            this.methods[methodName] = this.methods[methodName] || {};\n            this.methods[methodName][types.join('|')] = method;\n            this.methodKeys[methodName] = _.sortBy(_.functions(this.methods[methodName]), 'length').reverse();\n        }\n    };\n\n    return Overloader;\n\n});\n\n","define('paychex.core/Validator',['lodash', 'paychex.core/Errors'], function(_, Errors) {\n\n    'use strict';\n\n    /**\n     * @author Dan Barnes\n     * @date 2014-09-13\n     */\n\n    var NON_EMPTY = 1;\n\n    /**\n     * @namespace paychex.core.Validator\n     * @description Abstract class providing code validation routines.\n     * @returns {undefined}\n     * @throws Class `Validator` is static and should not be instantiated.\n     * @example\n     * define(['Validator'], function(Validator){\n     *     Validator.isNumber(1e12); // -> true\n     *     Validator.isArray({}); // -> false\n     * });\n     */\n    function Validator() {\n        Errors.throw(Errors.Types.Invocation, 'Class `Validator` is static and should not be instantiated.');\n    }\n\n    /**\n     * Returns true if the value is a function. If you specify a second argument, the routine\n     * will verify the function expects *at least* the given number of arguments.\n     * @function paychex.core.Validator.isFunction\n     * @param {*} value The value to check is a function.\n     * @param {Number=} minArgCount The minimum number of arguments the function should have defined.\n     * @returns {boolean} result `true` if the value is a function with the specified number of arguments;\n     * otherwise, `false`.\n     * @throws Parameter `minArgCount` must be a non-negative number.\n     * @example\n     * Validator.isFunction(function(){}) => true\n     * Validator.isFunction(function(){}, 1) => false\n     * @alias paychex.core.Validator.validateFunctionArgCount\n     */\n    Validator.isFunction = Validator.validateFunctionArgCount = function isFunction(value, minArgCount) {\n        var NON_NEGATIVE = 0;\n        if (minArgCount !== undefined && !Validator.isNumber(minArgCount, NON_NEGATIVE)) {\n            Errors.throw(Errors.Types.IllegalArgument, 'Parameter `minArgCount` must be a non-negative number.');\n        }\n        return _.isFunction(value) &&\n            (value.length >= (minArgCount !== undefined ? minArgCount : value.length));\n    };\n\n    /**\n     * Determines if the given value is a number in the specified range.\n     * @function paychex.core.Validator.isNumber\n     * @param {*} value The value to check.\n     * @param {Number} [min=Number.MIN_VALUE] The lower accepted bound of the number.\n     * @param {Number} [max=Number.MAX_VALUE] The upper accepted bound of the number.\n     * @returns {boolean} result `true` if the value is a number in the specified range; `false` otherwise.\n     * @example\n     * Validator.isNumber(1e23) => true\n     * Validator.isNumber(12, 0) => true\n     * Validator.isNumber(12, 0, 10) => false\n     */\n    Validator.isNumber = function isNumber(value, min, max) {\n        var localMin = min,\n            localMax = max;\n        if (!_.isNumber(min) || _.isNaN(min)) {\n            localMin = Number.MIN_VALUE;\n        }\n        if (!_.isNumber(max) || _.isNaN(max)) {\n            localMax = Number.MAX_VALUE;\n        }\n        return _.isNumber(value) && value >= localMin && value <= localMax;\n    };\n\n    /**\n     * Determines if the specified value is an array.\n     * @function paychex.core.Validator.isArray\n     * @param {*} value The value to determine is an array.\n     * @param {string|function} [type] If provided, verifies that every element\n     * in the array matches the specified type; can be a string or class; if a\n     * string is provided, can be one of the keys in {@link paychex.core.Validator.validationMap};\n     * see the example for details.\n     * @param {number} [minLength=0] The minimum number of element the array\n     * should have. If not provided, defaults to zero (all arrays have zero or\n     * more elements).\n     * @returns {boolean} result `true` if the value is an array; `false` otherwise.\n     * @throws If provided, parameter `type` must be a non-empty string or a function.\n     * @throws If provided, parameter `minLength` must be a non-negative number.\n     * @example\n     * Validator.isArray([1, 2, 3]) => true\n     * Validator.isArray({key: 'value'}) => false\n     * Validator.isArray(['a', 'b'], 'string') => true\n     * Validator.isArray([new Date(), new Date(), 'abc'], Date) => false\n     * Validator.isArray([8, 7, 6], 2) => true\n     * Validator.isArray([8, 7, 6], 'string', 2) => false\n     */\n    Validator.isArray = function isArray(value, type, minLength) {\n\n        var matchesType,\n            ANY_LENGTH = 0,\n            NON_NEGATIVE = 0,\n            itemType = type,\n            length = minLength;\n\n        if (_.isUndefined(length) && Validator.isNumber(itemType, NON_NEGATIVE)) {\n            length = itemType;\n            itemType = undefined;\n        }\n\n        length = length || ANY_LENGTH;\n\n        if (!Validator.isTypeMatch(type, 'nonEmptyString|function|undefined')) {\n            Errors.throw(Errors.Types.IllegalArgument, 'If provided, parameter `type` must be a non-empty string or a function.');\n        }\n\n        if (!Validator.isNumber(length, NON_NEGATIVE)) {\n            Errors.throw(Errors.Types.IllegalArgument, 'If provided, parameter `minLength` must be a non-negative number.');\n        }\n\n        matchesType = _.isString(itemType) ?\n            function isTypeMatch(val) { return Validator.isTypeMatch(val, itemType); } :\n            function isInstanceOf(val) { return !itemType || val instanceof itemType; };\n\n        return _.isArray(value) && value.length >= length && _.every(value, matchesType);\n\n    };\n\n    /**\n     * Determines if the specified value is a string.\n     * @function paychex.core.Validator.isString\n     * @param {*} value The value to test if a string.\n     * @param {Number} [minLength=0] An optional length check; if supplied, the string's length will be checked\n     * without whitespace.\n     * @param {String|RegExp} [rx] An optional regular expression or regexp pattern to validate against.\n     * @returns {boolean} result `true` if the value is a string; `false` otherwise.\n     * @throws Parameter `minLength` must be a non-negative number.\n     * @throws Parameter `rx` must be a non-empty regexp pattern or a regular expression object.\n     * @example\n     * Validator.isString('abc') => true\n     * Validator.isString('abc', 10) => false\n     * Validator.isString('abc', 0, /[a-z]/) => true\n     */\n    Validator.isString = function isString(value, minLength, rx) {\n\n        var ANY_LENGTH = 0,\n            NON_NEGATIVE = 0,\n            pattern = rx;\n\n        if (minLength !== undefined && !Validator.isNumber(minLength, NON_NEGATIVE)) {\n            Errors.throw(Errors.Types.IllegalArgument, 'Parameter `minLength` must be a non-negative number.');\n        }\n\n        if (!_.isUndefined(pattern)) {\n            if (Validator.isString(pattern, NON_EMPTY)) {\n                pattern = new RegExp(pattern);\n            }\n            if (!_.isRegExp(pattern)) {\n                Errors.throw(Errors.Types.IllegalArgument, 'Parameter `rx` must be a non-empty regexp pattern or a regular expression object.');\n            }\n        }\n\n        return _.isString(value) &&\n            (value.trim().length >= (minLength || ANY_LENGTH)) &&\n            (!pattern || pattern.test(value));\n\n    };\n\n    /**\n     * Determines if the value specified is null or undefined.\n     * @function paychex.core.Validator.isNullOrUndefined\n     * @param {*} value The value to determine is null or undefined.\n     * @returns {boolean} result `true` if the value is null or undefined; `false` otherwise.\n     * @example\n     * var myValue;\n     * Validator.isNullOrUndefined(myValue) => true\n     * Validator.isNullOrUndefined(123) => false\n     */\n    Validator.isNullOrUndefined = function isNullOrUndefined(value) {\n        return _.isNil(value);\n    };\n\n    /**\n     * Determines if the specified value is an Arguments object.\n     * @function paychex.core.Validator.isArguments\n     * @param {*} value The value to determine is an Arguments object.\n     * @returns {boolean} result `true` if the value is an Arguments object; otherwise `false`.\n     * @example\n     * function(){\n     *     Validator.isArguments(arguments) => true\n     *     Validator.isArguments([1, 2, 3]) => false\n     * }\n     */\n    Validator.isArguments = function isArguments(value) {\n        return _.isArguments(value);\n    };\n\n    /**\n     * Determines if the specified values and types match. You can pass either a single value and type\n     * or an array of values and types to check multiple instances in a single call. You can also pass multiple\n     * types to check against a single value by using the | separator. See the example for details.\n     * @function paychex.core.Validator.isTypeMatch\n     * @param {*|Array} values The values whose types should be checked.\n     * @param {String|String[]} types The type names to verify for the given values. Acceptable type names can\n     * be found in the {@link Validator.validationMap validationMap} keys.\n     * @returns {boolean} result `true` if all of the specified values have the specified types; otherwise `false`.\n     * @throws Parameter `types` cannot be an empty array.\n     * @throws Parameter `values` cannot be an empty array.\n     * @throws Parameter `types` must be a non-empty string or array or non-empty strings.\n     * @throws Parameter `values` has fewer elements than parameter `types`.\n     * @throws Validation function for type `type` was not found.\n     * @example\n     * Validator.isTypeMatch(123, 'number') => true\n     * Validator.isTypeMatch(['abc', 123], ['string', 'number']) => true\n     * Validator.isTypeMatch('abc', 'number|string') => true\n     * Validator.isTypeMatch(arguments, ['function', 'function|undefined'])\n     * @alias paychex.core.Validator.validateArgs\n     */\n    Validator.isTypeMatch = Validator.validateArgs = function isTypeMatch(values, types) {\n\n        var HAS_ARGUMENT = 1,\n            localValues = values,\n            localTypes = types;\n\n        /** @returns {boolean} Whether the values should be cast to an array. */\n        function shouldTypeCastValuesAsArray() {\n            var FIRST_ENTRY = 0,\n                SINGLE_ENTRY = 1;\n            return !_.isArray(localValues) || (\n                localTypes.length === SINGLE_ENTRY &&\n                _.includes(localTypes[FIRST_ENTRY].toLowerCase(), 'array') &&\n                !_.isArray(localValues[FIRST_ENTRY])\n            );\n        }\n\n        if (!_.isArray(localTypes)) {\n            localTypes = [localTypes];\n        }\n\n        if (_.isEmpty(localTypes)) {\n            Errors.throw(Errors.Types.IllegalArgument, 'Parameter `types` cannot be an empty array.');\n        }\n\n        if (Validator.isArguments(localValues)) {\n            localValues = _.toArray(localValues);\n        }\n\n        if (shouldTypeCastValuesAsArray()) {\n            localValues = [localValues];\n        }\n\n        if (_.isEmpty(localValues)) {\n            Errors.throw(Errors.Types.IllegalArgument, 'Parameter `values` cannot be an empty array.');\n        }\n\n        if (!_.every(localTypes, function isNonEmptyString(type) {\n            return Validator.isString(type, NON_EMPTY);\n        })) {\n            Errors.throw(Errors.Types.IllegalArgument, 'Parameter `types` must be a non-empty string or array or non-empty strings.');\n        }\n\n        if (localValues.length < localTypes.length) {\n            Errors.throw(Errors.Types.IllegalArgument, 'Parameter `values` has fewer elements than parameter `types`.');\n        }\n\n        return _.every(localValues, function valueMatchesType(value, index) {\n            return index >= localTypes.length ||\n                _.some(localTypes[index].replace(/\\?/g, '|undefined').split('|'), function matchesType(type) {\n                    var localType = type.toLowerCase().trim(),\n                        validator = Validator.validationMap[localType];\n                    if (!Validator.isFunction(validator, HAS_ARGUMENT)) {\n                        Errors.throw(Errors.Types.IllegalArgument, 'Validation function for type was not found.', {type: localType});\n                    }\n                    return validator(value);\n                });\n        });\n\n    };\n\n    /**\n     * Map of the available type validation methods for the {@link Validator.isTypeMatch isTypeMatch} method.\n     * Currently available type validations include:\n     *\n     *  - \\* - returns true regardless of value type\n     *  - any - any defined type (i.e. value is not `undefined`)\n     *  - arguments - value is a function's arguments object\n     *  - array - value is an array\n     *  - bool, boolean - value is `true` or `false`\n     *  - date - value is a date\n     *  - function - value is a function\n     *  - null - value is `null`\n     *  - number - value is numeric\n     *  - object - value is a reference type\n     *  - pojo - value is an object literal, such as {key: 'value'}\n     *  - regexp - value is a regular expression\n     *  - string - value is a string\n     *  - nonemptystring - value is a non-empty string\n     *  - undefined - value is `undefined`\n     * @member {Object} paychex.core.Validator.validationMap\n     */\n    Validator.validationMap = {\n        // NOTE: using manual functions wrapping lodash functions because\n        // we check the arity of each validation function and some lodash\n        // functions don't have any named parameters\n        '*': function(value) { return !!value /* gets rid of unused var lint error */ || true; },\n        'any': function(value) { return !_.isUndefined(value); },\n        'null': function(value) { return _.isNull(value); },\n        'undefined': function(value) { return _.isUndefined(value); },\n        'string': Validator.isString,\n        'number': _.isNumber,\n        'array': Validator.isArray,\n        'function': Validator.isFunction,\n        'arguments': Validator.isArguments,\n        'object': _.isObject,\n        'pojo': _.isPlainObject,\n        'regexp': _.isRegExp,\n        'date': _.isDate,\n        'boolean': _.isBoolean,\n        'bool': _.isBoolean,\n        'nonemptystring': function(value) { return Validator.isString(value, NON_EMPTY); }\n    };\n\n    return Validator;\n\n});\n\n","define('paychex.core/WindowOpener',[\n    'lodash',\n    'paychex.core/Logger',\n    'paychex.core/Promise',\n    'paychex.core/Errors'\n], function (_,\n             Logger,\n             Promise,\n             Errors) {\n    'use strict';\n\n    var ns = 'paychex.core.WindowOpener',\n        log = Logger.get(ns);\n\n    /**\n     * method makes actual call to window 'open'\n     * @param args - arguments for open method for window\n     * @param successHandler\n     * @param failureHandler\n     * @returns {*}\n     * @private\n     */\n\n    function _openWindow(args, successHandler, failureHandler) {\n        var result = _.attempt(function tryOpenWindow() {\n            return successHandler({winRef: window.open.apply(window, args)});\n        });\n        if (_.isError(result)) {\n            log.error('Error opening new window: ' + result);\n            return failureHandler(Errors.get('WindowOpener', 'failed to open window', {severity: 'NONE'}));\n        }\n        return result;\n    }\n\n    /**\n     * method to open new window.\n     * @params - Arguments to be passed in strUrl, strWindowName, [strWindowFeatures]\n     * @returns {Promise} Promise resolved with {winRef object}\n     * @private\n     */\n    function _openNewWindow() {\n        log.info('Open new window got called');\n        var DEFAULT_TIMEOUT = 100,\n            isFirefox = _.includes(navigator.userAgent.toLowerCase(), 'firefox'),\n            args = _.toArray(arguments);\n\n        if (!isFirefox) {\n            return _openWindow(args, Promise.resolve, Promise.reject);\n        } else {\n            return new Promise(function OpenWindowPromise(resolve, reject) {\n                setTimeout(_openWindow, DEFAULT_TIMEOUT, args, resolve, reject);\n            });\n        }\n    }\n\n    return {open: _openNewWindow};\n});\n\n","define('paychex.core/Workflows',[\n    'paychex.core/Promise',\n    'paychex.core/lib/dag',\n    'paychex.core/lib/tsort',\n    'paychex.core/Utils',\n    'paychex.core/Errors',\n    'paychex.core/Logger',\n    'paychex.core/Validator',\n    'paychex.core/Tracker'\n], function(\n    Promise,\n    dag,\n    tsort,\n    _,\n    Errors,\n    Logger,\n    Validator,\n    Tracking\n) {\n\n    'use strict';\n\n    /**\n     * @author Dan Barnes\n     * @date 2014-09-24\n     */\n\n    /**\n     * @namespace paychex.core.Workflows\n     * @desc Provides functionality to create asynchronous workflows.\n     * @throws Workflows is a static class and should not be instantiated.\n     */\n\n    /**\n     * @class paychex.core.Workflow\n     * @desc Encapsulates a single workflow instance and provides methods\n     * for modifying and executing the workflow.\n     * @param {String} name The unique name of the workflow.\n     * @throws Workflows must have a name.\n     * @throws Workflow `name` already exists.\n     */\n\n    var wfs = {},\n        NON_EMPTY = 1,\n        MISSING_KEY = '_missing',\n        MAX_CONCURRENCY = 10,\n\n        ErrorMessages = {\n\n            ADD_SEQUENCE: 'Function `addSequence` expects an object literal parameter whose' +\n                ' keys represent step names and whose values are either step objects or functions' +\n                ' that return step objects.',\n\n            INJECT_STEP: 'Function `injectStep` expects a string, optional array, array, and ' +\n                'object or function as parameters.',\n\n            DISPATCH_ARG_TYPES: 'Function `dispatch` expects an optional arguments array, optional ' +\n                'timeout in milliseconds, and optional tracking data.',\n\n            DISPATCH_NEGATIVE_TIMEOUT: 'Parameter `timeout` must be a non-negative number. If `timeout` = 0, ' +\n                'no timeout will be used.'\n\n        },\n\n        Workflows = function Workflows() {\n            Errors.throw(Errors.Types.Invocation, 'Workflows is a static class and should not be instantiated.');\n        },\n\n        Workflow = function Workflow(name) {\n            if (!Validator.isString(name, NON_EMPTY)) {\n                Errors.throw(Errors.Types.IllegalArgument, 'Workflows must have a name.');\n            }\n            if (wfs.hasOwnProperty(name)) {\n                Errors.throw(Errors.Types.IllegalArgument, 'Workflow already exists.', {name: name});\n            }\n            this.log = Logger.get(name, {level: 'INFO'});\n            this.name = name;\n            this.edges = [];\n            this.fns = {};\n            wfs[name] = this;\n        };\n\n    /**\n     * Removes all registered workflows. Used primarily for unit testing.\n     * @function paychex.core.Workflows.clear\n     * @returns {undefined}\n     * @private\n     */\n    Workflows.clear = function clear() {\n        wfs = {};\n    };\n\n    /**\n     * Creates a new workflow instance.\n     * @function paychex.core.Workflows.create\n     * @param {String} name The name of the workflow to create.\n     * @throws Workflows must have a name.\n     * @throws Workflow `name` already exists.\n     * @returns {paychex.core.Workflow} The workflow instance, for chaining.\n     * @example\n     * Workflows.create('my-workflow')\n     *     .addStep(...)\n     *     .dispatch(...);\n     */\n    Workflows.create = function create(name) {\n        return new Workflow(name);\n    };\n\n    /**\n     * @name paychex.core.Workflows.State\n     * @enum {String}\n     * @readonly\n     * @desc Enumeration of the possible states of a dispatched workflow.\n     */\n    Workflows.State = {\n        /** RUNNING */\n        RUNNING: 'RUNNING',\n        /** RESOLVED */\n        RESOLVED: 'RESOLVED',\n        /** REJECTED */\n        REJECTED: 'REJECTED',\n        /** CANCELED */\n        CANCELED: 'CANCELED'\n    };\n\n    /**\n     * Deletes a workflow from the global registry.\n     * @function paychex.core.Workflow#delete\n     * @returns {undefined}\n     * @example\n     * var wf = Workflows.create('my-workflow');\n     * // do stuff here\n     * $scope.$on('$destroy', function() {\n     *   wf.delete();\n     * });\n     */\n    Workflow.prototype.delete = function deleteWorkflow() {\n        if (wfs.hasOwnProperty(this.name)) {\n            delete wfs[this.name];\n        }\n    };\n\n    /**\n     * Adds the specified step to the workflow instance.\n     * @function paychex.core.Workflow#addStep\n     * @param {String} name The name of the step to register for this workflow.\n     * @param {Array} [depends] An optional array of step names this step depends on.\n     * If specified, these steps are guaranteed to be executed *before* this step is\n     * executed.\n     * @param {Function|Object|Workflow} func A step object or function that returns a step\n     * object. Step objects have optional methods that can be invoked at appropriate\n     * points in the workflow execution. See the example for details.\n     * @returns {paychex.core.Workflow} The workflow instance, for chaining.\n     * @example\n     * var wf = Workflows\n     *     .create('my-workflow')\n     *     .addStep('my-step', {\n     *         execute: function(){\n     *             return new Date();\n     *         }\n     *     })\n     *     .addStep('my-second-step', ['my-step'], function(){\n     *         // private vars could go here\n     *         return {\n     *             execute: function(){\n     *                 // because we said this step depends on `my-step`, we can\n     *                 // be certain that the results object contains the return\n     *                 // value from `my-step`'s execute method:\n     *                 log(this.results['my-step']) // outputs current date\n     *             },\n     *             success: function(){\n     *                 log('the workflow has succeeded');\n     *             },\n     *             failure: function(reason){\n     *                 error(reason || 'the workflow failed');\n     *             }\n     *         };\n     *     });\n     * @throws Function `addStep` expects a string, optional array, and function or object.\n     * @throws Step `name` already exists in this workflow.\n     * @throws Parameter `depends` must be an array of non-empty strings.\n     */\n    Workflow.prototype.addStep = function addStep(name, depends, func) {\n\n        var wf = this,\n            localName = name,\n            localDepends = depends,\n            localFunc = func;\n\n        (function validateArguments() {\n\n            if (Validator.isTypeMatch([localName, localDepends, localFunc], ['string', 'function|object', 'undefined'])) {\n                localFunc = localDepends;\n                localDepends = [];\n            }\n\n            if (!Validator.isTypeMatch([localName, localDepends, localFunc], ['string', 'array', 'function|object'])) {\n                Errors.throw(Errors.Types.IllegalArgument, 'Function `addStep` expects a string, optional array, and function or object.');\n            }\n\n            if (!Validator.isString(localName, NON_EMPTY)) {\n                Errors.throw(Errors.Types.IllegalArgument, 'A step localName must be provided.');\n            }\n\n            if (wf.fns.hasOwnProperty(localName)) {\n                Errors.throw(Errors.Types.IllegalArgument, 'Step already exists in this workflow.', {step: localName});\n            }\n\n            if (localFunc instanceof Workflow) {\n                localFunc = _.partial(function wrapper(inner) {\n                    return {execute: function exec() {\n                        return inner.dispatch(_.toArray(arguments));\n                    }};\n                }, localFunc.clone());\n            }\n\n            if (Validator.isTypeMatch(localFunc, 'pojo')) {\n                localFunc = _.partial(function wrapper(obj) {\n                    return obj;\n                }, localFunc);\n            }\n\n            if (!Validator.isFunction(localFunc)) {\n                Errors.throw(Errors.Types.IllegalArgument, 'Function `addStep` expects a function, POJO, or Workflow instance for parameter `func`.');\n            }\n\n        })();\n\n        /**\n         * @private\n         * @returns {Array} An array of edges for the step being added.\n         */\n        function getEdges() {\n\n            if (_.isEmpty(localDepends)) {\n                return [[null, localName]];\n            }\n\n            return _.map(localDepends, function validateDependency(dep) {\n                if (!Validator.isString(dep, NON_EMPTY)) {\n                    Errors.throw(Errors.Types.IllegalArgument, 'Parameter `depends` must be an array of non-empty strings.');\n                }\n                return [dep, localName];\n            });\n\n        }\n\n        this.fns[localName] = localFunc;\n        this.edges = this.edges.concat(getEdges());\n\n        return this;\n\n    };\n\n    /**\n     * Creates an exact copy of this Workflow instance, including\n     * the state of any private (closure) members.\n     * @function paychex.core.Workflow#clone\n     * @returns {paychex.core.Workflow} The workflow instance, for chaining.\n     */\n    Workflow.prototype.clone = function clone() {\n        /* eslint \"lodash/prefer-noop\": 0 */\n        /**\n         * @constructor\n         * @type {paychex.core.Workflow}\n         */\n        var F = function Clone() {};\n        F.prototype = this;\n        return new F();\n    };\n\n    /**\n     * Adds multiple steps to the workflow, ensuring that each\n     * step is executed in sequence. See the example for details.\n     * @function paychex.core.Workflow#addSequence\n     * @param {Array=} depends An optional array of step names these steps all depend on. If provided,\n     * your first step will not be executed until all of these steps execute first.\n     * @param {Object} steps An object literal whose keys represent step\n     * names and whose values represent step objects or functions.\n     * @returns {paychex.core.Workflow} The workflow instance, for chaining.\n     * @example\n     * Workflows.create('wf')\n     *     .addStep('A', { execute: function(){ log('A runs first'); } })\n     *     .addSequence(['A'], {\n     *         'B': { execute: function(){ log('step B runs after A'); } },\n     *         'C': { execute: function(){ log('step C runs after B'); } }\n     *     })\n     *     .dispatch();\n     */\n    Workflow.prototype.addSequence = function addSequence(depends, steps) {\n\n        var wf = this,\n            localDepends = depends,\n            localSteps = steps;\n\n        if (Validator.isNullOrUndefined(localSteps)) {\n            localSteps = depends;\n            localDepends = [];\n        }\n\n        if (!Validator.isTypeMatch([localDepends, localSteps], ['array', 'pojo'])) {\n            Errors.throw(Errors.Types.IllegalArgument, ErrorMessages.ADD_SEQUENCE);\n        }\n\n        _.forEach(localSteps, function addSingleStep(step, key) {\n            wf.addStep(key, localDepends, step);\n            localDepends = [key];\n        });\n\n        return this;\n\n    };\n\n    /**\n     * Returns a string representation of the workflow steps, indented to show\n     * dependencies. Note that the indents do not necessarily represent the exact order\n     * of execution, only which steps will be executed first.\n     * @function paychex.core.Workflow#toString\n     * @returns {String} A human-readable representation of the workflow step dependencies.\n     * @example\n     * var wf = Workflows\n     *    .create('workflow-name')\n     *    .addStep('A', {})\n     *    .addStep('B', ['A'], {})\n     *    .addStep('C', ['A'], {})\n     *    .addStep('D', ['B'], {})\n     *    .addStep('E', ['D'], {});\n     * log(wf.toString());\n     * // OUTPUT:\n     * workflow-name:\n     * A\n     *   C\n     *   B\n     *     D\n     *       E\n     */\n    Workflow.prototype.toString = function toString() {\n        var SELF = 1,\n            indent = '  ',\n            sorted = tsort(this.edges),\n            space = _.memoize(function spacing(num) {\n                return _.repeat(indent, num);\n            }),\n            numParents = _.memoize(function parents(step) {\n                var count = 0,\n                    elem = _.find(sorted.graph, {id: step});\n                if (!!elem && !!elem.parents.length) {\n                    count = SELF + _.max(_.map(elem.parents, numParents));\n                }\n                return count;\n            });\n        if (!!sorted.error) {\n            Errors.throw(sorted.error);\n        } else {\n            return _.reduce(sorted.path, function concat(out, step) {\n                return out + ['\\n', space(numParents(step)), step].join('');\n            }, this.name + ':');\n        }\n    };\n\n    /**\n     * Injects a step into the middle of a workflow, ensuring that certain steps are executed *before*\n     * the injected steps and other steps are executed *after* the injected step.\n     * @function paychex.core.Workflow#injectStep\n     * @param {String} stepName The name of the step to insert into the workflow.\n     * @param {Array=} depends An optional array of step names that this step depends on. These steps\n     * will be executed sometime prior to the step being inserted.\n     * @param {Array} stepsToPrecede The step names that should be executed *after* the step being injected.\n     * @param {Object|Function} stepObjectOrFunction The function or step object to execute.\n     * @returns {paychex.core.Workflow} The Workflow instance, for chaining.\n     * @example\n     * var wf = Workflows\n     *     .create('my-workflow')\n     *     .addStep('A', [], function(){ ... })\n     *     .addStep('B', ['A'], { ... })\n     *     .injectStep('A.5', ['A'], ['B'], { ... });\n     */\n    Workflow.prototype.injectStep = function injectStep(stepName, depends, stepsToPrecede, stepObjectOrFunction) {\n\n        var wf = this,\n            localDepends = _.isArray(depends) && depends || [],\n            localPrecedes = _.isArray(stepsToPrecede) && stepsToPrecede || [],\n            localStepObject = _.firstDefined(stepObjectOrFunction, stepsToPrecede, depends);\n\n        if (!Validator.isTypeMatch(\n            [stepName, localDepends, localPrecedes, localStepObject],\n            ['string', 'array', 'array', 'pojo|function'])) {\n            Errors.throw(Errors.Types.IllegalArgument, ErrorMessages.INJECT_STEP);\n        }\n\n        this.addStep(stepName, localDepends, localStepObject);\n\n        _.forEach(localPrecedes, function processSteps(precedingStepName) {\n            var dependencyExists = _.matches({1: precedingStepName});\n            _.forEach(_.filter(wf.edges, dependencyExists), function doStepInjection(edge) {\n                edge[1] = stepName;\n                wf.edges.push([stepName, precedingStepName]);\n            });\n        });\n\n        this.edges = _.uniqWith(this.edges, _.isEqual);\n\n        return this;\n\n    };\n\n    /**\n     * Removes the step with the given name from the workflow.\n     * @function paychex.core.Workflow#removeStep\n     * @param {String} name The name of the step to remove from this workflow.\n     * @returns {paychex.core.Workflow} The Workflow instance, for chaining.\n     */\n    Workflow.prototype.removeStep = function removeStep(name) {\n        delete this.fns[name];\n        this.edges = _.filter(this.edges, function isNotDependency(edge) {\n            return !_.includes(edge, name);\n        });\n        return this;\n    };\n\n    /**\n     * By default, if a workflow is dispatched with a step missing, it\n     * will reject with an appropriate message. You can override this behavior\n     * by registering a single callback to invoke when this happens. If your\n     * callback does *not* return a rejected promise, the workflow will skip\n     * the missing step and continue as normal. If you return a rejected promise,\n     * the workflow will be rejected.\n     *\n     * **NOTE:** To remove your callback, simply call onMissingStep with no\n     * parameters, or pass null: `myWorkflow.onMissingStep(null)`\n     * @function paychex.core.Workflow#onMissingStep\n     * @param {Function|null|undefined} callback The callback to invoke when a\n     * workflow is dispatched and a dependent step is missing. Callbacks can accept\n     * a single parameter: stepName -- the name of the step that was requested and\n     * does not exist in the workflow.\n     * @returns {paychex.core.Workflow} The Workflow instance, for chaining.\n     * @example\n     * Workflows.create('my-workflow')\n     *     .onMissingStep(function(stepName){\n     *         debug('step ' + stepName + ' was not found');\n     *         // because we are not returning a rejected promise,\n     *         // the workflow will skip the missing step and continue\n     *         // executing\n     *     });\n     */\n    Workflow.prototype.onMissingStep = function onMissingStep(callback) {\n        this[MISSING_KEY] = Validator.isFunction(callback) && callback || _.partial(Promise.reject, 'missing step');\n        return this;\n    };\n\n    /* eslint \"no-unused-vars\": 0 */\n    /**\n     * Invokes the workflow with the specified parameters, returning a promise that will be\n     * resolved with a dictionary of each step name to its execution result, or rejected with\n     * an Error instance representing the cause of the dispatch failure.\n     * @function paychex.core.Workflow#dispatch\n     * @param {Array=} args An optional array of arguments to pass to each step's `execute` method.\n     * @param {Number} [timeout=0] An optional timeout that specifies how long the workflow should be\n     * allowed to execute before being canceled automatically.\n     * @param {Object} [trackingData] An optional object that specifies if and how the workflow dispatch\n     *  should be tracked. If not specified, the workflow dispatch will not be tracked. See the example\n     *  for uses.\n     * @returns {Promise} A promise that will be resolved if the workflow has executed successfully, or will\n     * be rejected if an error has occurred. The promise has a `cancel` method that will abort the workflow\n     * and reject the promise, preventing subsequent steps from running.\n     * @throws Function `dispatch` expects an optional arguments array and optional timeout in milliseconds.\n     * @throws Parameter `timeout` must be a non-negative number. If `timeout` = 0, no timeout will be used.\n     * @example\n     * Workflows.create('my-workflow')\n     *     .addStep('A', {...})\n     *     .dispatch([arg1, arg2])\n     *     .then(mySuccessHandler, myFailureHandler);\n     * @example\n     * // all params (args, timeout, and tracking data):\n     * myWorkflow.dispatch(['some arg'], 1000, {category: 'startup'});\n     * // args and tracking data\n     * myWorkflow.dispatch(['some arg'], {category: 'startup'});\n     * // args and timeout:\n     * myWorkflow.dispatch(['some arg'], 1500);\n     * @example\n     * var dispatch = myWorkflow.dispatch([1, 2, 3]);\n     * userCancelRequested().then(function cancelWorkflow() {\n     *   dispatch.cancel(); // aborts workflow\n     * });\n     * dispatch\n     *   .then(function workflowSuccess() {})\n     *   .catch(function workflowFailure(err) {\n     *     // investigate err to see if the workflow\n     *     // was cancelled or failed for some other\n     *     // reason\n     *   })\n     *   .done();\n     * @example\n     * for (var i = 0; i < 10; i++) {\n     *   myWorkflow.dispatch({\n     *     label: 'my-workflow-dispatch #' + i\n     *     category: 'workflows',\n     *     tags: ['workflow', 'loop']\n     *   });\n     * }\n     */\n    Workflow.prototype.dispatch = function dispatch(args, timeout, trackingData) {\n\n        var NON_NEGATIVE = 0,\n            DEFAULT_TIMEOUT = 0,\n            PERCENT_PRECISION = 2,\n            WORKFLOW_STARTING = 0,\n            WORKFLOW_COMPLETE = 100,\n\n            params = _.toArray(arguments),\n            localTracking = _.find(params, _.isPlainObject) || undefined,\n            localTimeout = _.find(params, _.isNumber) || DEFAULT_TIMEOUT,\n            localArgs = _.find(params, _.isArray) || [],\n            canceled = Promise.defer(),\n            aborted = false,\n\n            wf = this;\n\n        if (!Validator.isTypeMatch([localArgs, localTimeout, localTracking], ['array', 'number', 'pojo?'])) {\n            Errors.throw(Errors.Types.IllegalArgument, ErrorMessages.DISPATCH_ARG_TYPES);\n        }\n\n        if (!Validator.isNumber(localTimeout, NON_NEGATIVE)) {\n            Errors.throw(Errors.Types.IllegalArgument, ErrorMessages.DISPATCH_NEGATIVE_TIMEOUT);\n        }\n\n        /** @constructor */\n        function Cancelable() {\n            this.cancel = function cancel(reason) {\n                canceled.reject(reason);\n            };\n        }\n\n        return _.assign(new Promise(function WorkflowDispatchPromise(resolve, reject, notify) {\n\n            var executed = [],\n                contexts = {},\n                fns = _.clone(wf.fns),\n                edges = _.clone(wf.edges),\n                baseTimer = Tracking.timers.create(wf.name),\n                context = {\n                    log: wf.log,\n                    workflow: wf,\n                    results: {},\n                    state: Workflows.State.RUNNING\n                };\n\n            /**\n             * @private\n             * @param {Object} step The step whose context should be retrieved.\n             * @returns {Object} The context in which to run the step.\n             */\n            function getStepContext(step) {\n                if (!(step.name in contexts)) {\n                    contexts[step.name] = _.merge(context, _.omitBy(step, _.isFunction));\n                }\n                return contexts[step.name];\n            }\n\n            /**\n             * @private\n             * @param {String} stepName The name of the step to retrieve.\n             * @returns {Object} The step matching the specified name. NOTE: This method\n             * retrieves a new instance of the step between each invocation. Properties\n             * changed on a previous step instance will not be reflected on subsequent\n             * step instances.\n             */\n            function getFullStep(stepName) {\n                return _.merge({\n                    name: stepName,\n                    retry: Promise.reject,\n                    execute: _.noop,\n                    success: _.noop,\n                    failure: _.noop,\n                    rollback: _.noop\n                }, fns[stepName]());\n            }\n\n            /**\n             * @private\n             * @returns {Promise} A promise that is always resolved.\n             */\n            function success() {\n                return Promise.settle(_.map(executed, function invokeStepSuccess(step) {\n                    return Promise.call(_.bind(step.success, getStepContext(step)), context.results);\n                })).tap(function finish() {\n                    context.state = Workflows.State.RESOLVED;\n                    resolve(context.results);\n                });\n            }\n\n            /**\n             * @private\n             * @param {String|Error} reason The reason the workflow failed.\n             * @returns {Promise} A promise that is always rejected.\n             */\n            function failure(reason) {\n                var failureReason = reason;\n                if (context.state === Workflows.State.RUNNING) {\n                    context.state = Workflows.State.REJECTED;\n                }\n                return _.reduceRight(executed, function chainRollbacks(result, step) {\n                    return result.finally(function executeRollbacks() {\n                        return Promise.call(_.bind(step.rollback, getStepContext(step)), failureReason);\n                    });\n                }, Promise.when()).finally(function executeFailureHandlers() {\n                    return new Promise(function WorkflowFailurePromise(finish) {\n                        var promises = [];\n                        dag(edges, MAX_CONCURRENCY, function runStepFailure(stepName, next) {\n                            var step = _.find(executed, {name: stepName});\n                            if (!step && fns.hasOwnProperty(stepName)) {\n                                step = getFullStep(stepName);\n                            }\n                            if (!!step) {\n                                promises.push(Promise.call(_.bind(step.failure, getStepContext(step)), failureReason));\n                            }\n                            next();\n                        }, function done() {\n                            Promise\n                                .settle(promises)\n                                .done(function ignore() {\n                                    finish();\n                                });\n                        });\n                    });\n                }).finally(function wrapAsWorkflowError() {\n                    var metaData = {\n                        workflow: wf.name,\n                        executed : _.map(executed, 'name')\n                    };\n                    if (_.isError(failureReason)) {\n                        failureReason = Errors.get(reason, 'WorkflowError', 'An error occurred during the dispatch', metaData);\n                    } else {\n                        failureReason = Errors.get('WorkflowError', failureReason, metaData);\n                    }\n                    reject(failureReason);\n                });\n            }\n\n            /**\n             * Finishes any timers that are running.\n             * @private\n             * @returns {undefined}\n             */\n            function complete() {\n                var isNotStopped = _.matches({state: 2});\n                if (!!localTracking) {\n                    // if the workflow ends early, we need\n                    // to remove any child timers that might\n                    // be running before we can call stop\n                    // on the workflow's timer\n                    baseTimer.children = _.filter(baseTimer.children, isNotStopped);\n                    baseTimer.stop(_.assignIn({\n                        category: 'workflows',\n                        tags: ['workflow']\n                    }, localTracking));\n                } else {\n                    baseTimer.reset();\n                }\n                baseTimer = null;\n                notify(WORKFLOW_COMPLETE);\n            }\n\n            /**\n             * @private\n             * @param {String} stepName The step that was requested.\n             * @param {Function} proceed The success callback to invoke if the step exists.\n             * @param {Function} abort An error generator routine.\n             * @returns {boolean} Whether the step was missing or not.\n             */\n            function isStepMissing(stepName, proceed, abort) {\n                if (fns.hasOwnProperty(stepName)) {\n                    return false;\n                }\n                if (!!wf[MISSING_KEY]) {\n                    Promise.call(wf[MISSING_KEY], stepName)\n                        .then(proceed, abort('onMissingStep handler rejected'))\n                        .catch()\n                        .done();\n                } else {\n                    abort('Step `' + stepName + '` was not found.')();\n                }\n                return true;\n            }\n\n            baseTimer.start();\n\n            notify(WORKFLOW_STARTING);\n\n            dag(edges, MAX_CONCURRENCY, function processStep(stepName, next) {\n\n                /**\n                 * The next step should be executed.\n                 * @private\n                 * @returns {undefined}\n                 */\n                function proceed() {\n                    if (!aborted) {\n                        next();\n                    }\n                }\n\n                /**\n                 * The step failed and the workflow should be aborted.\n                 * @private\n                 * @param {String} msg The message to reject the dispatch promise with.\n                 * @returns {Function} A function that can be invoked to reject the promise with an optional message.\n                 */\n                function abort(msg) {\n                    return function doAbort(err) {\n                        if (!aborted) {\n                            aborted = true;\n                            next(err || msg);\n                        }\n                    };\n                }\n\n                if (isStepMissing(stepName, proceed, abort)) {\n                    return;\n                }\n\n                /* eslint \"vars-on-top\": 0 */\n\n                var step = getFullStep(stepName),\n\n                    stepContext = getStepContext(step),\n\n                    tryExecuteStep = function tryExecuteStep() {\n\n                        var stepSuccess = function stepSuccess(result) {\n                                context.results[stepName] = result;\n                                proceed();\n                            },\n\n                            stepFailure = function stepFailure(originalReason) {\n                                return aborted || Promise.call(_.bind(step.retry, stepContext), originalReason)\n                                    .then(tryExecuteStep, abort(originalReason || 'step failed: ' + stepName));\n                            },\n\n                            stepTimer = baseTimer.add(stepName);\n\n                        stepTimer.start();\n\n                        return Promise.race([\n                            canceled.promise.catch(function abortWorkflow(err) {\n                                context.state = Workflows.State.CANCELED;\n                                abort('workflow canceled')(err);\n                                return undefined; // swallow and resolve\n                            }),\n                            Promise.apply(_.bind(step.execute, stepContext), localArgs || [])\n                                .then(stepSuccess, stepFailure)\n                        ]).finally(function houseKeeping() {\n                            stepTimer.stop();\n                            notify(Number((fns.length / executed.length * WORKFLOW_COMPLETE).toFixed(PERCENT_PRECISION)));\n                        });\n\n                    };\n\n                if (!_.includes(executed, step)) {\n                    executed.push(step);\n                }\n\n                tryExecuteStep();\n\n                if (localTimeout !== DEFAULT_TIMEOUT) {\n                    setTimeout(abort('Workflow dispatch timed out.'), localTimeout);\n                }\n\n            }, _.once(function dagCompleted(data) {\n                complete();\n                if (_.isNil(data)) {\n                    success();\n                } else {\n                    failure(data);\n                }\n            }));\n\n        }), new Cancelable());\n\n    };\n\n    return Workflows;\n\n});\n\n"]}