{"version":3,"sources":["webpack:///./node_modules/@paypalcorp/fpti/dist/fpti.js","webpack:///./src/components/integration-builder/hooks/use-isomorphic-layout-effect/index.tsx","webpack:///./src/utils/auto-id/index.tsx","webpack:///./src/utils/withAnalytics.tsx","webpack:///./src/react-utils/context/index.ts","webpack:///./src/react-utils/form-control-utils/index.tsx","webpack:///./src/react-utils/function/index.tsx","webpack:///./src/components/integration-builder/hooks/use-boolean/index.ts","webpack:///./src/components/integration-builder/hooks/use-ids/index.tsx","webpack:///./src/components/integration-builder/utils/misc.ts","webpack:///./node_modules/lodash.mergewith/index.js","webpack:///./src/components/integration-builder/hooks/use-safe-layout-effect/index.tsx","webpack:///./src/components/integration-builder/hooks/use-force-update/index.tsx","webpack:///./src/components/integration-builder/hooks/use-unmount-effect/index.tsx"],"names":["getNearestInt","num","Math","round","parseFloat","uuid","cryptoObj","window","crypto","msCrypto","random32ByteNumber","randomNumber","rnds32","Uint32Array","getRandomValues","e","random","toString","storages","s","l","getStorage","store","get3pStorage","fpti_3p","key","value","getItem","_getItem","vid","vid_exp","fpti","fpti_exp","now","Date","JSON","parse","item","storage","setItem","_setItem","setLocalItem","stringify","appendDataToURL","url","data","appendQueryStringData","indexOf","charAt","length","encodeURIComponent","fireImagePixel","src","Image","t","ua","navigator","userAgent","isIE","test","isIOSSafari","shouldUpdateReferrerPolicy","referrerPolicy","impressionKeys","normalizeData","dataObject","generateBeaconUrl","options","fptiserverurl","parts","split","match","location","protocol","version","basePayLoad","getTime","g","getTimezoneOffset","start","end","view","t11","undefined","createTrackingPayload","beaconURL","onBeaconCreate","_tenantName","tenant_name","hostname","fpti3pIds","base","obj","shouldOverride","extend","record","inputData","beaconUrl","exports","recordImpression","preRecordCallback","document","title","referrer","screen","colorDepth","screenDimensions","width","height","deviceDimensions","ratio","devicePixelRatio","w","h","abs","orientation","temp","getDeviceDimensions","elem","a","browserDimensions","documentElement","body","cookieEnabled","res","recordWithFetch","result","fetch","useIsomorphicLayoutEffect","React","serverHandoffComplete","id","genId","useId","idFromProps","initialId","setId","useLayoutEffect","String","withAnalytics","Component","props","createContext","strict","errorMessage","name","Context","displayName","Provider","useContext","context","error","Error","captureStackTrace","runIfFn","valueOrFn","args","useBoolean","initialState","useState","setValue","on","useCallback","off","toggle","prev","useIds","idProp","prefixes","map","prefix","callAllHandlers","fns","event","some","fn","defaultPrevented","assignRef","ref","isFunction","current","mergeRefs","refs","node","forEach","isBrowser","createElement","reIsHostCtor","reIsUint","typedArrayTags","freeGlobal","global","Object","freeSelf","self","root","Function","freeExports","nodeType","freeModule","module","moduleExports","freeProcess","process","nodeUtil","types","require","binding","nodeIsTypedArray","isTypedArray","apply","func","thisArg","call","uid","transform","arrayProto","Array","prototype","funcProto","objectProto","coreJsData","funcToString","hasOwnProperty","maskSrcKey","exec","keys","IE_PROTO","nativeObjectToString","objectCtorString","reIsNative","RegExp","replace","Buffer","Symbol","Uint8Array","allocUnsafe","getPrototype","getPrototypeOf","arg","objectCreate","create","propertyIsEnumerable","splice","symToStringTag","toStringTag","defineProperty","getNative","nativeIsBuffer","isBuffer","nativeMax","max","nativeNow","Map","nativeCreate","baseCreate","object","proto","isObject","Hash","entries","index","this","clear","entry","set","ListCache","MapCache","Stack","__data__","size","arrayLikeKeys","inherited","isArr","isArray","isArg","isArguments","isBuff","isType","skipIndexes","n","iteratee","baseTimes","isIndex","push","assignMergeValue","eq","baseAssignValue","assignValue","objValue","assocIndexOf","array","has","get","pop","getMapData","pairs","LARGE_ARRAY_SIZE","fromRight","baseFor","keysFunc","iterable","baseGetTag","isOwn","tag","unmasked","getRawTag","objectToString","baseIsArguments","isObjectLike","baseIsNative","isMasked","toSource","baseKeysIn","nativeKeysIn","isProto","isPrototype","baseMerge","source","srcIndex","customizer","stack","srcValue","mergeFunc","safeGet","stacked","newValue","isCommon","isTyped","isArrayLike","copyArray","buffer","isDeep","slice","constructor","copy","cloneBuffer","typedArray","arrayBuffer","byteLength","byteOffset","Ctor","isPlainObject","isNew","copyObject","keysIn","toPlainObject","initCloneObject","baseMergeDeep","baseRest","setToString","arguments","otherArgs","overRest","identity","type","getValue","count","lastCalled","stamp","remaining","shortOut","string","other","isLength","baseUnary","assigner","mergeWith","sources","guard","isIterateeCall","useSafeLayoutEffect","useForceUpdate","unloadingRef","setCount","useUnmountEffect","deps"],"mappings":"2FAuCA,SAASA,EAAcC,GACrB,OAAOC,KAAKC,MAAMC,WAAWH,KAAS,EAuCxC,SAASI,IACP,IAAIC,EAAYC,OAAOC,QAAUD,OAAOE,SAEpCC,EAAqB,WACvB,IAAIC,EAGJ,IACE,IAAIC,EAAS,IAAIC,YAAY,GAC7BP,EAAUQ,gBAAgBF,GAC1BD,EALoB,WAKLC,EAAO,GACtB,MAAOG,GACPJ,EAAeT,KAAKC,MAPA,WAOwBD,KAAKc,UAGnD,OAAOL,EAAaM,SAAS,KAG/B,OAAOP,IAAuBA,IA3FhC,EAAQ,QAER,EAAQ,QAwGR,IAAIQ,EAAW,CACbC,EAAG,iBACHC,EAAG,gBAOL,SAASC,EAAWF,GAClB,IAAIG,EAEJ,IACEA,EAAQf,OAAOW,EAASC,IACxB,MAAOJ,GACPO,EAAQ,KAGV,OAAOA,EAgET,SAASC,IACP,IAAIC,EAAU,KAEd,GAfSH,EAAW,KAepB,CAIA,IAxCoBI,EA0BN,UAeZD,EArEJ,SAAkBF,EAAOG,GACvB,IAAIC,EAMJ,OAJIJ,IACFI,EAAQJ,EAAMK,QAAQF,IAGjBC,EAsBAE,CAASP,EAAW,KAAMI,GAyC/B,IAAII,EAAM,KACNC,EAAU,KACVC,EAAO,KACPC,EAAW,KACXC,EAAMC,KAAKD,MAEXT,GAKAK,GAHFL,EAAUW,KAAKC,MAAMZ,IAETK,KAAOL,EAAQM,QAAUG,EAC7BT,EAAQK,IAERxB,IAKN0B,EADEP,EAAQO,MAAQP,EAAQQ,SAAWC,EAC9BT,EAAQO,KAER1B,IAITyB,EAAUG,EA1CM,KA2ChBD,EAAWC,EA1CA,UA6CXJ,EAAMxB,IACNyB,EAAUG,EA/CM,KAgDhBF,EAAO1B,IACP2B,EAAWC,EAhDA,SAoDbT,EAAU,CACRK,IAAKA,EACLC,QAASA,EACTC,KAAMA,EACNC,SAAUA,GAtEhB,SAAsBP,EAAKY,IA7B3B,SAAkBC,EAASb,EAAKY,GAC9B,GAAKC,GAAYD,EAIjB,IACEC,EAAQC,QAAQd,EAAKY,GACrB,MAAOtB,KAuBTyB,CAASnB,EAAW,KAAMI,EAAKY,GAuE7BI,CAzDY,UAyDYN,KAAKO,UAAUlB,IACvC,MAAOT,IApFX,IAAsBU,EAuFpB,OAAOD,GAeT,SAASmB,EAAgBC,EAAKC,GAC5B,IAAK,IAAIpB,KAAOoB,EACVpB,QAA4B,IAAdoB,EAAKpB,IAAsC,KAAdoB,EAAKpB,KAClDmB,EAAME,EAAsBF,EAAKnB,EAAKoB,EAAKpB,KAI/C,OAAOmB,EAgBT,SAASE,EAAsBF,EAAKnB,EAAKC,GACvC,GAAID,IAAQC,GAAmB,IAAVA,IAAyB,IAAVA,GAAkB,CACpD,GAAqB,iBAAVA,EACT,IACEA,EAAQS,KAAKO,UAAUhB,GACvB,MAAOX,GACPW,EAAQ,SAIc,IAAtBkB,EAAIG,QAAQ,OACdH,GAAO,KAG0B,MAA/BA,EAAII,OAAOJ,EAAIK,OAAS,KAC1BL,GAAO,KAGTA,GAAOnB,EAAM,IAAMyB,mBAAmBxB,GAGxC,OAAOkB,EAgFT,SAASO,EAAeC,GACtB,GAAKA,GAA2B,oBAAX7C,QAA0BA,OAAO8C,MAAtD,CAIA,IAAIC,EAAI,IAAI/C,OAAO8C,MAAM,EAAG,GAC5BC,EAAEF,IAAMA,EAOV,WACE,IACIG,EADYhD,OAAOiD,UACJC,UACfC,EAAO,gBAAgBC,KAAKJ,GAC5BK,GAAe,QAAQD,KAAKJ,IAAO,UAAUI,KAAKJ,KAAQ,UAAUI,KAAKJ,IAAO,SAASI,KAAKJ,GAElG,GAAIG,GAAQE,EACV,OAAO,EAGT,OAAO,EAfHC,KACFP,EAAEQ,eAAiB,+BAiBvB,IAGIC,EACc,KADdA,EAES,KAFTA,EAGQ,KAHRA,EAIgB,KAJhBA,EAKW,KALXA,EAMY,KANZA,EAOW,KAPXA,EAQY,KARZA,EASY,KATZA,EAUa,KASjB,SAASC,EAAcC,GAWrB,OARIA,GAAcA,EAAWpB,KACpBoB,EAEA,CACLpB,KAAMoB,GAAc,IAQ1B,SAASC,EAAkBC,EAAStB,GAClC,IAAID,EAAMuB,EAAQvB,KAAyB,oBAAXrC,QAA0BA,OAAO6D,eApC/C,0BAqCdC,EAAQzB,EAAI0B,MAAM,MACtB1B,EAAMyB,EAAM,IAGJE,MAAM,WACZ3B,GAA2B,oBAAb4B,UAA4BA,SAASC,UAAY,IAAM7B,GAIvEA,GAAO,IAEHyB,EAAM,KACRzB,GAAOyB,EAAM,GAAK,KAGpBzB,GAAO,KAAOM,mBAAmBiB,EAAQO,SArD7B,SAuDZ,IAAIC,EAAc,CAChBrB,GA3cK,IAAIpB,MAAO0C,UA6chBC,GApcK,IAAI3C,MAAO4C,qBAwclB,GAAIjC,EAAKkC,MAAO,CACd,IAAIC,EAAMnC,EAAKmC,KAAOL,EAAYrB,EAClCT,EAAKoC,KAAOpC,EAAKoC,MAAQ,GACzBpC,EAAKoC,KAAKC,IAAMF,EAAMnC,EAAKkC,MAC3BlC,EAAKkC,MAAQlC,EAAKmC,SAAMG,EAK1B,OAFAvC,EAAMD,EAAgBC,EAAK+B,GAC3B/B,EAAMD,EAAgBC,EAAKC,GAI7B,SAASuC,EAAsBjB,EAAStB,GACtC,IAAIwC,EACAC,EAAiBnB,EAAQmB,eAEzBC,EAAchF,OAAOwB,MAAQxB,OAAOwB,KAAKyD,aA/EjC,aAkFZ,GAAwB,oBAAbhB,WAA8E,IAAlDA,SAASiB,SAAS1C,QAAQ,IAAMwC,GAAqB,CAC1F,IAAIG,EAAYnE,IAEZmE,GAxbR,SAAgBC,EAAMC,EAAKC,GAQzB,IAAK,IAAIpE,UAPqB,IAAnBoE,IACTA,GAAiB,GAGnBF,EAAOA,GAAQ,GACfC,EAAMA,GAAO,QAGa,IAAbA,EAAInE,KAAyBoE,IAAmBA,QAAuC,IAAdF,EAAKlE,MACvFkE,EAAKlE,GAAOmE,EAAInE,IA+ahBqE,CAAOjD,EAAM,CACX,SAAU6C,EAAU7D,IACpB,UAAW6D,EAAU3D,OAW3B,QANKuD,GAA4C,mBAAnBA,IAAsD,IAArBA,OAE7DD,EAAYnB,EAAkBC,EAAStB,IAGzCM,EAAekC,GACRA,EAcT,SAASU,EAAOC,GACd,IAAI7B,EAAUH,EAAcgC,GACxBC,EAAYb,EAAsBjB,EAASA,EAAQtB,MACvD,MAAO,CACLA,KAAMsB,EAAQtB,KACdD,IAAKqD,GA6ETC,EAAQd,sBAAwBA,EAChCc,EAAQhC,kBAAoBA,EAC5BgC,EAAQlC,cAAgBA,EACxBkC,EAAQH,OAASA,EACjBG,EAAQC,iBAlER,SAA0BH,EAAWI,GACnC,IAAIjC,EAAUH,EAAcgC,GACxBnD,EAAOsB,EAAQtB,KAEnBA,EAAKkB,GAA4BsC,SAASC,MAE1CzD,EAAKkB,GAA2BsC,SAASE,SAEzC1D,EAAKkB,GArLExD,OAAOiG,OAAOC,WAuLrB,IApMID,EAoMAE,EAnMG,CACLC,OAFEH,EAASjG,OAAOiG,QAAU,IAEdG,MACdC,OAAQJ,EAAOI,QAkMjB/D,EAAKkB,GAA8B2C,EAAiBC,MACpD9D,EAAKkB,GAA+B2C,EAAiBE,OAErD,IAAIC,EAjON,WACE,IAAIL,EAASjG,OAAOiG,QAAU,GAC1BM,EAAQvG,OAAOwG,kBAAoB,EACnCC,EAAIhH,EAAcwG,EAAOG,MAAQG,GACjCG,EAAIjH,EAAcwG,EAAOI,OAASE,GAEtC,GAAqC,KAAjC5G,KAAKgH,IAAI3G,OAAO4G,aAAqB,CAEvC,IAAIC,EAAOJ,EACXA,EAAIC,EACJA,EAAIG,EAGN,MAAO,CACLT,MAAOK,EACPJ,OAAQK,GAkNaI,GACvBxE,EAAKkB,GAA8B8C,EAAiBF,MACpD9D,EAAKkB,GAA+B8C,EAAiBD,OAErD,IAxPIU,EACAC,EAuPAC,GAxPAF,EAAO/G,OACPgH,EAAI,QAEF,eAAgBhH,SACpBgH,EAAI,SACJD,EAAOjB,SAASoB,iBAAmBpB,SAASqB,MAGvC,CACLf,MAAOW,EAAKC,EAAI,SAChBX,OAAQU,EAAKC,EAAI,YA+OnB1E,EAAKkB,GAA+ByD,EAAkBb,MACtD9D,EAAKkB,GAAgCyD,EAAkBZ,OAEvD/D,EAAKkB,GA9LSP,UAAUmE,cAAgB,EAAI,EA+L5C,IAAIC,EAAM,CACR/E,KAAMsB,EAAQtB,KACdD,IAAK,IAYP,MATiC,mBAAtBwD,EACTA,GAAkB,WAEhB,OADAwB,EAAIhF,IAAMwC,EAAsBjB,EAAStB,GAClC+E,KAGTA,EAAIhF,IAAMwC,EAAsBjB,EAAStB,GAGpC+E,GA8BT1B,EAAQ2B,gBAfR,SAAyB7B,GACvB,IAAI8B,EAAS/B,EAAOC,GAMpB,MAJqB,oBAAV+B,OACTA,MAAMD,EAAOlF,KAGRkF,I,oFC3lBIE,EACO,oBAAXzH,OAAyB0H,kBAAwBA,YCItDC,GAAwB,EACxBC,EAAK,EACHC,EAAQ,mBAAQD,GAetB,SAASE,EAAMC,GAKb,IAAMC,EAAYD,IAAgBJ,EAAwBE,IAAU,MAEpE,EAAoBH,WAAeM,GAA5BJ,EAAP,KAAWK,EAAX,KAyBA,OAvBAC,GAAgB,WACH,OAAPN,GAOFK,EAAMJ,OAGP,IAEHH,aAAgB,YACgB,IAA1BC,IAMFA,GAAwB,KAEzB,IACU,MAANC,EAAaO,OAAOP,QAAMhD,I,kCCxDnC,qCASewD,IANO,SAACC,GACrB,OAAO,SAACC,GAAD,OACL,kBAACD,EAAD,iBAAeC,EAAf,CAAsB9G,KAAM,CAAEgE,gBAAQI,2C,kCCL1C,kDA0BO,SAAS2C,EAA2B3E,QAAoC,IAApCA,MAAgC,IACzE,MAIIA,EAJJ,IACE4E,cADF,aAEEC,oBAFF,MAEiB,6FAFjB,EAGEC,EAHF,EAGEA,KAGIC,EAAUjB,qBAA6C9C,GAiB7D,OAfA+D,EAAQC,YAAcF,EAef,CACLC,EAAQE,SAdV,SAASC,IACP,IAAMC,EAAUrB,aAAiBiB,GAEjC,IAAKI,GAAWP,EAAQ,OAChBQ,EAAQ,IAAIC,MAAMR,GAGxB,MAFAO,EAAMN,KAAO,eACb,UAAAO,MAAMC,yBAAN,cAAAD,MAA0BD,EAAOF,GAC3BE,EAGR,OAAOD,GAMPJ,K,4NCCJ,MACEJ,YAA0C,CACxCC,QAAQ,EACRE,KAAM,uBAHV,U,yBC9BO,SAASS,EACdC,GAEG,2BADAC,EACA,iCADAA,EACA,kBACH,OAAO,IAAWD,GAAaA,EAAS,WAAT,EAAaC,GAAQD,E,uDC5BtD,kDASO,SAASE,EAAWC,QAAoC,IAApCA,OAA6B,GACtD,MAA0BC,mBAASD,GAA5BpI,EAAP,KAAcsI,EAAd,KAcA,MAAO,CAACtI,EAAO,CAAEuI,GAZNC,uBAAY,WACrBF,GAAS,KACR,IAUkBG,IARTD,uBAAY,WACtBF,GAAS,KACR,IAMuBI,OAJXF,uBAAY,WACzBF,GAAS,SAACK,GAAD,OAAWA,OACnB,Q,kCCtBL,8DAkBO,SAASC,EAAOC,GAAwC,2BAApBC,EAAoB,iCAApBA,EAAoB,kBAC7D,IAAMrC,EAAKE,YAAMkC,GACjB,OAAOtC,WAAc,WACnB,OAAOuC,EAASC,KAAI,SAACC,GAAD,OAAeA,EAAf,IAAyBvC,OAC5C,CAACA,EAAIqC,M,oCCTV,SAASG,IAEP,2BADGC,EACH,yBADGA,EACH,gBACA,OAAO,SAAcC,GACnBD,EAAIE,MAAK,SAACC,GAER,OADAA,WAAKF,GACEA,aAAP,EAAOA,EAAOG,qBAnBpB,sGA6BA,SAASC,EAAmBC,EAA8BxJ,GACxD,GAAW,MAAPwJ,EAEJ,GARiB,SAACxJ,GAAD,MACA,mBAAVA,EAOHyJ,CAAWD,GACbA,EAAIxJ,QAIN,IAEEwJ,EAAIE,QAAU1J,EACd,MAAO6H,GACP,MAAM,IAAIC,MAAJ,wBAAkC9H,EAAlC,aAAoDwJ,EAApD,MAWV,SAASG,IAAmD,2BAAnCC,EAAmC,yBAAnCA,EAAmC,gBAC1D,OAAO,SAACC,GACND,EAAKE,SAAQ,SAACN,GAAD,OAASD,EAAUC,EAAKK,OAmBzC,IAAME,IANgB,oBAAXlL,SACPA,OAAO8F,WACP9F,OAAO8F,SAASqF,gB,sBCrEpB,cAUA,IAkDIC,EAAe,8BAGfC,EAAW,mBAGXC,EAAiB,GACrBA,EAxBiB,yBAwBYA,EAvBZ,yBAuByCA,EAtB5C,sBAsBsEA,EArBrE,uBAqBgGA,EApBhG,uBAoB2HA,EAnB3H,uBAmBsJA,EAlB/I,8BAkBiLA,EAjBvL,wBAiBmNA,EAhBnN,yBAgB+O,EAC/PA,EA7Cc,sBA6CYA,EA5CX,kBA4CsCA,EA3BhC,wBA2BiEA,EA1CxE,oBA0CkGA,EA1B9F,qBA0B4HA,EAzChI,iBAyC0JA,EAxCzJ,kBAwCoLA,EAvCrL,qBAuC+MA,EArChN,gBAqCyOA,EApCtO,mBAoCkQA,EAlClQ,mBAkC8RA,EAhC9R,mBAgC0TA,EA/B7T,gBA+BsVA,EA9BnV,mBA8B+WA,EA5B9W,qBA4B2Y,EAG5Z,IAAIC,EAA8B,iBAAVC,GAAsBA,GAAUA,EAAOC,SAAWA,QAAUD,EAGhFE,EAA0B,iBAARC,MAAoBA,MAAQA,KAAKF,SAAWA,QAAUE,KAGxEC,EAAOL,GAAcG,GAAYG,SAAS,cAATA,GAGjCC,EAA4CnG,IAAYA,EAAQoG,UAAYpG,EAG5EqG,EAAaF,GAAgC,iBAAVG,GAAsBA,IAAWA,EAAOF,UAAYE,EAGvFC,EAAgBF,GAAcA,EAAWrG,UAAYmG,EAGrDK,EAAcD,GAAiBX,EAAWa,QAG1CC,EAAW,WACb,IAEE,IAAIC,EAAQN,GAAcA,EAAWO,SAAWP,EAAWO,QAAQ,QAAQD,MAE3E,OAAIA,GAKGH,GAAeA,EAAYK,SAAWL,EAAYK,QAAQ,QACjE,MAAOhM,KAXI,GAgBXiM,EAAmBJ,GAAYA,EAASK,aAY5C,SAASC,EAAMC,EAAMC,EAASxD,GAC5B,OAAQA,EAAK3G,QACX,KAAK,EACH,OAAOkK,EAAKE,KAAKD,GAEnB,KAAK,EACH,OAAOD,EAAKE,KAAKD,EAASxD,EAAK,IAEjC,KAAK,EACH,OAAOuD,EAAKE,KAAKD,EAASxD,EAAK,GAAIA,EAAK,IAE1C,KAAK,EACH,OAAOuD,EAAKE,KAAKD,EAASxD,EAAK,GAAIA,EAAK,GAAIA,EAAK,IAGrD,OAAOuD,EAAKD,MAAME,EAASxD,GAoE7B,IAeM0D,EAvBWH,EAAMI,EAQnBC,EAAaC,MAAMC,UACnBC,EAAYvB,SAASsB,UACrBE,EAAc5B,OAAO0B,UAGrBG,EAAa1B,EAAK,sBAGlB2B,EAAeH,EAAU1M,SAGzB8M,EAAiBH,EAAYG,eAG7BC,GACEV,EAAM,SAASW,KAAKJ,GAAcA,EAAWK,MAAQL,EAAWK,KAAKC,UAAY,KACxE,iBAAmBb,EAAM,GASpCc,EAAuBR,EAAY3M,SAGnCoN,EAAmBP,EAAaT,KAAKrB,QAGrCsC,EAAaC,OAAO,IAAMT,EAAaT,KAAKU,GAAgBS,QAjL7C,sBAiLmE,QAAQA,QAAQ,yDAA0D,SAAW,KAGvKC,EAAShC,EAAgBN,EAAKsC,YAAStJ,EACvCuJ,EAASvC,EAAKuC,OACdC,EAAaxC,EAAKwC,WAClBC,EAAcH,EAASA,EAAOG,iBAAczJ,EAC5C0J,GA9Ca1B,EA8CUnB,OAAO8C,eA9CXvB,EA8C2BvB,OA7CzC,SAAU+C,GACf,OAAO5B,EAAKI,EAAUwB,MA6CtBC,EAAehD,OAAOiD,OACtBC,EAAuBtB,EAAYsB,qBACnCC,EAAS3B,EAAW2B,OACpBC,EAAiBV,EAASA,EAAOW,iBAAclK,EAE/CmK,EAAiB,WACnB,IACE,IAAInC,EAAOoC,GAAUvD,OAAQ,kBAE7B,OADAmB,EAAK,GAAI,GAAI,IACNA,EACP,MAAOpM,KALU,GAUjByO,EAAiBf,EAASA,EAAOgB,cAAWtK,EAC5CuK,EAAYxP,KAAKyP,IACjBC,EAAY1N,KAAKD,IAGjB4N,EAAMN,GAAUpD,EAAM,OACtB2D,EAAeP,GAAUvD,OAAQ,UAUjC+D,EAAa,WACf,SAASC,KAET,OAAO,SAAUC,GACf,IAAKC,GAASD,GACZ,MAAO,GAGT,GAAIjB,EACF,OAAOA,EAAaiB,GAGtBD,EAAOtC,UAAYuC,EACnB,IAAInI,EAAS,IAAIkI,EAEjB,OADAA,EAAOtC,eAAYvI,EACZ2C,GAfM,GA2BjB,SAASqI,EAAKC,GACZ,IAAIC,GAAS,EACTpN,EAAoB,MAAXmN,EAAkB,EAAIA,EAAQnN,OAG3C,IAFAqN,KAAKC,UAEIF,EAAQpN,GAAQ,CACvB,IAAIuN,EAAQJ,EAAQC,GACpBC,KAAKG,IAAID,EAAM,GAAIA,EAAM,KAsG7B,SAASE,EAAUN,GACjB,IAAIC,GAAS,EACTpN,EAAoB,MAAXmN,EAAkB,EAAIA,EAAQnN,OAG3C,IAFAqN,KAAKC,UAEIF,EAAQpN,GAAQ,CACvB,IAAIuN,EAAQJ,EAAQC,GACpBC,KAAKG,IAAID,EAAM,GAAIA,EAAM,KAoH7B,SAASG,EAASP,GAChB,IAAIC,GAAS,EACTpN,EAAoB,MAAXmN,EAAkB,EAAIA,EAAQnN,OAG3C,IAFAqN,KAAKC,UAEIF,EAAQpN,GAAQ,CACvB,IAAIuN,EAAQJ,EAAQC,GACpBC,KAAKG,IAAID,EAAM,GAAIA,EAAM,KAkG7B,SAASI,EAAMR,GACb,IAAIvN,EAAOyN,KAAKO,SAAW,IAAIH,EAAUN,GACzCE,KAAKQ,KAAOjO,EAAKiO,KA2GnB,SAASC,EAAcrP,EAAOsP,GAC5B,IAAIC,EAAQC,GAAQxP,GAChByP,GAASF,GAASG,GAAY1P,GAC9B2P,GAAUJ,IAAUE,GAAS1B,GAAS/N,GACtC4P,GAAUL,IAAUE,IAAUE,GAAUpE,GAAavL,GACrD6P,EAAcN,GAASE,GAASE,GAAUC,EAC1CxJ,EAASyJ,EA5lBf,SAAmBC,EAAGC,GAIpB,IAHA,IAAIpB,GAAS,EACTvI,EAAS2F,MAAM+D,KAEVnB,EAAQmB,GACf1J,EAAOuI,GAASoB,EAASpB,GAG3B,OAAOvI,EAolBoB4J,CAAUhQ,EAAMuB,OAAQyF,QAAU,GACzDzF,EAAS6E,EAAO7E,OAEpB,IAAK,IAAIxB,KAAOC,GACTsP,IAAajD,EAAeV,KAAK3L,EAAOD,IAAW8P,IACjD,UAAP9P,GACA4P,IAAkB,UAAP5P,GAA0B,UAAPA,IAC9B6P,IAAkB,UAAP7P,GAA0B,cAAPA,GAA8B,cAAPA,IACrDkQ,GAAQlQ,EAAKwB,KACX6E,EAAO8J,KAAKnQ,GAIhB,OAAOqG,EAaT,SAAS+J,EAAiB7B,EAAQvO,EAAKC,SACvByD,IAAVzD,IAAwBoQ,GAAG9B,EAAOvO,GAAMC,SAAoByD,IAAVzD,KAAyBD,KAAOuO,KACpF+B,EAAgB/B,EAAQvO,EAAKC,GAejC,SAASsQ,EAAYhC,EAAQvO,EAAKC,GAChC,IAAIuQ,EAAWjC,EAAOvO,GAEhBsM,EAAeV,KAAK2C,EAAQvO,IAAQqQ,GAAGG,EAAUvQ,UAAqByD,IAAVzD,GAAyBD,KAAOuO,IAChG+B,EAAgB/B,EAAQvO,EAAKC,GAajC,SAASwQ,EAAaC,EAAO1Q,GAG3B,IAFA,IAAIwB,EAASkP,EAAMlP,OAEZA,KACL,GAAI6O,GAAGK,EAAMlP,GAAQ,GAAIxB,GACvB,OAAOwB,EAIX,OAAQ,EAaV,SAAS8O,EAAgB/B,EAAQvO,EAAKC,GACzB,aAAPD,GAAsB6N,EACxBA,EAAeU,EAAQvO,EAAK,CAC1B,cAAgB,EAChB,YAAc,EACd,MAASC,EACT,UAAY,IAGdsO,EAAOvO,GAAOC,EA/blByO,EAAKzC,UAAU6C,MA7Ef,WACED,KAAKO,SAAWf,EAAeA,EAAa,MAAQ,GACpDQ,KAAKQ,KAAO,GA4EdX,EAAKzC,UAAkB,OA9DvB,SAAoBjM,GAClB,IAAIqG,EAASwI,KAAK8B,IAAI3Q,WAAe6O,KAAKO,SAASpP,GAEnD,OADA6O,KAAKQ,MAAQhJ,EAAS,EAAI,EACnBA,GA4DTqI,EAAKzC,UAAU2E,IA/Cf,SAAiB5Q,GACf,IAAIoB,EAAOyN,KAAKO,SAEhB,GAAIf,EAAc,CAChB,IAAIhI,EAASjF,EAAKpB,GAClB,MAvViB,8BAuVVqG,OAA4B3C,EAAY2C,EAGjD,OAAOiG,EAAeV,KAAKxK,EAAMpB,GAAOoB,EAAKpB,QAAO0D,GAwCtDgL,EAAKzC,UAAU0E,IA3Bf,SAAiB3Q,GACf,IAAIoB,EAAOyN,KAAKO,SAChB,OAAOf,OAA6B3K,IAAdtC,EAAKpB,GAAqBsM,EAAeV,KAAKxK,EAAMpB,IA0B5E0O,EAAKzC,UAAU+C,IAZf,SAAiBhP,EAAKC,GACpB,IAAImB,EAAOyN,KAAKO,SAGhB,OAFAP,KAAKQ,MAAQR,KAAK8B,IAAI3Q,GAAO,EAAI,EACjCoB,EAAKpB,GAAOqO,QAA0B3K,IAAVzD,EA1XT,4BA0XgDA,EAC5D4O,MA+HTI,EAAUhD,UAAU6C,MA3FpB,WACED,KAAKO,SAAW,GAChBP,KAAKQ,KAAO,GA0FdJ,EAAUhD,UAAkB,OA7E5B,SAAyBjM,GACvB,IAAIoB,EAAOyN,KAAKO,SACZR,EAAQ6B,EAAarP,EAAMpB,GAE/B,QAAI4O,EAAQ,KAMRA,GAFYxN,EAAKI,OAAS,EAG5BJ,EAAKyP,MAELnD,EAAO9B,KAAKxK,EAAMwN,EAAO,KAGzBC,KAAKQ,MACA,IA6DTJ,EAAUhD,UAAU2E,IAhDpB,SAAsB5Q,GACpB,IAAIoB,EAAOyN,KAAKO,SACZR,EAAQ6B,EAAarP,EAAMpB,GAC/B,OAAO4O,EAAQ,OAAIlL,EAAYtC,EAAKwN,GAAO,IA8C7CK,EAAUhD,UAAU0E,IAjCpB,SAAsB3Q,GACpB,OAAOyQ,EAAa5B,KAAKO,SAAUpP,IAAQ,GAiC7CiP,EAAUhD,UAAU+C,IAnBpB,SAAsBhP,EAAKC,GACzB,IAAImB,EAAOyN,KAAKO,SACZR,EAAQ6B,EAAarP,EAAMpB,GAS/B,OAPI4O,EAAQ,KACRC,KAAKQ,KACPjO,EAAK+O,KAAK,CAACnQ,EAAKC,KAEhBmB,EAAKwN,GAAO,GAAK3O,EAGZ4O,MA6GTK,EAASjD,UAAU6C,MAzEnB,WACED,KAAKQ,KAAO,EACZR,KAAKO,SAAW,CACd,KAAQ,IAAIV,EACZ,IAAO,IAAKN,GAAOa,GACnB,OAAU,IAAIP,IAqElBQ,EAASjD,UAAkB,OAvD3B,SAAwBjM,GACtB,IAAIqG,EAASyK,GAAWjC,KAAM7O,GAAa,OAAEA,GAE7C,OADA6O,KAAKQ,MAAQhJ,EAAS,EAAI,EACnBA,GAqDT6I,EAASjD,UAAU2E,IAxCnB,SAAqB5Q,GACnB,OAAO8Q,GAAWjC,KAAM7O,GAAK4Q,IAAI5Q,IAwCnCkP,EAASjD,UAAU0E,IA3BnB,SAAqB3Q,GACnB,OAAO8Q,GAAWjC,KAAM7O,GAAK2Q,IAAI3Q,IA2BnCkP,EAASjD,UAAU+C,IAbnB,SAAqBhP,EAAKC,GACxB,IAAImB,EAAO0P,GAAWjC,KAAM7O,GACxBqP,EAAOjO,EAAKiO,KAGhB,OAFAjO,EAAK4N,IAAIhP,EAAKC,GACd4O,KAAKQ,MAAQjO,EAAKiO,MAAQA,EAAO,EAAI,EAC9BR,MAgHTM,EAAMlD,UAAU6C,MAlFhB,WACED,KAAKO,SAAW,IAAIH,EACpBJ,KAAKQ,KAAO,GAiFdF,EAAMlD,UAAkB,OApExB,SAAqBjM,GACnB,IAAIoB,EAAOyN,KAAKO,SACZ/I,EAASjF,EAAa,OAAEpB,GAE5B,OADA6O,KAAKQ,KAAOjO,EAAKiO,KACVhJ,GAiET8I,EAAMlD,UAAU2E,IApDhB,SAAkB5Q,GAChB,OAAO6O,KAAKO,SAASwB,IAAI5Q,IAoD3BmP,EAAMlD,UAAU0E,IAvChB,SAAkB3Q,GAChB,OAAO6O,KAAKO,SAASuB,IAAI3Q,IAuC3BmP,EAAMlD,UAAU+C,IAzBhB,SAAkBhP,EAAKC,GACrB,IAAImB,EAAOyN,KAAKO,SAEhB,GAAIhO,aAAgB6N,EAAW,CAC7B,IAAI8B,EAAQ3P,EAAKgO,SAEjB,IAAKhB,GAAO2C,EAAMvP,OAASwP,IAGzB,OAFAD,EAAMZ,KAAK,CAACnQ,EAAKC,IACjB4O,KAAKQ,OAASjO,EAAKiO,KACZR,KAGTzN,EAAOyN,KAAKO,SAAW,IAAIF,EAAS6B,GAKtC,OAFA3P,EAAK4N,IAAIhP,EAAKC,GACd4O,KAAKQ,KAAOjO,EAAKiO,KACVR,MAmIT,IA+WuBoC,GA/WnBC,GAgXK,SAAU3C,EAAQyB,EAAUmB,GAMjC,IALA,IAAIvC,GAAS,EACTwC,EAAW7G,OAAOgE,GAClBnH,EAAQ+J,EAAS5C,GACjB/M,EAAS4F,EAAM5F,OAEZA,KAAU,CACf,IAAIxB,EAAMoH,EAAM6J,GAAYzP,IAAWoN,GAEvC,IAA+C,IAA3CoB,EAASoB,EAASpR,GAAMA,EAAKoR,GAC/B,MAIJ,OAAO7C,GArXX,SAAS8C,GAAWpR,GAClB,OAAa,MAATA,OACeyD,IAAVzD,EA/zBQ,qBANL,gBAw0BL0N,GAAkBA,KAAkBpD,OAAOtK,GAwZpD,SAAmBA,GACjB,IAAIqR,EAAQhF,EAAeV,KAAK3L,EAAO0N,GACnC4D,EAAMtR,EAAM0N,GAEhB,IACE1N,EAAM0N,QAAkBjK,EACxB,IAAI8N,GAAW,EACf,MAAOlS,IAET,IAAI+G,EAASsG,EAAqBf,KAAK3L,GAEnCuR,IACEF,EACFrR,EAAM0N,GAAkB4D,SAEjBtR,EAAM0N,IAIjB,OAAOtH,EA3aoDoL,CAAUxR,GAuiBvE,SAAwBA,GACtB,OAAO0M,EAAqBf,KAAK3L,GAxiB6CyR,CAAezR,GAW/F,SAAS0R,GAAgB1R,GACvB,OAAO2R,GAAa3R,IA91BR,sBA81BkBoR,GAAWpR,GAY3C,SAAS4R,GAAa5R,GACpB,SAAKwO,GAASxO,IA8dhB,SAAkByL,GAChB,QAASa,GAAcA,KAAcb,EA/dboG,CAAS7R,MAInByJ,GAAWzJ,GAAS4M,EAAa3C,GAChChI,KAonBjB,SAAkBwJ,GAChB,GAAY,MAARA,EAAc,CAChB,IACE,OAAOW,EAAaT,KAAKF,GACzB,MAAOpM,IAET,IACE,OAAOoM,EAAO,GACd,MAAOpM,KAGX,MAAO,GA/nBayS,CAAS9R,IAuB/B,SAAS+R,GAAWzD,GAClB,IAAKE,GAASF,GACZ,OA4dJ,SAAsBA,GACpB,IAAIlI,EAAS,GAEb,GAAc,MAAVkI,EACF,IAAK,IAAIvO,KAAOuK,OAAOgE,GACrBlI,EAAO8J,KAAKnQ,GAIhB,OAAOqG,EAreE4L,CAAa1D,GAGtB,IAAI2D,EAAUC,GAAY5D,GACtBlI,EAAS,GAEb,IAAK,IAAIrG,KAAOuO,GACD,eAAPvO,IAAyBkS,GAAY5F,EAAeV,KAAK2C,EAAQvO,KACrEqG,EAAO8J,KAAKnQ,GAIhB,OAAOqG,EAeT,SAAS+L,GAAU7D,EAAQ8D,EAAQC,EAAUC,EAAYC,GACnDjE,IAAW8D,GAIfnB,GAAQmB,GAAQ,SAAUI,EAAUzS,GAGlC,GAFAwS,IAAUA,EAAQ,IAAIrD,GAElBV,GAASgE,IA8BjB,SAAuBlE,EAAQ8D,EAAQrS,EAAKsS,EAAUI,EAAWH,EAAYC,GAC3E,IAAIhC,EAAWmC,GAAQpE,EAAQvO,GAC3ByS,EAAWE,GAAQN,EAAQrS,GAC3B4S,EAAUJ,EAAM5B,IAAI6B,GAExB,GAAIG,EAEF,YADAxC,EAAiB7B,EAAQvO,EAAK4S,GAIhC,IAAIC,EAAWN,EAAaA,EAAW/B,EAAUiC,EAAUzS,EAAM,GAAIuO,EAAQ8D,EAAQG,QAAS9O,EAC1FoP,OAAwBpP,IAAbmP,EAEf,GAAIC,EAAU,CACZ,IAAItD,EAAQC,GAAQgD,GAChB7C,GAAUJ,GAASxB,GAASyE,GAC5BM,GAAWvD,IAAUI,GAAUpE,GAAaiH,GAChDI,EAAWJ,EAEPjD,GAASI,GAAUmD,EACjBtD,GAAQe,GACVqC,EAAWrC,EAkqBVoB,GADkB3R,EAhqBQuQ,IAiqBHwC,GAAY/S,GAhqBpC4S,EAwHR,SAAmBR,EAAQ3B,GACzB,IAAI9B,GAAS,EACTpN,EAAS6Q,EAAO7Q,OACpBkP,IAAUA,EAAQ1E,MAAMxK,IAExB,OAASoN,EAAQpN,GACfkP,EAAM9B,GAASyD,EAAOzD,GAGxB,OAAO8B,EAjIUuC,CAAUzC,GACZZ,GACTkD,GAAW,EACXD,EAqER,SAAqBK,EAAQC,GAC3B,GAAIA,EACF,OAAOD,EAAOE,QAGhB,IAAI5R,EAAS0R,EAAO1R,OAChB6E,EAAS8G,EAAcA,EAAY3L,GAAU,IAAI0R,EAAOG,YAAY7R,GAExE,OADA0R,EAAOI,KAAKjN,GACLA,EA7EUkN,CAAYd,GAAU,IACxBM,GACTD,GAAW,EAqGMU,EApGUf,EAqG7BS,GArGuC,GAqFnBO,EAgBeD,EAAWN,OAf9C7M,EAAS,IAAIoN,EAAYJ,YAAYI,EAAYC,YACrD,IAAIxG,EAAW7G,GAAQ2I,IAAI,IAAI9B,EAAWuG,IACnCpN,GAaqDmN,EAAWN,OArGjEL,EAsGC,IAAIW,EAAWH,YAAYH,EAAQM,EAAWG,WAAYH,EAAWhS,SApGtEqR,EAAW,GAm0BnB,SAAuB5S,GACrB,IAAK2R,GAAa3R,IAlyDJ,mBAkyDcoR,GAAWpR,GACrC,OAAO,EAGT,IAAIuO,EAAQpB,EAAanN,GAEzB,GAAc,OAAVuO,EACF,OAAO,EAGT,IAAIoF,EAAOtH,EAAeV,KAAK4C,EAAO,gBAAkBA,EAAM6E,YAC9D,MAAsB,mBAARO,GAAsBA,aAAgBA,GAAQvH,EAAaT,KAAKgI,IAAShH,EA70B1EiH,CAAcpB,IAAa9C,GAAY8C,IAChDI,EAAWrC,EAEPb,GAAYa,GACdqC,EAw3BR,SAAuB5S,GACrB,OAxvBF,SAAoBoS,EAAQjL,EAAOmH,EAAQgE,GACzC,IAAIuB,GAASvF,EACbA,IAAWA,EAAS,IACpB,IAAIK,GAAS,EACTpN,EAAS4F,EAAM5F,OAEnB,OAASoN,EAAQpN,GAAQ,CACvB,IAAIxB,EAAMoH,EAAMwH,GACZiE,EAAWN,EAAaA,EAAWhE,EAAOvO,GAAMqS,EAAOrS,GAAMA,EAAKuO,EAAQ8D,QAAU3O,OAEvEA,IAAbmP,IACFA,EAAWR,EAAOrS,IAGhB8T,EACFxD,EAAgB/B,EAAQvO,EAAK6S,GAE7BtC,EAAYhC,EAAQvO,EAAK6S,GAI7B,OAAOtE,EAmuBAwF,CAAW9T,EAAO+T,GAAO/T,IAz3BfgU,CAAczD,GACf/B,GAAS+B,KAAa9G,GAAW8G,KAC3CqC,EAuRR,SAAyBtE,GACvB,MAAoC,mBAAtBA,EAAO8E,aAA8BlB,GAAY5D,GAA6C,GAAnCD,EAAWlB,EAAamB,IAxRhF2F,CAAgBzB,KAG7BK,GAAW,EAuFjB,IAAyBU,EACnBN,EAhBoBO,EACpBpN,EAmkBN,IAA2BpG,EAxoBrB6S,IAEFN,EAAMxD,IAAIyD,EAAUI,GACpBH,EAAUG,EAAUJ,EAAUH,EAAUC,EAAYC,GACpDA,EAAc,OAAEC,IAGlBrC,EAAiB7B,EAAQvO,EAAK6S,GAlF1BsB,CAAc5F,EAAQ8D,EAAQrS,EAAKsS,EAAUF,GAAWG,EAAYC,OAC/D,CACL,IAAIK,EAAWN,EAAaA,EAAWI,GAAQpE,EAAQvO,GAAMyS,EAAUzS,EAAM,GAAIuO,EAAQ8D,EAAQG,QAAS9O,OAEzFA,IAAbmP,IACFA,EAAWJ,GAGbrC,EAAiB7B,EAAQvO,EAAK6S,MAE/BmB,IAoFL,SAASI,GAAS1I,EAAMpI,GACtB,OAAO+Q,GA2XT,SAAkB3I,EAAMpI,EAAOwI,GAE7B,OADAxI,EAAQ2K,OAAoBvK,IAAVJ,EAAsBoI,EAAKlK,OAAS,EAAI8B,EAAO,GAC1D,WAML,IALA,IAAI6E,EAAOmM,UACP1F,GAAS,EACTpN,EAASyM,EAAU9F,EAAK3G,OAAS8B,EAAO,GACxCoN,EAAQ1E,MAAMxK,KAEToN,EAAQpN,GACfkP,EAAM9B,GAASzG,EAAK7E,EAAQsL,GAG9BA,GAAS,EAGT,IAFA,IAAI2F,EAAYvI,MAAM1I,EAAQ,KAErBsL,EAAQtL,GACfiR,EAAU3F,GAASzG,EAAKyG,GAI1B,OADA2F,EAAUjR,GAASwI,EAAU4E,GACtBjF,EAAMC,EAAMmD,KAAM0F,IA/YRC,CAAS9I,EAAMpI,EAAOmR,IAAW/I,EAAO,IAmM7D,SAASoF,GAAW9H,EAAKhJ,GACvB,IA4GiBC,EACbyU,EA7GAtT,EAAO4H,EAAIoG,SACf,OA6Ge,WADXsF,SADazU,EA3GAD,KA6GkB,UAAR0U,GAA4B,UAARA,GAA4B,WAARA,EAA8B,cAAVzU,EAAkC,OAAVA,GA7GvFmB,EAAmB,iBAAPpB,EAAkB,SAAW,QAAUoB,EAAK4H,IAYlF,SAAS8E,GAAUS,EAAQvO,GACzB,IAAIC,EA/jCN,SAAkBsO,EAAQvO,GACxB,OAAiB,MAAVuO,OAAiB7K,EAAY6K,EAAOvO,GA8jC/B2U,CAASpG,EAAQvO,GAC7B,OAAO6R,GAAa5R,GAASA,OAAQyD,EAsDvC,SAASwM,GAAQjQ,EAAOuB,GACtB,IAAIkT,SAAczU,EAElB,SADAuB,EAAmB,MAAVA,EA1xCY,iBA0xCwBA,KACjB,UAARkT,GAA4B,UAARA,GAAoBvK,EAASjI,KAAKjC,KAAWA,GAAS,GAAKA,EAAQ,GAAK,GAAKA,EAAQuB,EA6D/H,SAAS2Q,GAAYlS,GACnB,IAAI2T,EAAO3T,GAASA,EAAMoT,YAE1B,OAAOpT,KADoB,mBAAR2T,GAAsBA,EAAK3H,WAAaE,GAiF7D,SAASwG,GAAQpE,EAAQvO,GACvB,IAAY,gBAARA,GAAgD,mBAAhBuO,EAAOvO,KAIhC,aAAPA,EAIJ,OAAOuO,EAAOvO,GAYhB,IAAIqU,GAWJ,SAAkB3I,GAChB,IAAIkJ,EAAQ,EACRC,EAAa,EACjB,OAAO,WACL,IAAIC,EAAQ3G,IACR4G,EAn9CO,IAm9CiBD,EAAQD,GAGpC,GAFAA,EAAaC,EAETC,EAAY,GACd,KAAMH,GAx9CI,IAy9CR,OAAON,UAAU,QAGnBM,EAAQ,EAGV,OAAOlJ,EAAKD,WAAM/H,EAAW4Q,YA3BfU,CAraKnH,EAA4B,SAAUnC,EAAMuJ,GACjE,OAAOpH,EAAenC,EAAM,WAAY,CACtC,cAAgB,EAChB,YAAc,EACd,OAk6BczL,EAl6BIgV,EAm6Bb,WACL,OAAOhV,IAn6BP,UAAY,IAi6BhB,IAAkBA,GAt6BsBwU,IA2fxC,SAASpE,GAAGpQ,EAAOiV,GACjB,OAAOjV,IAAUiV,GAASjV,GAAUA,GAASiV,GAAUA,EAsBzD,IAAIvF,GAAcgC,GAAgB,WAChC,OAAO2C,UADyB,IAE3B3C,GAAkB,SAAU1R,GACjC,OAAO2R,GAAa3R,IAAUqM,EAAeV,KAAK3L,EAAO,YAAcwN,EAAqB7B,KAAK3L,EAAO,WA0BtGwP,GAAUzD,MAAMyD,QA2BpB,SAASuD,GAAY/S,GACnB,OAAgB,MAATA,GAAiBkV,GAASlV,EAAMuB,UAAYkI,GAAWzJ,GAmDhE,IAAI+N,GAAWD,GAiVf,WACE,OAAO,GA/TT,SAASrE,GAAWzJ,GAClB,IAAKwO,GAASxO,GACZ,OAAO,EAKT,IAAIsR,EAAMF,GAAWpR,GACrB,MA3qDY,qBA2qDLsR,GA1qDI,8BA0qDcA,GA/qDZ,0BA+qD6BA,GArqD7B,kBAqqDgDA,EA8B/D,SAAS4D,GAASlV,GAChB,MAAuB,iBAATA,GAAqBA,GAAS,GAAKA,EAAQ,GAAK,GAAKA,GAntD9C,iBAgvDvB,SAASwO,GAASxO,GAChB,IAAIyU,SAAczU,EAClB,OAAgB,MAATA,IAA0B,UAARyU,GAA4B,YAARA,GA4B/C,SAAS9C,GAAa3R,GACpB,OAAgB,MAATA,GAAiC,iBAATA,EAiEjC,IAAIuL,GAAeD,EA7rDnB,SAAmBG,GACjB,OAAO,SAAUzL,GACf,OAAOyL,EAAKzL,IA2rDsBmV,CAAU7J,GAl9BhD,SAA0BtL,GACxB,OAAO2R,GAAa3R,IAAUkV,GAASlV,EAAMuB,WAAa4I,EAAeiH,GAAWpR,KAugCtF,SAAS+T,GAAOzF,GACd,OAAOyE,GAAYzE,GAAUe,EAAcf,GAAQ,GAAQyD,GAAWzD,GAmCxE,IAvxBwB8G,GAuxBpBC,IAvxBoBD,GAuxBO,SAAU9G,EAAQ8D,EAAQC,EAAUC,GACjEH,GAAU7D,EAAQ8D,EAAQC,EAAUC,IAvxB7B6B,IAAS,SAAU7F,EAAQgH,GAChC,IAAI3G,GAAS,EACTpN,EAAS+T,EAAQ/T,OACjB+Q,EAAa/Q,EAAS,EAAI+T,EAAQ/T,EAAS,QAAKkC,EAChD8R,EAAQhU,EAAS,EAAI+T,EAAQ,QAAK7R,EAUtC,IATA6O,EAAa8C,GAAS7T,OAAS,GAA0B,mBAAd+Q,GAA4B/Q,IAAU+Q,QAAc7O,EAE3F8R,GA8IR,SAAwBvV,EAAO2O,EAAOL,GACpC,IAAKE,GAASF,GACZ,OAAO,EAGT,IAAImG,SAAc9F,EAElB,SAAY,UAAR8F,EAAmB1B,GAAYzE,IAAW2B,GAAQtB,EAAOL,EAAO/M,QAAkB,UAARkT,GAAoB9F,KAASL,IAClG8B,GAAG9B,EAAOK,GAAQ3O,GAtJZwV,CAAeF,EAAQ,GAAIA,EAAQ,GAAIC,KAClDjD,EAAa/Q,EAAS,OAAIkC,EAAY6O,EACtC/Q,EAAS,GAGX+M,EAAShE,OAAOgE,KAEPK,EAAQpN,GAAQ,CACvB,IAAI6Q,EAASkD,EAAQ3G,GAEjByD,GACFgD,GAAS9G,EAAQ8D,EAAQzD,EAAO2D,GAIpC,OAAOhE,MA8yBX,SAASkG,GAASxU,GAChB,OAAOA,EAqBT8K,EAAOtG,QAAU6Q,K,qMCr/DJI,E,UAAsB1L,EAC/BxD,kBACAA,Y,UCZG,SAASmP,IACd,IAAMC,EAAepP,UAAa,GAClC,EAA0BA,WAAe,GAAlCoO,EAAP,KAAciB,EAAd,KAMA,OAJAC,GAAiB,WACfF,EAAajM,SAAU,KAGlBnD,eAAkB,WAClBoP,EAAajM,SAChBkM,EAASjB,EAAQ,KAElB,CAACA,I,UCbC,SAASkB,EAAiBxM,EAAgByM,GAC/C,YADiE,IAAlBA,MAAc,IACtDvP,aACL,kBAAM,kBAAM8C,OAEZyM","file":"f68b6560540997019da160705c016bf18f9f73c7-edafdc43fa8898d7380e.js","sourcesContent":["'use strict';\n/**\n * gets current timestamp in epoch seconds\n * @returns {Number} times in epoch seconds\n */\n\nrequire(\"core-js/modules/es.typed-array.set.js\");\n\nrequire(\"core-js/modules/es.typed-array.sort.js\");\n\nfunction getTimestamp() {\n  return new Date().getTime();\n}\n/**\n * gets current GMT offset\n * @returns {Number} offset is mins\n */\n\n\nfunction getGmtOffset() {\n  return new Date().getTimezoneOffset();\n}\n/**\n * Round off numbers(int/string/float) to int\n * Invalid input returns 0\n *\n * @example\n * getNearestInt(100)  // 100\n * getNearestInt(100.49)  // 100\n * getNearestInt(100.50)  // 101\n * getNearestInt('100.50')  // 101\n * getNearestInt('test')  // 0\n *\n *\n * @param {Number|String} num number or number in string\n * @returns {Number} rounded integer\n */\n\n\nfunction getNearestInt(num) {\n  return Math.round(parseFloat(num)) || 0;\n}\n/**\n * Extend base object with key-vals from other object with optional override.\n *\n * @example\n * extend({}, { a: 1 });                      // { a: 1 }\n * extend({ a: 1 }, { b: 1 });                // { a: 1, b: 1 }\n * extend({ a: 1 }, { a: 2, b: 2 });          // { a: 2, b: 2 }\n * extend({ a: 1 }, { a: 2, b: 2 }, false);   // { a: 1, b: 2 }\n *\n * @param {Object} base Base source object, which will be updated\n * @param {Object} obj Source object\n * @param {Boolean} shouldOverride default is true\n * @returns {Object} Returns updated base object\n */\n\n\nfunction extend(base, obj, shouldOverride) {\n  if (typeof shouldOverride === 'undefined') {\n    shouldOverride = true;\n  }\n\n  base = base || {};\n  obj = obj || {};\n\n  for (var key in obj) {\n    if (typeof obj[key] !== 'undefined' && (shouldOverride || !shouldOverride && typeof base[key] === 'undefined')) {\n      base[key] = obj[key];\n    }\n  }\n\n  return base;\n}\n/**\n * uuid generator. Generates a unique ID\n */\n\n\nfunction uuid() {\n  var cryptoObj = window.crypto || window.msCrypto; // for IE 11\n\n  var random32ByteNumber = function random32ByteNumber() {\n    var randomNumber;\n    var max32ByteNumber = 0x7fffffff;\n\n    try {\n      var rnds32 = new Uint32Array(1);\n      cryptoObj.getRandomValues(rnds32);\n      randomNumber = rnds32[0] & max32ByteNumber;\n    } catch (e) {\n      randomNumber = Math.round(max32ByteNumber * Math.random());\n    }\n\n    return randomNumber.toString(16);\n  };\n\n  return random32ByteNumber() + random32ByteNumber();\n}\n/**\n * sets client only cookie key/value pair\n * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies\n *\n * @example\n * setCookie ('key', 'value')\n *\n * @param {String} key cookie key\n * @param {String|Integer} value cookie value\n * @param {Object} options optional cookie options\n */\n\n\nvar storages = {\n  s: 'sessionStorage',\n  l: 'localStorage'\n};\n/***\n * localStorage: data stored has no expiration time\n * sessionStorage: data stored gets cleared when the page session ends(page is closed)\n **/\n\nfunction getStorage(s) {\n  var store;\n\n  try {\n    store = window[storages[s]];\n  } catch (e) {\n    store = null;\n  }\n\n  return store;\n}\n\nfunction _getItem(store, key) {\n  var value;\n\n  if (store) {\n    value = store.getItem(key);\n  }\n\n  return value;\n}\n\nfunction _setItem(storage, key, item) {\n  if (!storage || !item) {\n    return;\n  }\n\n  try {\n    storage.setItem(key, item);\n  } catch (e) {// Do Nothing\n  }\n}\n/**\n * Fetch an item from the local Store, given its key\n *\n * @param key Key of the item to be fetched\n * @returns {*} Item from the local Store\n */\n\n\nfunction getLocalItem(key) {\n  return _getItem(getStorage('l'), key);\n}\n/**\n * Store an item, given its key to local Store\n *\n * @param key Key used to uniquely identify item in the local Store\n * @param item Item to be stored\n */\n\n\nfunction setLocalItem(key, item) {\n  _setItem(getStorage('l'), key, item);\n}\n/**\n * checks if localStorage is available\n * @return {Boolean}\n */\n\n\nfunction hasLocalStorage() {\n  return !!getStorage('l');\n}\n\nvar visitorIdExpiry = 30 * 60 * 1000;\nvar fptiExpiry = 3 * 365 * 24 * 60 * 60 * 1000;\nvar fpti3pKey = 'fpti_3p';\n/**\n * Get/Create 3rd party FPTI Ids. Uses Local Storage for persistence.\n * Addresses some concerns of identity with ITP 2.2\n * @see used by {@link recordImpression}\n */\n\nfunction get3pStorage() {\n  var fpti_3p = null;\n\n  if (!hasLocalStorage()) {\n    return;\n  }\n\n  try {\n    fpti_3p = getLocalItem(fpti3pKey);\n    var vid = null;\n    var vid_exp = null;\n    var fpti = null;\n    var fpti_exp = null;\n    var now = Date.now();\n\n    if (fpti_3p) {\n      // We have data in LS, we need to update the expiry & generate new Ids if expired\n      fpti_3p = JSON.parse(fpti_3p); // check if visitor Id has expired\n\n      if (fpti_3p.vid && fpti_3p.vid_exp > now) {\n        vid = fpti_3p.vid;\n      } else {\n        vid = uuid();\n      } // check if fpti Id has expired\n\n\n      if (fpti_3p.fpti && fpti_3p.fpti_exp > now) {\n        fpti = fpti_3p.fpti;\n      } else {\n        fpti = uuid();\n      } // Updating expiries\n\n\n      vid_exp = now + visitorIdExpiry;\n      fpti_exp = now + fptiExpiry;\n    } else {\n      // We dont have data in LS, we need to generate Ids & place them in LS\n      vid = uuid();\n      vid_exp = now + visitorIdExpiry;\n      fpti = uuid();\n      fpti_exp = now + fptiExpiry;\n    } // Set updated data back to LS\n\n\n    fpti_3p = {\n      vid: vid,\n      vid_exp: vid_exp,\n      fpti: fpti,\n      fpti_exp: fpti_exp\n    };\n    setLocalItem(fpti3pKey, JSON.stringify(fpti_3p));\n  } catch (e) {// Do nothing\n  }\n\n  return fpti_3p;\n}\n/**\n * adds a new data to the query string of a url\n *\n * @example\n * appendDataToURL('https://www.example.com', {x: 'y'});      // https://www.example.com?x=y\n * appendDataToURL('https://www.example.com?a=b', {x: 'y'});  // https://www.example.com?a=b&x=y\n *\n * @param {String} url\n * @param {Object} data JSON Object\n * @returns {String} Updated url\n */\n\n\nfunction appendDataToURL(url, data) {\n  for (var key in data) {\n    if (key && typeof data[key] !== 'undefined' && data[key] !== '') {\n      url = appendQueryStringData(url, key, data[key]);\n    }\n  }\n\n  return url;\n}\n/**\n * adds a new piece of data to the query string of a url\n *\n * @example\n * appendQueryStringData('https://www.example.com', 'x', 'y');      // https://www.example.com?x=y\n * appendQueryStringData('https://www.example.com?a=b', 'x', 'y');  // https://www.example.com?a=b&x=y\n *\n * @param {String} url\n * @param {String} key\n * @param {String|Number} value\n * @returns {String} Updated url\n */\n\n\nfunction appendQueryStringData(url, key, value) {\n  if (key && (value || value === 0 || value === false)) {\n    if (typeof value === 'object') {\n      try {\n        value = JSON.stringify(value);\n      } catch (e) {\n        value = '_err_'; // Log error value to track\n      }\n    }\n\n    if (url.indexOf('?') === -1) {\n      url += '?';\n    }\n\n    if (url.charAt(url.length - 1) !== '?') {\n      url += '&';\n    }\n\n    url += key + '=' + encodeURIComponent(value);\n  }\n\n  return url;\n}\n/**\n * gets browser dimensions\n * @returns {Object} {width: Value, height: Value}\n */\n\n\nfunction getBrowserDimensions() {\n  var elem = window;\n  var a = 'inner';\n\n  if (!('innerWidth' in window)) {\n    a = 'client';\n    elem = document.documentElement || document.body;\n  }\n\n  return {\n    width: elem[a + 'Width'],\n    height: elem[a + 'Height']\n  };\n}\n/**\n * gets device dimensions\n * @returns {Object} {width: Value, height: Value}\n */\n\n\nfunction getDeviceDimensions() {\n  var screen = window.screen || {};\n  var ratio = window.devicePixelRatio || 1;\n  var w = getNearestInt(screen.width * ratio);\n  var h = getNearestInt(screen.height * ratio);\n\n  if (Math.abs(window.orientation) === 90) {\n    // landscape mode w/h are exchanged\n    var temp = w;\n    w = h;\n    h = temp;\n  }\n\n  return {\n    width: w,\n    height: h\n  };\n}\n/**\n * gets screen dimensions\n * @returns {Object} {width: Value, height: Value}\n */\n\n\nfunction getScreenDimensions() {\n  var screen = window.screen || {};\n  return {\n    width: screen.width,\n    height: screen.height\n  };\n}\n/**\n * gets screen color depth\n * @returns {Number}\n */\n\n\nfunction getScreenColorDepth() {\n  return window.screen.colorDepth;\n} // gets boolean for cookies enabled\n\n\nfunction isCookiesEnabled() {\n  var enabled = navigator.cookieEnabled ? 1 : 0;\n  return enabled;\n}\n/**\n * Creates an image pixel\n * @param {String} src\n */\n\n\nfunction fireImagePixel(src) {\n  if (!src || !(typeof window !== 'undefined' && window.Image)) {\n    return;\n  }\n\n  var t = new window.Image(0, 0);\n  t.src = src;\n\n  if (shouldUpdateReferrerPolicy()) {\n    t.referrerPolicy = 'no-referrer-when-downgrade';\n  }\n}\n\nfunction shouldUpdateReferrerPolicy() {\n  var navigator = window.navigator;\n  var ua = navigator.userAgent;\n  var isIE = /MSIE|Trident/i.test(ua);\n  var isIOSSafari = (/iPad/i.test(ua) || /iPhone/i.test(ua)) && /WebKit/i.test(ua) && /CriOS/i.test(ua);\n\n  if (isIE || isIOSSafari) {\n    return false;\n  }\n\n  return true;\n}\n\nvar HOST_PP = 'paypal.com';\nvar VERSION = '1.0.0';\nvar FPTI_BASE_URL = 'https://t.paypal.com/ts';\nvar impressionKeys = {\n  cookiesEnabled: 'ce',\n  pageTitle: 'pt',\n  referrer: 'ru',\n  screenColorDepth: 'cd',\n  screenWidth: 'sw',\n  screenHeight: 'sh',\n  deviceWidth: 'dw',\n  deviceHeight: 'dh',\n  browserWidth: 'bw',\n  browserHeight: 'bh'\n};\n/**\n * Normalize the 2 flavors of options to record API\n * option: { data: {} } and data: {}\n * to option: { data: {} }\n * @param {*} dataObject\n */\n\nfunction normalizeData(dataObject) {\n  var opts;\n\n  if (dataObject && dataObject.data) {\n    opts = dataObject;\n  } else {\n    opts = {\n      data: dataObject || {}\n    };\n  }\n\n  return opts;\n} // generates a beacon url given request options\n\n\nfunction generateBeaconUrl(options, data) {\n  var url = options.url || typeof window !== 'undefined' && window.fptiserverurl || FPTI_BASE_URL;\n  var parts = url.split('?');\n  url = parts[0]; // remove existing query string\n  // if url begins with '//' then we automatically add the current protocol\n\n  if (url.match(/^\\/\\//)) {\n    url = (typeof location !== 'undefined' && location.protocol || '') + url;\n  } // add query string delimiter\n\n\n  url += '?'; // re-append existing query string\n\n  if (parts[1]) {\n    url += parts[1] + '&';\n  }\n\n  url += 'v=' + encodeURIComponent(options.version || VERSION); // version\n\n  var basePayLoad = {\n    t: getTimestamp(),\n    // timestamp\n    g: getGmtOffset() // gmt offset\n\n  }; // if starts time exists provide delta\n\n  if (data.start) {\n    var end = data.end || basePayLoad.t;\n    data.view = data.view || {};\n    data.view.t11 = end - data.start;\n    data.start = data.end = undefined;\n  }\n\n  url = appendDataToURL(url, basePayLoad);\n  url = appendDataToURL(url, data);\n  return url;\n}\n\nfunction createTrackingPayload(options, data) {\n  var beaconURL;\n  var onBeaconCreate = options.onBeaconCreate;\n\n  var _tenantName = window.fpti && window.fpti.tenant_name || HOST_PP; // Use 3p_ variables from local storage only when it is 3rd party\n\n\n  if (typeof location !== 'undefined' && location.hostname.indexOf('.' + _tenantName) === -1) {\n    var fpti3pIds = get3pStorage();\n\n    if (fpti3pIds) {\n      extend(data, {\n        '3p_vid': fpti3pIds.vid,\n        '3p_fpti': fpti3pIds.fpti\n      });\n    }\n  }\n\n  if (!onBeaconCreate || typeof onBeaconCreate === 'function' && onBeaconCreate() !== false) {\n    // beacon.src throw an exception you access it in IE if url is bigger than 4k\n    beaconURL = generateBeaconUrl(options, data);\n  }\n\n  fireImagePixel(beaconURL);\n  return beaconURL;\n}\n/**\n * Record any payload as FPTI event\n *\n * @example\n * record({page: 'test', pgrp: 'test', e: 'im'});\n * record({ data: {page: 'test', pgrp: 'test', e: 'im'}, url: '//t.paypal.com/ts' });\n *\n * @param {Object} inputData\n * @returns {Object} {data: {...}, url: '<beacon_URL>'}\n */\n\n\nfunction record(inputData) {\n  var options = normalizeData(inputData);\n  var beaconUrl = createTrackingPayload(options, options.data);\n  return {\n    data: options.data,\n    url: beaconUrl\n  };\n}\n/**\n * Record a FPTI impression.\n * Adds default browser aware impression key/values automatically like referrer, page title, browser width-height...\n *\n * @example\n * recordImpression({page: 'test', pgrp: 'test'});\n *\n * @param {Object} inputData\n * @param {Function} preRecordCallback\n */\n\n\nfunction recordImpression(inputData, preRecordCallback) {\n  var options = normalizeData(inputData);\n  var data = options.data; // page title\n\n  data[impressionKeys.pageTitle] = document.title; // referrer url\n\n  data[impressionKeys.referrer] = document.referrer; // screen color depth\n\n  data[impressionKeys.screenColorDepth] = getScreenColorDepth(); // screen dimensions\n\n  var screenDimensions = getScreenDimensions();\n  data[impressionKeys.screenWidth] = screenDimensions.width;\n  data[impressionKeys.screenHeight] = screenDimensions.height; // device dimensions\n\n  var deviceDimensions = getDeviceDimensions();\n  data[impressionKeys.deviceWidth] = deviceDimensions.width;\n  data[impressionKeys.deviceHeight] = deviceDimensions.height; // browser dimensions\n\n  var browserDimensions = getBrowserDimensions();\n  data[impressionKeys.browserWidth] = browserDimensions.width;\n  data[impressionKeys.browserHeight] = browserDimensions.height; // cookies enabled\n\n  data[impressionKeys.cookiesEnabled] = isCookiesEnabled();\n  var res = {\n    data: options.data,\n    url: ''\n  };\n\n  if (typeof preRecordCallback === 'function') {\n    preRecordCallback(function () {\n      res.url = createTrackingPayload(options, data);\n      return res;\n    });\n  } else {\n    res.url = createTrackingPayload(options, data);\n  }\n\n  return res;\n}\n/**\n * Record any payload as FPTI event in React-native.\n * Instead of Image pixel using fetch (AJAX) call.\n *\n * @example\n * recordWithFetch({page: 'test', pgrp: 'test', e: 'im'});\n * recordWithFetch({ data: {page: 'test', pgrp: 'test', e: 'im'}, url: 'https://t.paypal.com/ts' });\n *\n * @param {Object} inputData\n * @returns {Object} {data: {...}, url: '<beacon_URL>'}\n */\n\n\nfunction recordWithFetch(inputData) {\n  var result = record(inputData);\n\n  if (typeof fetch !== 'undefined') {\n    fetch(result.url);\n  }\n\n  return result;\n}\n\nexports.createTrackingPayload = createTrackingPayload;\nexports.generateBeaconUrl = generateBeaconUrl;\nexports.normalizeData = normalizeData;\nexports.record = record;\nexports.recordImpression = recordImpression;\nexports.recordWithFetch = recordWithFetch;","import * as React from 'react'\n\nexport const useIsomorphicLayoutEffect =\n  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n","/* eslint-disable */\nimport * as React from 'react'\nimport { useIsomorphicLayoutEffect as useLayoutEffect } from '../../components/integration-builder/hooks/use-isomorphic-layout-effect'\n\n// NOTE: this guy belongs to dx-ui-react, but we can export the component later\n// on the library.\n\nlet serverHandoffComplete = false\nlet id = 0\nconst genId = () => ++id\n\n/**\n * useId\n *\n * Autogenerate IDs to facilitate WAI-ARIA and server rendering.\n *\n * Note: The returned ID will initially be `null` and will update after a\n * component mounts. Users may need to supply their own ID if they need\n * consistent values for SSR.\n *\n */\nfunction useId(idFromProps: string): string\nfunction useId(idFromProps: string | undefined): string | undefined\nfunction useId(idFromProps?: null): string | undefined\nfunction useId(idFromProps?: string | null) {\n  /*\n   * If this instance isn't part of the initial render, we don't have to do the\n   * double render/patch-up dance. We can just generate the ID and return it.\n   */\n  const initialId = idFromProps || (serverHandoffComplete ? genId() : null)\n\n  const [id, setId] = React.useState(initialId)\n\n  useLayoutEffect(() => {\n    if (id === null) {\n      /*\n       * Patch the ID after render. We do this in `useLayoutEffect` to avoid any\n       * rendering flicker, though it'll make the first render slower (unlikely\n       * to matter, but you're welcome to measure your app and let us know if\n       * it's a problem).\n       */\n      setId(genId())\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  React.useEffect(() => {\n    if (serverHandoffComplete === false) {\n      /*\n       * Flag all future uses of `useId` to skip the update dance. This is in\n       * `useEffect` because it goes after `useLayoutEffect`, ensuring we don't\n       * accidentally bail out of the patch-up dance prematurely.\n       */\n      serverHandoffComplete = true\n    }\n  }, [])\n  return id != null ? String(id) : undefined\n}\n\nexport { useId }\n","import React from 'react'\nimport { record, recordImpression } from '@paypalcorp/fpti'\n\nconst withAnalytics = (Component: any) => {\n  return (props: any) => (\n    <Component {...props} fpti={{ record, recordImpression }} />\n  )\n}\n\nexport default withAnalytics\n","/* eslint-disable */\nimport * as React from 'react'\n\nexport interface CreateContextOptions {\n  /**\n   * If `true`, React will throw if context is `null` or `undefined`\n   * In some cases, you might want to support nested context, so you can set it to `false`\n   */\n  strict?: boolean\n  /**\n   * Error message to throw if the context is `undefined`\n   */\n  errorMessage?: string\n  /**\n   * The display name of the context\n   */\n  name?: string\n}\n\ntype CreateContextReturn<T> = [React.Provider<T>, () => T, React.Context<T>]\n\n/**\n * Creates a named context, provider, and hook.\n *\n * @param options create context options\n */\nexport function createContext<ContextType>(options: CreateContextOptions = {}) {\n  const {\n    strict = true,\n    errorMessage = 'useContext: `context` is undefined. Seems you forgot to wrap component within the Provider',\n    name,\n  } = options\n\n  const Context = React.createContext<ContextType | undefined>(undefined)\n\n  Context.displayName = name\n\n  function useContext() {\n    const context = React.useContext(Context)\n\n    if (!context && strict) {\n      const error = new Error(errorMessage)\n      error.name = 'ContextError'\n      Error.captureStackTrace?.(error, useContext)\n      throw error\n    }\n\n    return context\n  }\n\n  return [\n    Context.Provider,\n    useContext,\n    Context,\n  ] as CreateContextReturn<ContextType>\n}\n\nexport function createNamedContext<ContextValueType>(\n  //@ts-ignore\n  name: string,\n  defaultValue: ContextValueType,\n): React.Context<ContextValueType> {\n  const Ctx = React.createContext<ContextValueType>(defaultValue)\n\n  return Ctx\n}\n","import { createContext } from '../context'\nimport * as React from 'react'\nimport { PropGetter, PropGetterAlt } from '../types'\nimport { mergeRefs } from '../ref'\nimport { dataAttr } from '../dom'\nimport { useId } from '../../utils/auto-id'\nimport { useBoolean } from '../../components/integration-builder/hooks/use-boolean'\n\nexport interface FormControlOptions {\n  /**\n   * If `true`, the form control will be required. This has 2 side effects:\n   * - The `FormLabel` will show a required indicator\n   * - The form element (e.g, Input) will have `aria-required` set to `true`\n   */\n  isRequired?: boolean\n  /**\n   * If `true`, the form control will be disabled. This has 2 side effects:\n   * - The `FormLabel` will have `data-disabled` attribute\n   * - The form element (e.g, Input) will be disabled\n   */\n  isDisabled?: boolean\n  /**\n   * If `true`, the form control will be invalid. This has 2 side effects:\n   * - The `FormLabel` and `FormErrorIcon` will have `data-invalid` set to `true`\n   * - The form element (e.g, Input) will have `aria-invalid` set to `true`\n   */\n  isInvalid?: boolean\n  /**\n   * If `true`, the form control will be readonly\n   */\n  isReadOnly?: boolean\n}\n\nexport interface FormControlContext extends FormControlOptions {\n  /**\n   * The label text used to inform users as to what information is\n   * requested for a text field.\n   */\n  label?: string\n  /**\n   * The custom `id` to use for the form control. This is passed directly to the form element (e.g, Input).\n   * - The form element (e.g Input) gets the `id`\n   * - The form label id: `form-label-${id}`\n   * - The form error text id: `form-error-text-${id}`\n   * - The form helper text id: `form-helper-text-${id}`\n   */\n  id?: string\n}\n\ntype FormControlProviderContext = Omit<\n  ReturnType<typeof useFormControlProvider>,\n  'getRootProps' | 'htmlProps'\n>\n\nconst [FormControlProvider, useFormControlContext] =\n  createContext<FormControlProviderContext>({\n    strict: false,\n    name: 'FormControlContext',\n  })\n\nexport { useFormControlContext }\n\nfunction useFormControlProvider(props: FormControlContext) {\n  const {\n    id: idProp,\n    isRequired,\n    isInvalid,\n    isDisabled,\n    isReadOnly,\n    ...htmlProps\n  } = props\n\n  // Generate all the required ids\n  const uuid = useId()\n  const id = idProp || `field-${uuid}`\n\n  const labelId = `${id}-label`\n  const feedbackId = `${id}-feedback`\n  const helpTextId = `${id}-helptext`\n\n  /**\n   * Track whether the `FormErrorMessage` has been rendered.\n   * We use this to append its id the the `aria-describedby` of the `input`.\n   */\n  const [hasFeedbackText, setHasFeedbackText] = React.useState(false)\n\n  /**\n   * Track whether the `FormHelperText` has been rendered.\n   * We use this to append its id the the `aria-describedby` of the `input`.\n   */\n  const [hasHelpText, setHasHelpText] = React.useState(false)\n\n  // Track whether the form element (e.g, `input`) has focus.\n  const [isFocused, setFocus] = useBoolean()\n\n  const getHelpTextProps = React.useCallback<PropGetter>(\n    (props = {}, forwardedRef = null) => ({\n      id: helpTextId,\n      ...props,\n      /**\n       * Notify the field context when the help text is rendered on screen,\n       * so we can apply the correct `aria-describedby` to the field (e.g. input, textarea).\n       */\n      ref: mergeRefs(forwardedRef, (node) => {\n        if (!node) return\n        setHasHelpText(true)\n      }),\n    }),\n    [helpTextId],\n  )\n\n  const getLabelProps = React.useCallback<PropGetterAlt<'label'>>(\n    (props = {}, forwardedRef = null) => ({\n      ...props,\n      ref: forwardedRef,\n      'data-focus': dataAttr(isFocused),\n      'data-disabled': dataAttr(isDisabled),\n      'data-invalid': dataAttr(isInvalid),\n      'data-readonly': dataAttr(isReadOnly),\n      id: props.id ?? labelId,\n      htmlFor: props.htmlFor ?? id,\n    }),\n    [id, isDisabled, isFocused, isInvalid, isReadOnly, labelId],\n  )\n\n  const getErrorMessageProps = React.useCallback<PropGetter>(\n    (props = {}, forwardedRef = null) => ({\n      id: feedbackId,\n      ...props,\n      /**\n       * Notify the field context when the error message is rendered on screen,\n       * so we can apply the correct `aria-describedby` to the field (e.g. input, textarea).\n       */\n      ref: mergeRefs(forwardedRef, (node) => {\n        if (!node) return\n        setHasFeedbackText(true)\n      }),\n      'aria-live': 'polite',\n    }),\n    [feedbackId],\n  )\n\n  const getRootProps = React.useCallback<PropGetterAlt<'div'>>(\n    (props = {}, forwardedRef = null) => ({\n      ...props,\n      ...htmlProps,\n      ref: forwardedRef,\n      role: 'group',\n    }),\n    [htmlProps],\n  )\n\n  const getRequiredIndicatorProps = React.useCallback<PropGetter>(\n    (props = {}, forwardedRef = null) => ({\n      ...props,\n      ref: forwardedRef,\n      role: 'presentation',\n      'aria-hidden': true,\n      children: props.children || '*',\n    }),\n    [],\n  )\n\n  return {\n    isRequired: !!isRequired,\n    isInvalid: !!isInvalid,\n    isReadOnly: !!isReadOnly,\n    isDisabled: !!isDisabled,\n    isFocused: !!isFocused,\n    onFocus: setFocus.on,\n    onBlur: setFocus.off,\n    hasFeedbackText,\n    setHasFeedbackText,\n    hasHelpText,\n    setHasHelpText,\n    id,\n    labelId,\n    feedbackId,\n    helpTextId,\n    htmlProps,\n    getHelpTextProps,\n    getErrorMessageProps,\n    getRootProps,\n    getLabelProps,\n    getRequiredIndicatorProps,\n  }\n}\n","import { isFunction } from 'lodash'\nimport { AnyFunction, FunctionArguments } from '../types'\n\nexport function callAllHandlers<T extends (event: any) => void>(\n  ...fns: (T | undefined)[]\n) {\n  return function func(event: FunctionArguments<T>[0]) {\n    fns.some((fn) => {\n      fn?.(event)\n      return event?.defaultPrevented\n    })\n  }\n}\n\nexport const noop = () => {}\n\nexport function callAll<T extends AnyFunction>(...fns: (T | undefined)[]) {\n  return function mergedFn(arg: FunctionArguments<T>[0]) {\n    fns.forEach((fn) => {\n      fn?.(arg)\n    })\n  }\n}\n\nexport function runIfFn<T, U>(\n  valueOrFn: T | ((...fnArgs: U[]) => T),\n  ...args: U[]\n): T {\n  return isFunction(valueOrFn) ? valueOrFn(...args) : valueOrFn\n}\n","import { useCallback, useState } from 'react'\n\ntype InitialState = boolean | (() => boolean)\n\n/**\n * React hook to manage boolean (on - off) states\n *\n * @param initialState the initial boolean state value\n */\nexport function useBoolean(initialState: InitialState = false) {\n  const [value, setValue] = useState(initialState)\n\n  const on = useCallback(() => {\n    setValue(true)\n  }, [])\n\n  const off = useCallback(() => {\n    setValue(false)\n  }, [])\n\n  const toggle = useCallback(() => {\n    setValue((prev) => !prev)\n  }, [])\n\n  return [value, { on, off, toggle }] as const\n}\n","import * as React from 'react'\nimport { useId } from '../../../../utils/auto-id'\n\n/**\n * Reack hook to generate ids for use in compound components\n *\n * @param idProp the external id passed from the user\n * @param prefixes array of prefixes to use\n *\n * @example\n *\n * ```js\n * const [buttonId, menuId] = useIds(\"52\", \"button\", \"menu\")\n *\n * // buttonId will be `button-52`\n * // menuId will be `menu-52`\n * ```\n */\nexport function useIds(idProp?: string, ...prefixes: string[]) {\n  const id = useId(idProp)\n  return React.useMemo(() => {\n    return prefixes.map((prefix) => `${prefix}-${id}`)\n  }, [id, prefixes])\n}\n","/* eslint-disable */\nimport * as React from 'react'\n\n/**\n * Well basically these utils are based on\n * typescript generics, generics are great\n * for reusable functions and cool utils.\n */\n\ntype FunctionArguments<T extends Function> = T extends (...args: infer R) => any\n  ? R\n  : never\n\nfunction callAllHandlers<T extends (event: any) => void>(\n  ...fns: (T | undefined)[]\n) {\n  return function func(event: FunctionArguments<T>[0]) {\n    fns.some((fn) => {\n      fn?.(event)\n      return event?.defaultPrevented\n    })\n  }\n}\n\nconst isFunction = (value: any): value is Function =>\n  typeof value === 'function'\n\ntype ReactRef<T> = React.Ref<T> | React.RefObject<T> | React.MutableRefObject<T>\n\nfunction assignRef<T = any>(ref: ReactRef<T> | undefined, value: T) {\n  if (ref == null) return\n\n  if (isFunction(ref)) {\n    ref(value)\n    return\n  }\n\n  try {\n    // @ts-ignore\n    ref.current = value\n  } catch (error) {\n    throw new Error(`Cannot assign value '${value}' to ref '${ref}'`)\n  }\n}\n\n/**\n * Combine multiple React refs into a single ref function.\n * This is used mostly when you need to allow consumers forward refs to\n * internal components\n *\n * @param refs refs to assign to value to\n */\nfunction mergeRefs<T>(...refs: (ReactRef<T> | undefined)[]) {\n  return (node: T | null) => {\n    refs.forEach((ref) => assignRef(ref, node))\n  }\n}\n\ntype Merge<T, P> = P & Omit<T, keyof P>\n\ntype PropGetter<T extends HTMLElement = any, P = {}> = (\n  props?: Merge<React.HTMLProps<T>, P>,\n  ref?: React.Ref<any> | React.RefObject<any>,\n) => Merge<React.HTMLProps<T>, P>\n\nfunction canUseDOM(): boolean {\n  return !!(\n    typeof window !== 'undefined' &&\n    window.document &&\n    window.document.createElement\n  )\n}\n\nconst isBrowser = canUseDOM()\n\nexport type { PropGetter, Merge, ReactRef, FunctionArguments }\n\nexport {\n  mergeRefs,\n  assignRef,\n  isFunction,\n  callAllHandlers,\n  canUseDOM,\n  isBrowser,\n}\n","/**\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n/** Used to stand-in for `undefined` hash values. */\n\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n/** Used to detect hot functions by number of calls within a span of milliseconds. */\n\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\n/** Used as references for various `Number` constants. */\n\nvar MAX_SAFE_INTEGER = 9007199254740991;\n/** `Object#toString` result references. */\n\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    asyncTag = '[object AsyncFunction]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    nullTag = '[object Null]',\n    objectTag = '[object Object]',\n    proxyTag = '[object Proxy]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    undefinedTag = '[object Undefined]',\n    weakMapTag = '[object WeakMap]';\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\n\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n/** Used to detect host constructors (Safari). */\n\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n/** Used to detect unsigned integer values. */\n\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n/** Used to identify `toStringTag` values of typed arrays. */\n\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;\n/** Detect free variable `global` from Node.js. */\n\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n/** Detect free variable `self`. */\n\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n/** Used as a reference to the global object. */\n\nvar root = freeGlobal || freeSelf || Function('return this')();\n/** Detect free variable `exports`. */\n\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n/** Detect free variable `module`. */\n\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n/** Detect the popular CommonJS extension `module.exports`. */\n\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n/** Detect free variable `process` from Node.js. */\n\nvar freeProcess = moduleExports && freeGlobal.process;\n/** Used to access faster Node.js helpers. */\n\nvar nodeUtil = function () {\n  try {\n    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    } // Legacy `process.binding('util')` for Node.js < 10.\n\n\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}();\n/* Node.js helper references. */\n\n\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\n\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0:\n      return func.call(thisArg);\n\n    case 1:\n      return func.call(thisArg, args[0]);\n\n    case 2:\n      return func.call(thisArg, args[0], args[1]);\n\n    case 3:\n      return func.call(thisArg, args[0], args[1], args[2]);\n  }\n\n  return func.apply(thisArg, args);\n}\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\n\n\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n\n  return result;\n}\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\n\n\nfunction baseUnary(func) {\n  return function (value) {\n    return func(value);\n  };\n}\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\n\n\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\n\n\nfunction overArg(func, transform) {\n  return function (arg) {\n    return func(transform(arg));\n  };\n}\n/** Used for built-in method references. */\n\n\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n/** Used to detect overreaching core-js shims. */\n\nvar coreJsData = root['__core-js_shared__'];\n/** Used to resolve the decompiled source of functions. */\n\nvar funcToString = funcProto.toString;\n/** Used to check objects for own properties. */\n\nvar hasOwnProperty = objectProto.hasOwnProperty;\n/** Used to detect methods masquerading as native. */\n\nvar maskSrcKey = function () {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? 'Symbol(src)_1.' + uid : '';\n}();\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\n\n\nvar nativeObjectToString = objectProto.toString;\n/** Used to infer the `Object` constructor. */\n\nvar objectCtorString = funcToString.call(Object);\n/** Used to detect if a method is native. */\n\nvar reIsNative = RegExp('^' + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&').replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$');\n/** Built-in value references. */\n\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    Symbol = root.Symbol,\n    Uint8Array = root.Uint8Array,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n    getPrototype = overArg(Object.getPrototypeOf, Object),\n    objectCreate = Object.create,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\nvar defineProperty = function () {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}();\n/* Built-in method references for those with the same name as other `lodash` methods. */\n\n\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeMax = Math.max,\n    nativeNow = Date.now;\n/* Built-in method references that are verified to be native. */\n\nvar Map = getNative(root, 'Map'),\n    nativeCreate = getNative(Object, 'create');\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\n\nvar baseCreate = function () {\n  function object() {}\n\n  return function (proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n\n    object.prototype = proto;\n    var result = new object();\n    object.prototype = undefined;\n    return result;\n  };\n}();\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n\n\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n  this.clear();\n\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\n\n\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n\n\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n\n\nfunction hashGet(key) {\n  var data = this.__data__;\n\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n\n\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\n\n\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;\n  return this;\n} // Add methods to `Hash`.\n\n\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n  this.clear();\n\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\n\n\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n\n\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n\n  var lastIndex = data.length - 1;\n\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n\n  --this.size;\n  return true;\n}\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n\n\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n  return index < 0 ? undefined : data[index][1];\n}\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n\n\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\n\n\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n\n  return this;\n} // Add methods to `ListCache`.\n\n\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n  this.clear();\n\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\n\n\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash(),\n    'map': new (Map || ListCache)(),\n    'string': new Hash()\n  };\n}\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n\n\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n\n\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n\n\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\n\n\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n} // Add methods to `MapCache`.\n\n\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\n\n\nfunction stackClear() {\n  this.__data__ = new ListCache();\n  this.size = 0;\n}\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n\n\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n  this.size = data.size;\n  return result;\n}\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n\n\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n\n\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\n\n\nfunction stackSet(key, value) {\n  var data = this.__data__;\n\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n\n    if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n\n    data = this.__data__ = new MapCache(pairs);\n  }\n\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n} // Add methods to `Stack`.\n\n\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\n\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && ( // Safari 9 has enumerable `arguments.length` in strict mode.\n    key == 'length' || // Node.js 0.10 has enumerable non-index properties on buffers.\n    isBuff && (key == 'offset' || key == 'parent') || // PhantomJS 2 has enumerable non-index properties on typed arrays.\n    isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset') || // Skip index properties.\n    isIndex(key, length)))) {\n      result.push(key);\n    }\n  }\n\n  return result;\n}\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\n\n\nfunction assignMergeValue(object, key, value) {\n  if (value !== undefined && !eq(object[key], value) || value === undefined && !(key in object)) {\n    baseAssignValue(object, key, value);\n  }\n}\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\n\n\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === undefined && !(key in object)) {\n    baseAssignValue(object, key, value);\n  }\n}\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n\n\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n\n  return -1;\n}\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\n\n\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\n\n\nvar baseFor = createBaseFor();\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\n\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n\n  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);\n}\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\n\n\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\n\n\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\n\n\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n\n\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n\n  return result;\n}\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\n\n\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n\n  baseFor(source, function (srcValue, key) {\n    stack || (stack = new Stack());\n\n    if (isObject(srcValue)) {\n      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    } else {\n      var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + '', object, source, stack) : undefined;\n\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n\n      assignMergeValue(object, key, newValue);\n    }\n  }, keysIn);\n}\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\n\n\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = safeGet(object, key),\n      srcValue = safeGet(source, key),\n      stacked = stack.get(srcValue);\n\n  if (stacked) {\n    assignMergeValue(object, key, stacked);\n    return;\n  }\n\n  var newValue = customizer ? customizer(objValue, srcValue, key + '', object, source, stack) : undefined;\n  var isCommon = newValue === undefined;\n\n  if (isCommon) {\n    var isArr = isArray(srcValue),\n        isBuff = !isArr && isBuffer(srcValue),\n        isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n    newValue = srcValue;\n\n    if (isArr || isBuff || isTyped) {\n      if (isArray(objValue)) {\n        newValue = objValue;\n      } else if (isArrayLikeObject(objValue)) {\n        newValue = copyArray(objValue);\n      } else if (isBuff) {\n        isCommon = false;\n        newValue = cloneBuffer(srcValue, true);\n      } else if (isTyped) {\n        isCommon = false;\n        newValue = cloneTypedArray(srcValue, true);\n      } else {\n        newValue = [];\n      }\n    } else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n      newValue = objValue;\n\n      if (isArguments(objValue)) {\n        newValue = toPlainObject(objValue);\n      } else if (!isObject(objValue) || isFunction(objValue)) {\n        newValue = initCloneObject(srcValue);\n      }\n    } else {\n      isCommon = false;\n    }\n  }\n\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n\n  assignMergeValue(object, key, newValue);\n}\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\n\n\nfunction baseRest(func, start) {\n  return setToString(overRest(func, start, identity), func + '');\n}\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\n\n\nvar baseSetToString = !defineProperty ? identity : function (func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\n\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n  buffer.copy(result);\n  return result;\n}\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\n\n\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\n\n\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\n\n\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n  array || (array = Array(length));\n\n  while (++index < length) {\n    array[index] = source[index];\n  }\n\n  return array;\n}\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\n\n\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n    var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n\n  return object;\n}\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\n\n\nfunction createAssigner(assigner) {\n  return baseRest(function (object, sources) {\n    var index = -1,\n        length = sources.length,\n        customizer = length > 1 ? sources[length - 1] : undefined,\n        guard = length > 2 ? sources[2] : undefined;\n    customizer = assigner.length > 3 && typeof customizer == 'function' ? (length--, customizer) : undefined;\n\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n\n    object = Object(object);\n\n    while (++index < length) {\n      var source = sources[index];\n\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n\n    return object;\n  });\n}\n/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\n\n\nfunction createBaseFor(fromRight) {\n  return function (object, iteratee, keysFunc) {\n    var index = -1,\n        iterable = Object(object),\n        props = keysFunc(object),\n        length = props.length;\n\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n\n    return object;\n  };\n}\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\n\n\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;\n}\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\n\n\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\n\n\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n\n  return result;\n}\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\n\n\nfunction initCloneObject(object) {\n  return typeof object.constructor == 'function' && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};\n}\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\n\n\nfunction isIndex(value, length) {\n  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length && (type == 'number' || type != 'symbol' && reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;\n}\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\n\n\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n\n  var type = typeof index;\n\n  if (type == 'number' ? isArrayLike(object) && isIndex(index, object.length) : type == 'string' && index in object) {\n    return eq(object[index], value);\n  }\n\n  return false;\n}\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\n\n\nfunction isKeyable(value) {\n  var type = typeof value;\n  return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null;\n}\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\n\n\nfunction isMasked(func) {\n  return !!maskSrcKey && maskSrcKey in func;\n}\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\n\n\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = typeof Ctor == 'function' && Ctor.prototype || objectProto;\n  return value === proto;\n}\n/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n\n\nfunction nativeKeysIn(object) {\n  var result = [];\n\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n\n  return result;\n}\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\n\n\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\n\n\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? func.length - 1 : start, 0);\n  return function () {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n\n    index = -1;\n    var otherArgs = Array(start + 1);\n\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\n\n\nfunction safeGet(object, key) {\n  if (key === 'constructor' && typeof object[key] === 'function') {\n    return;\n  }\n\n  if (key == '__proto__') {\n    return;\n  }\n\n  return object[key];\n}\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\n\n\nvar setToString = shortOut(baseSetToString);\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\n\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n  return function () {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n    lastCalled = stamp;\n\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n\n    return func.apply(undefined, arguments);\n  };\n}\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\n\n\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n\n    try {\n      return func + '';\n    } catch (e) {}\n  }\n\n  return '';\n}\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\n\n\nfunction eq(value, other) {\n  return value === other || value !== value && other !== other;\n}\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\n\n\nvar isArguments = baseIsArguments(function () {\n  return arguments;\n}()) ? baseIsArguments : function (value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');\n};\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\n\nvar isArray = Array.isArray;\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\n\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\n\n\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\n\n\nvar isBuffer = nativeIsBuffer || stubFalse;\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\n\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  } // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n\n\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\n\n\nfunction isLength(value) {\n  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\n\n\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\n\n\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\n\n\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n\n  var proto = getPrototype(value);\n\n  if (proto === null) {\n    return true;\n  }\n\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;\n}\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\n\n\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\n\nfunction toPlainObject(value) {\n  return copyObject(value, keysIn(value));\n}\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\n\n\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n/**\n * This method is like `_.merge` except that it accepts `customizer` which\n * is invoked to produce the merged values of the destination and source\n * properties. If `customizer` returns `undefined`, merging is handled by the\n * method instead. The `customizer` is invoked with six arguments:\n * (objValue, srcValue, key, object, source, stack).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} customizer The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * function customizer(objValue, srcValue) {\n *   if (_.isArray(objValue)) {\n *     return objValue.concat(srcValue);\n *   }\n * }\n *\n * var object = { 'a': [1], 'b': [2] };\n * var other = { 'a': [3], 'b': [4] };\n *\n * _.mergeWith(object, other, customizer);\n * // => { 'a': [1, 3], 'b': [2, 4] }\n */\n\n\nvar mergeWith = createAssigner(function (object, source, srcIndex, customizer) {\n  baseMerge(object, source, srcIndex, customizer);\n});\n/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\n\nfunction constant(value) {\n  return function () {\n    return value;\n  };\n}\n/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\n\n\nfunction identity(value) {\n  return value;\n}\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\n\n\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = mergeWith;","import * as React from 'react'\nimport { isBrowser } from '../../utils/misc'\n\n/**\n * useSafeLayoutEffect enables us to safely call `useLayoutEffect` on the browser\n * (for SSR reasons)\n *\n * React currently throws a warning when using useLayoutEffect on the server.\n * To get around it, we can conditionally useEffect on the server (no-op) and\n * useLayoutEffect in the browser.\n *\n * @see https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85\n */\nexport const useSafeLayoutEffect = isBrowser\n  ? React.useLayoutEffect\n  : React.useEffect\n","import * as React from 'react'\nimport { useUnmountEffect } from '..'\n\nexport function useForceUpdate() {\n  const unloadingRef = React.useRef(false)\n  const [count, setCount] = React.useState(0)\n\n  useUnmountEffect(() => {\n    unloadingRef.current = true\n  })\n\n  return React.useCallback(() => {\n    if (!unloadingRef.current) {\n      setCount(count + 1)\n    }\n  }, [count])\n}\n","import * as React from 'react'\n\nexport function useUnmountEffect(fn: () => void, deps: any[] = []) {\n  return React.useEffect(\n    () => () => fn(),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    deps,\n  )\n}\n"],"sourceRoot":""}