{"version":3,"file":"js/dot-nano.js","mappings":"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,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,WACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,UAAY,YACxB,IAAIA,GAAQ,UAAY,WACxB,IAAIA,GAAQ,UAAY,YACxB,IAAIA,GAAQ,UAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,WACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,WACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,UAAY,WACxB,IAAIA,GAAQ,UAAY,YACxB,IAAIA,GAAQ,UAAY,YACxB,IAAIA,GAAQ,UAAY,YACxB,IAAIA,GAAQ,UAAY,YACxB,IAAIA,GAAQ,UAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,WACxB,IAAIA,GAAQ,WAAY,WACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,WACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,UAAY,YACxB,IAAIA,GAAQ,UAAY,YACxB,IAAIA,GAAQ,UAAY,YACxB,IAAIA,GAAQ,UAAY,WACxB,IAAIA,GAAQ,UAAY,WACxB,IAAIA,GAAQ,UAAY,YACxB,IAAIA,GAAQ,WAAY,WACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,YACxB,IAAIA,GAAQ,WAAY,W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U,MACV,SAAU,EACV,SAAU,IACV,OAAS,SACT,QAAU,SACV,QAAU,EACV,QAAU,SACV,QAAU,SACV,QAAU,MACV,QAAU,MACV,QAAU,IACV,QAAU,EACV,QAAU,IACV,SAAU,SACV,SAAU,MACV,SAAU,MACV,SAAU,SACV,SAAU,SACV,SAAU,SACV,SAAW,SACX,SAAW,MACX,SAAW,MACX,SAAW,SACX,SAAW,IACX,SAAW,SACX,SAAW,SACX,SAAW,EACX,SAAW,SACX,SAAW,SACX,SAAW,EACX,SAAW,MACX,SAAW,SACX,SAAW,IACX,SAAW,MACX,SAAW,SACX,SAAW,SACX,SAAW,IACX,SAAW,SACX,SAAW,EACX,SAAW,MACX,SAAW,SACX,SAAW,IACX,SAAW,SACX,SAAW,MACX,SAAW,SACX,SAAW,MACX,SAAW,SACX,SAAW,SACX,SAAW,SACX,SAAW,EACX,SAAW,OAEb,CACE,EAAK,WACL,MAAS,WACT,OAAS,QACT,OAAS,WACT,OAAS,EACT,OAAS,QACT,OAAS,WACT,OAAS,QACT,OAAS,WACT,OAAS,QACT,OAAS,GACT,OAAS,WACT,OAAS,WACT,OAAS,KACT,OAAS,KACT,OAAS,WACT,MAAQ,WACR,MAAS,GACT,OAAS,WACT,OAAS,WACT,OAAS,QACT,OAAS,WACT,OAAS,EACT,OAAS,WACT,OAAS,KACT,OAAS,WACT,OAAS,QACT,OAAS,KACT,OAAS,WACT,OAAS,QACT,OAAS,QACT,QAAS,WACT,QAAU,QACV,QAAU,QACV,QAAU,WACV,QAAU,EACV,QAAU,KACV,QAAU,WACV,QAAU,WACV,QAAU,WACV,QAAU,WACV,QAAU,WACV,QAAU,WACV,QAAU,QACV,QAAU,WACV,QAAU,QACV,QAAU,GACV,QAAU,KACV,QAAU,WACV,QAAU,WACV,QAAU,EACV,QAAU,QACV,QAAU,QACV,QAAU,WACV,QAAU,WACV,QAAU,GACV,QAAU,WACV,QAAU,KACV,QAAU,WACV,QAAU,WACV,QAAU,KACV,QAAU,WACV,QAAU,QACV,QAAU,SAEZ,CACE,EAAK,IACL,KAAQ,SACR,KAAQ,OACR,MAAQ,UACR,MAA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AAY,UAAY,WAAY,UACpC,UAAY,UAAY,WAAY,UACpC,WAAY,UAAY,WAAY,WACpC,SAAY,WAAY,WAAY,WACpC,WAAY,WAAY,WAAY,UACpC,WAAY,WAAY,WAAY,WACpC,WAAY,WAAY,UAAY,WACpC,WAAY,WAAY,UAAY,WACpC,WAAY,WAAY,WAAY,UACpC,WAAY,UAAY,UAAY,UACpC,WAAY,WAAY,WAAY,WACpC,WAAY,WAAY,WAAY,SACpC,WAAY,WAAY,WAAY,WACpC,WAAY,WAAY,UAAY,WACpC,UAAY,UAAY,WAAY,WACpC,UAAY,WAAY,SAAY,WACpC,WAAY,WAAY,WAAY,WACpC,WAAY,WAAY,WAAY,WACpC,WAAY,UAAY,WAAY,WACpC,WAAY,WAAY,UAAY,WACpC,WAAY,WAAY,WAAY,WACpC,WAAY,WAAY,UAAY,UACpC,UAAY,WAAY,WAAY,WACpC,WAAY,UAAY,WAAY,UACpC,WAAY,WAAY,WAAY,WACpC,WAAY,UAAY,WAAY,WACpC,WAAY,WAAY,WAAY,UACpC,WAAY,WAAY,WAAY,WACpC,WAAY,WAAY,WAAY,WACpC,WAAY,WAAY,WAAY,WACpC,WAAY,WAAY,WAAY,WACpC,WAAY,WAAY,WAAY,WACpC,UAAY,WAAY,UAAY,UACpC,WAAY,UAAY,UAAY,UACpC,UAAY,WAAY,WAAY,WACpC,WAAY,WAAY,WAAY,WACpC,WAAY,UAAY,WAAY,WACpC,WAAY,WAAY,WAAY,WACpC,WAAY,WAAY,WAAY,UACpC,WAAY,UAAY,WAAY,WACpC,WAAY,WAAY,WAAY,WACpC,UAAY,WAAY,WAAY,YACpC,CAAC,WAAY,WAAY,WAAY,WACrC,WAAY,WAAY,WAAY,WACpC,WAAY,UAAY,WAAY,WACpC,UAAY,WAAY,UAAY,WACpC,WAAY,WAAY,WAAY,WACpC,WAAY,SAAY,WAAY,UACpC,WAAY,WAAY,WAAY,WACpC,UAAY,WAAY,UAAY,WACpC,WAAY,WAAY,WAAY,UACpC,WAAY,WAAY,WAAY,WACpC,WAAY,WAAY,WAAY,WACpC,UAAY,WAAY,WAAY,UACpC,UAAY,WAAY,UAAY,WACpC,UAAY,WAAY,WAAY,WACpC,WAAY,WAAY,WAAY,WACpC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H,IAAG,IACH,IAAG,IACH,IAAG,KACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,KACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,IACH,IAAG,KAEDC,GAAe,IAAI9rC,OAAO5I,OAAOwI,KAAKisC,IAAUryC,KAAK,KAAM,KAYpDuyC,GAAa,CAAChtC,EAAOitC,KAC9B,GAAI,GAASjtC,IAAUH,MAAMgE,QAAQ7D,GACjC,OAAO,KAGX,IAAIktC,GAb6BC,EAaUlyC,OAAO+E,GAAO2b,OAZlDwxB,EAAoBjsC,QAAQ6rC,IAAep1B,GACvCm1B,GAASn1B,IAAUA,KAYzBzW,QAAQ,mBAAoB,IAC5BA,QAAQ,MAAO,KACfA,QAAQ,sBAAuB,IAC/B+lB,cAjB2B,IAACkmB,EAkBjC,MAAMC,EAAkBZ,GAAMS,IAAe,GAE7C,GAAIA,GAAcG,EAAgBp2C,OAAS,EACvC,IAAK,MAAQgJ,MAAOqtC,EAAG,IAAEZ,KAASW,EAC1BX,EAAI1kC,KAAKmlC,KACTA,EAAkBA,EAAgBhsC,QAAQurC,EAAKY,IAM3D,OADAH,EAAkBA,EAAgBhsC,QAAQ,SAAU,IAC7CgsC,CAAe,ECpSpBI,GAAa,CACf,MACA,MACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,MACA,MACA,MACA,MACA,OACA,OACA,KACA,MACA,MACA,KACA,MACA,OACA,MACA,MACA,OACA,MACA,KACA,MACA,MACA,OACA,MACA,MACA,MACA,MACA,KACA,MACA,MACA,MACA,MACA,MACA,MACA,IACA,MACA,OACA,MACA,KACA,KACA,KACA,MACA,MACA,MACA,MACA,KACA,QACA,MACA,KACA,MACA,OACA,OACA,MACA,KACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,OACA,MACA,MACA,KACA,MACA,OACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,KACA,KACA,KACA,MACA,MACA,MACA,OACA,KACA,MACA,IACA,MACA,MACA,MACA,KACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,KACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,KACA,MACA,MACA,MACA,MACA,OACA,MACA,MACA,KACA,MACA,MACA,MACA,KACA,MACA,KACA,MACA,MACA,MACA,MACA,MACA,MACA,KACA,MACA,MACA,MACA,MACA,MACA,KACA,KACA,MACA,OACA,MACA,MACA,KACA,IACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,KACA,MACA,MACA,MACA,KACA,KACA,MACA,OACA,OACA,MACA,MACA,MACA,KACA,KACA,MACA,MACA,IACA,KACA,MACA,MACA,OACA,MACA,KACA,IACA,MACA,OACA,MACA,MACA,MACA,MACA,MACA,IACA,IACA,MACA,MACA,KACA,KACA,KACA,KACA,MACA,MACA,MACA,MACA,OAkDSC,GAAoB,CAACC,EAAaC,GAAS,KACpD,MAAMP,EA9CgB,CAACM,GACnB,GAASA,IAAgB3tC,MAAMgE,QAAQ2pC,GAChC,KAEJvyC,OAAOuyC,GACT7xB,OACAza,QAAQ,eAAgB,MACxBA,QAAQ,MAAO,IAuCI,CAAWssC,GACnC,IAAKN,EACD,MAAO,CAAC,EAGZ,MAAMQ,EAnCY,CAACC,IACnB,MAAMC,EAAS,CACXt3C,GAAI,GACJyuC,GAAI4I,GAER,GAT6B,CAACA,GAAoE,OAA1CA,EAAsB31B,UAAU,EAAG,GASvF61B,CAAkBD,EAAO7I,IACzB,IAAK,MAAM+I,KAAQR,GAAY,CAC3B,MAAMS,EAAW,KAAKD,IACtB,GAAIF,EAAO7I,GAAG7Y,WAAW6hB,GAAW,CAChCH,EAAOt3C,GAAKw3C,EACZF,EAAO7I,GAAK6I,EAAO7I,GAAG7jC,QAAQ,IAAID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","sources":["webpack://@sklik/dot/./node_modules/crypto-js/sha256.js","webpack://@sklik/dot/./node_modules/crypto-js/core.js","webpack://@sklik/dot/./node_modules/lodash.isequal/index.js","webpack://@sklik/dot/./node_modules/lodash.clonedeep/index.js","webpack://@sklik/dot/./node_modules/abortcontroller-polyfill/dist/abortcontroller-polyfill-only.js","webpack://@sklik/dot/webpack/bootstrap","webpack://@sklik/dot/webpack/runtime/compat get default export","webpack://@sklik/dot/webpack/runtime/define property getters","webpack://@sklik/dot/webpack/runtime/hasOwnProperty shorthand","webpack://@sklik/dot/webpack/runtime/node module decorator","webpack://@sklik/dot/./src/modules/polyfills/customEvent.polyfill.js","webpack://@sklik/dot/./src/types/config.ts","webpack://@sklik/dot/./src/constants/index.ts","webpack://@sklik/dot/./src/types/types.ts","webpack://@sklik/dot/./src/modules/utils/general/url.ts","webpack://@sklik/dot/./src/modules/utils/cookie/cookie.ts","webpack://@sklik/dot/./src/modules/identityObject/identityObject.ts","webpack://@sklik/dot/./src/modules/config/validation.ts","webpack://@sklik/dot/./src/modules/config/config.ts","webpack://@sklik/dot/./src/modules/utils/storage/storage.ts","webpack://@sklik/dot/./node_modules/@iva/utils/dist/url.js","webpack://@sklik/dot/./src/modules/geometry/geometry.ts","webpack://@sklik/dot/./src/modules/spenttime/spenttime.ts","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/types.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/consts.js","webpack://@sklik/dot/./node_modules/@iva/debugger/dist/esm/log.js","webpack://@sklik/dot/./node_modules/@iva/debugger/dist/esm/constants.js","webpack://@sklik/dot/./node_modules/@iva/debugger/dist/esm/window.js","webpack://@sklik/dot/./node_modules/@iva/debugger/dist/esm/url.js","webpack://@sklik/dot/./node_modules/@iva/debugger/dist/esm/getShouldLog.js","webpack://@sklik/dot/./node_modules/@iva/debugger/dist/esm/index.js","webpack://@sklik/dot/./node_modules/@iva/debugger/dist/esm/permanent.js","webpack://@sklik/dot/./node_modules/@iva/debugger/dist/esm/status.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/debug.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/cache.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/encoding.js","webpack://@sklik/dot/./node_modules/@sklik/cmp2-common/dist/iabtcf/Base64Url.js","webpack://@sklik/dot/./node_modules/@sklik/cmp2-common/dist/cmpone.js","webpack://@sklik/dot/./node_modules/@sklik/cmp2-common/dist/cookie.js","webpack://@sklik/dot/./node_modules/@sklik/cmp2-common/dist/consent.js","webpack://@sklik/dot/./node_modules/@sklik/cmp2-common/dist/sidStoreLegalCheck.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/namespace.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/utils.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/config.js","webpack://@sklik/dot/./node_modules/@iva/utils/dist/types/address.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/core.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/x64-core.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/enc-base64.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/md5.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/evpkdf.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/cipher-core.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/enc-utf16.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/enc-base64url.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/sha1.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/sha256.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/sha224.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/sha512.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/sha384.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/sha3.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/ripemd160.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/pbkdf2.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/aes.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/tripledes.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/rabbit.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/rabbit-legacy.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/rc4.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/blowfish.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/mode-cfb.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/mode-ctr.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/mode-ctr-gladman.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/mode-ecb.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/mode-ofb.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/pad-ansix923.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/pad-iso10126.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/pad-zeropadding.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/pad-iso97971.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/pad-nopadding.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/format-hex.js","webpack://@sklik/dot/./node_modules/crypto-es/lib/index.js","webpack://@sklik/dot/./node_modules/@iva/utils/dist/modules/utils.js","webpack://@sklik/dot/./node_modules/@iva/utils/dist/address.js","webpack://@sklik/dot/./node_modules/@iva/utils/dist/telephone.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/hash.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/invalidUpdates.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/identities.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/externals/eid.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/externals/login.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/externals/consent.js","webpack://@sklik/dot/./node_modules/@iva/utils/dist/cookie.js","webpack://@sklik/dot/./node_modules/@iva/utils/dist/modules/validation.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/externals/udid.js","webpack://@sklik/dot/./node_modules/@iva/utils/dist/sid.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/externals/sid.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/frames.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/externals/id5.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/externals/index.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/events.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/subscribing.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/general.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/getrules.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/storage.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/specials.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/whitelisting.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/cleanup.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/index.js","webpack://@sklik/dot/./node_modules/@iva/identity-storage/dist/esm/modules/versioning.js","webpack://@sklik/dot/./src/modules/hit/composeData.ts","webpack://@sklik/dot/./src/modules/lazyHitting/lazyHitting.ts","webpack://@sklik/dot/./src/modules/postponedHitting/postponedHitting.ts","webpack://@sklik/dot/./src/modules/utils/html/traversing.ts","webpack://@sklik/dot/./src/modules/utils/html/iframe.ts","webpack://@sklik/dot/./src/modules/impress/impress.ts","webpack://@sklik/dot/./src/modules/hit/sharedData.ts","webpack://@sklik/dot/./src/modules/hit/hit.ts","webpack://@sklik/dot/./src/modules/utils/general/browser.ts","webpack://@sklik/dot/./src/modules/utils/cookie/cookieWallCookie.ts","webpack://@sklik/dot/./src/modules/init.ts","webpack://@sklik/dot/./src/modules/hit/delayedHit.ts","webpack://@sklik/dot/./src/modules/logger/methodPlaceholder.ts","webpack://@sklik/dot/./src/modules/logger/log.ts","webpack://@sklik/dot/./src/modules/utils/general/string.ts","webpack://@sklik/dot/./src/classes/dot.class.ts","webpack://@sklik/dot/./src/modules/redirect/redirect.ts","webpack://@sklik/dot/./src/modules/sid/sid.ts","webpack://@sklik/dot/./node_modules/@iva/sbrowser-sid/dist/esm/index.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/config.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/modules/utils/debug.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/modules/utils/detectShouldRun.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/modules/utils/decodeClid.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/modules/utils/xorCrypt.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/modules/utils/cutParamFromUrl.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/modules/utils/sendHit.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/modules/utils/cookieUtils.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/modules/sid.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/modules/sznaiid.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/modules/consent.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/index.js","webpack://@sklik/dot/./node_modules/@iva/linkdecoration/src/modules/szntime.js","webpack://@sklik/dot/./src/modules/sid/sync.ts","webpack://@sklik/dot/./src/modules/linkdecoration/linkdecoration.ts","webpack://@sklik/dot/./node_modules/@iva/marker/dist/config.js","webpack://@sklik/dot/./node_modules/@iva/marker/dist/modules/debug.js","webpack://@sklik/dot/./node_modules/@iva/marker/dist/modules/cookie.js","webpack://@sklik/dot/./node_modules/@iva/marker/dist/modules/requests.js","webpack://@sklik/dot/./node_modules/@iva/marker/dist/marker.js","webpack://@sklik/dot/./src/modules/marker/marker.ts","webpack://@sklik/dot/./node_modules/@iva/refresher/src/index.js","webpack://@sklik/dot/./node_modules/@iva/error-reporter/dist/esm/modules/browser.js","webpack://@sklik/dot/./node_modules/@iva/error-reporter/dist/esm/constants.js","webpack://@sklik/dot/./node_modules/@iva/error-reporter/dist/esm/modules/HitSender.js","webpack://@sklik/dot/./node_modules/@iva/error-reporter/dist/esm/modules/storage.js","webpack://@sklik/dot/./node_modules/@iva/error-reporter/dist/esm/main.js","webpack://@sklik/dot/./src/dot-nano.ts","webpack://@sklik/dot/./node_modules/@iva/utils/dist/constants.js"],"sourcesContent":[";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory(require(\"./core\"));\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([\"./core\"], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\tfactory(root.CryptoJS);\n\t}\n}(this, function (CryptoJS) {\n\n\t(function (Math) {\n\t    // Shortcuts\n\t    var C = CryptoJS;\n\t    var C_lib = C.lib;\n\t    var WordArray = C_lib.WordArray;\n\t    var Hasher = C_lib.Hasher;\n\t    var C_algo = C.algo;\n\n\t    // Initialization and round constants tables\n\t    var H = [];\n\t    var K = [];\n\n\t    // Compute constants\n\t    (function () {\n\t        function isPrime(n) {\n\t            var sqrtN = Math.sqrt(n);\n\t            for (var factor = 2; factor <= sqrtN; factor++) {\n\t                if (!(n % factor)) {\n\t                    return false;\n\t                }\n\t            }\n\n\t            return true;\n\t        }\n\n\t        function getFractionalBits(n) {\n\t            return ((n - (n | 0)) * 0x100000000) | 0;\n\t        }\n\n\t        var n = 2;\n\t        var nPrime = 0;\n\t        while (nPrime < 64) {\n\t            if (isPrime(n)) {\n\t                if (nPrime < 8) {\n\t                    H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));\n\t                }\n\t                K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));\n\n\t                nPrime++;\n\t            }\n\n\t            n++;\n\t        }\n\t    }());\n\n\t    // Reusable object\n\t    var W = [];\n\n\t    /**\n\t     * SHA-256 hash algorithm.\n\t     */\n\t    var SHA256 = C_algo.SHA256 = Hasher.extend({\n\t        _doReset: function () {\n\t            this._hash = new WordArray.init(H.slice(0));\n\t        },\n\n\t        _doProcessBlock: function (M, offset) {\n\t            // Shortcut\n\t            var H = this._hash.words;\n\n\t            // Working variables\n\t            var a = H[0];\n\t            var b = H[1];\n\t            var c = H[2];\n\t            var d = H[3];\n\t            var e = H[4];\n\t            var f = H[5];\n\t            var g = H[6];\n\t            var h = H[7];\n\n\t            // Computation\n\t            for (var i = 0; i < 64; i++) {\n\t                if (i < 16) {\n\t                    W[i] = M[offset + i] | 0;\n\t                } else {\n\t                    var gamma0x = W[i - 15];\n\t                    var gamma0  = ((gamma0x << 25) | (gamma0x >>> 7))  ^\n\t                                  ((gamma0x << 14) | (gamma0x >>> 18)) ^\n\t                                   (gamma0x >>> 3);\n\n\t                    var gamma1x = W[i - 2];\n\t                    var gamma1  = ((gamma1x << 15) | (gamma1x >>> 17)) ^\n\t                                  ((gamma1x << 13) | (gamma1x >>> 19)) ^\n\t                                   (gamma1x >>> 10);\n\n\t                    W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];\n\t                }\n\n\t                var ch  = (e & f) ^ (~e & g);\n\t                var maj = (a & b) ^ (a & c) ^ (b & c);\n\n\t                var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));\n\t                var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7)  | (e >>> 25));\n\n\t                var t1 = h + sigma1 + ch + K[i] + W[i];\n\t                var t2 = sigma0 + maj;\n\n\t                h = g;\n\t                g = f;\n\t                f = e;\n\t                e = (d + t1) | 0;\n\t                d = c;\n\t                c = b;\n\t                b = a;\n\t                a = (t1 + t2) | 0;\n\t            }\n\n\t            // Intermediate hash value\n\t            H[0] = (H[0] + a) | 0;\n\t            H[1] = (H[1] + b) | 0;\n\t            H[2] = (H[2] + c) | 0;\n\t            H[3] = (H[3] + d) | 0;\n\t            H[4] = (H[4] + e) | 0;\n\t            H[5] = (H[5] + f) | 0;\n\t            H[6] = (H[6] + g) | 0;\n\t            H[7] = (H[7] + h) | 0;\n\t        },\n\n\t        _doFinalize: function () {\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\n\t            var nBitsTotal = this._nDataBytes * 8;\n\t            var nBitsLeft = data.sigBytes * 8;\n\n\t            // Add padding\n\t            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);\n\t            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;\n\t            data.sigBytes = dataWords.length * 4;\n\n\t            // Hash final blocks\n\t            this._process();\n\n\t            // Return final computed hash\n\t            return this._hash;\n\t        },\n\n\t        clone: function () {\n\t            var clone = Hasher.clone.call(this);\n\t            clone._hash = this._hash.clone();\n\n\t            return clone;\n\t        }\n\t    });\n\n\t    /**\n\t     * Shortcut function to the hasher's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     *\n\t     * @return {WordArray} The hash.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hash = CryptoJS.SHA256('message');\n\t     *     var hash = CryptoJS.SHA256(wordArray);\n\t     */\n\t    C.SHA256 = Hasher._createHelper(SHA256);\n\n\t    /**\n\t     * Shortcut function to the HMAC's object interface.\n\t     *\n\t     * @param {WordArray|string} message The message to hash.\n\t     * @param {WordArray|string} key The secret key.\n\t     *\n\t     * @return {WordArray} The HMAC.\n\t     *\n\t     * @static\n\t     *\n\t     * @example\n\t     *\n\t     *     var hmac = CryptoJS.HmacSHA256(message, key);\n\t     */\n\t    C.HmacSHA256 = Hasher._createHmacHelper(SHA256);\n\t}(Math));\n\n\n\treturn CryptoJS.SHA256;\n\n}));",";(function (root, factory) {\n\tif (typeof exports === \"object\") {\n\t\t// CommonJS\n\t\tmodule.exports = exports = factory();\n\t}\n\telse if (typeof define === \"function\" && define.amd) {\n\t\t// AMD\n\t\tdefine([], factory);\n\t}\n\telse {\n\t\t// Global (browser)\n\t\troot.CryptoJS = factory();\n\t}\n}(this, function () {\n\n\t/*globals window, global, require*/\n\n\t/**\n\t * CryptoJS core components.\n\t */\n\tvar CryptoJS = CryptoJS || (function (Math, undefined) {\n\n\t    var crypto;\n\n\t    // Native crypto from window (Browser)\n\t    if (typeof window !== 'undefined' && window.crypto) {\n\t        crypto = window.crypto;\n\t    }\n\n\t    // Native crypto in web worker (Browser)\n\t    if (typeof self !== 'undefined' && self.crypto) {\n\t        crypto = self.crypto;\n\t    }\n\n\t    // Native crypto from worker\n\t    if (typeof globalThis !== 'undefined' && globalThis.crypto) {\n\t        crypto = globalThis.crypto;\n\t    }\n\n\t    // Native (experimental IE 11) crypto from window (Browser)\n\t    if (!crypto && typeof window !== 'undefined' && window.msCrypto) {\n\t        crypto = window.msCrypto;\n\t    }\n\n\t    // Native crypto from global (NodeJS)\n\t    if (!crypto && typeof global !== 'undefined' && global.crypto) {\n\t        crypto = global.crypto;\n\t    }\n\n\t    // Native crypto import via require (NodeJS)\n\t    if (!crypto && typeof require === 'function') {\n\t        try {\n\t            crypto = require('crypto');\n\t        } catch (err) {}\n\t    }\n\n\t    /*\n\t     * Cryptographically secure pseudorandom number generator\n\t     *\n\t     * As Math.random() is cryptographically not safe to use\n\t     */\n\t    var cryptoSecureRandomInt = function () {\n\t        if (crypto) {\n\t            // Use getRandomValues method (Browser)\n\t            if (typeof crypto.getRandomValues === 'function') {\n\t                try {\n\t                    return crypto.getRandomValues(new Uint32Array(1))[0];\n\t                } catch (err) {}\n\t            }\n\n\t            // Use randomBytes method (NodeJS)\n\t            if (typeof crypto.randomBytes === 'function') {\n\t                try {\n\t                    return crypto.randomBytes(4).readInt32LE();\n\t                } catch (err) {}\n\t            }\n\t        }\n\n\t        throw new Error('Native crypto module could not be used to get secure random number.');\n\t    };\n\n\t    /*\n\t     * Local polyfill of Object.create\n\n\t     */\n\t    var create = Object.create || (function () {\n\t        function F() {}\n\n\t        return function (obj) {\n\t            var subtype;\n\n\t            F.prototype = obj;\n\n\t            subtype = new F();\n\n\t            F.prototype = null;\n\n\t            return subtype;\n\t        };\n\t    }());\n\n\t    /**\n\t     * CryptoJS namespace.\n\t     */\n\t    var C = {};\n\n\t    /**\n\t     * Library namespace.\n\t     */\n\t    var C_lib = C.lib = {};\n\n\t    /**\n\t     * Base object for prototypal inheritance.\n\t     */\n\t    var Base = C_lib.Base = (function () {\n\n\n\t        return {\n\t            /**\n\t             * Creates a new object that inherits from this object.\n\t             *\n\t             * @param {Object} overrides Properties to copy into the new object.\n\t             *\n\t             * @return {Object} The new object.\n\t             *\n\t             * @static\n\t             *\n\t             * @example\n\t             *\n\t             *     var MyType = CryptoJS.lib.Base.extend({\n\t             *         field: 'value',\n\t             *\n\t             *         method: function () {\n\t             *         }\n\t             *     });\n\t             */\n\t            extend: function (overrides) {\n\t                // Spawn\n\t                var subtype = create(this);\n\n\t                // Augment\n\t                if (overrides) {\n\t                    subtype.mixIn(overrides);\n\t                }\n\n\t                // Create default initializer\n\t                if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {\n\t                    subtype.init = function () {\n\t                        subtype.$super.init.apply(this, arguments);\n\t                    };\n\t                }\n\n\t                // Initializer's prototype is the subtype object\n\t                subtype.init.prototype = subtype;\n\n\t                // Reference supertype\n\t                subtype.$super = this;\n\n\t                return subtype;\n\t            },\n\n\t            /**\n\t             * Extends this object and runs the init method.\n\t             * Arguments to create() will be passed to init().\n\t             *\n\t             * @return {Object} The new object.\n\t             *\n\t             * @static\n\t             *\n\t             * @example\n\t             *\n\t             *     var instance = MyType.create();\n\t             */\n\t            create: function () {\n\t                var instance = this.extend();\n\t                instance.init.apply(instance, arguments);\n\n\t                return instance;\n\t            },\n\n\t            /**\n\t             * Initializes a newly created object.\n\t             * Override this method to add some logic when your objects are created.\n\t             *\n\t             * @example\n\t             *\n\t             *     var MyType = CryptoJS.lib.Base.extend({\n\t             *         init: function () {\n\t             *             // ...\n\t             *         }\n\t             *     });\n\t             */\n\t            init: function () {\n\t            },\n\n\t            /**\n\t             * Copies properties into this object.\n\t             *\n\t             * @param {Object} properties The properties to mix in.\n\t             *\n\t             * @example\n\t             *\n\t             *     MyType.mixIn({\n\t             *         field: 'value'\n\t             *     });\n\t             */\n\t            mixIn: function (properties) {\n\t                for (var propertyName in properties) {\n\t                    if (properties.hasOwnProperty(propertyName)) {\n\t                        this[propertyName] = properties[propertyName];\n\t                    }\n\t                }\n\n\t                // IE won't copy toString using the loop above\n\t                if (properties.hasOwnProperty('toString')) {\n\t                    this.toString = properties.toString;\n\t                }\n\t            },\n\n\t            /**\n\t             * Creates a copy of this object.\n\t             *\n\t             * @return {Object} The clone.\n\t             *\n\t             * @example\n\t             *\n\t             *     var clone = instance.clone();\n\t             */\n\t            clone: function () {\n\t                return this.init.prototype.extend(this);\n\t            }\n\t        };\n\t    }());\n\n\t    /**\n\t     * An array of 32-bit words.\n\t     *\n\t     * @property {Array} words The array of 32-bit words.\n\t     * @property {number} sigBytes The number of significant bytes in this word array.\n\t     */\n\t    var WordArray = C_lib.WordArray = Base.extend({\n\t        /**\n\t         * Initializes a newly created word array.\n\t         *\n\t         * @param {Array} words (Optional) An array of 32-bit words.\n\t         * @param {number} sigBytes (Optional) The number of significant bytes in the words.\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.lib.WordArray.create();\n\t         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);\n\t         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);\n\t         */\n\t        init: function (words, sigBytes) {\n\t            words = this.words = words || [];\n\n\t            if (sigBytes != undefined) {\n\t                this.sigBytes = sigBytes;\n\t            } else {\n\t                this.sigBytes = words.length * 4;\n\t            }\n\t        },\n\n\t        /**\n\t         * Converts this word array to a string.\n\t         *\n\t         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex\n\t         *\n\t         * @return {string} The stringified word array.\n\t         *\n\t         * @example\n\t         *\n\t         *     var string = wordArray + '';\n\t         *     var string = wordArray.toString();\n\t         *     var string = wordArray.toString(CryptoJS.enc.Utf8);\n\t         */\n\t        toString: function (encoder) {\n\t            return (encoder || Hex).stringify(this);\n\t        },\n\n\t        /**\n\t         * Concatenates a word array to this word array.\n\t         *\n\t         * @param {WordArray} wordArray The word array to append.\n\t         *\n\t         * @return {WordArray} This word array.\n\t         *\n\t         * @example\n\t         *\n\t         *     wordArray1.concat(wordArray2);\n\t         */\n\t        concat: function (wordArray) {\n\t            // Shortcuts\n\t            var thisWords = this.words;\n\t            var thatWords = wordArray.words;\n\t            var thisSigBytes = this.sigBytes;\n\t            var thatSigBytes = wordArray.sigBytes;\n\n\t            // Clamp excess bits\n\t            this.clamp();\n\n\t            // Concat\n\t            if (thisSigBytes % 4) {\n\t                // Copy one byte at a time\n\t                for (var i = 0; i < thatSigBytes; i++) {\n\t                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);\n\t                }\n\t            } else {\n\t                // Copy one word at a time\n\t                for (var j = 0; j < thatSigBytes; j += 4) {\n\t                    thisWords[(thisSigBytes + j) >>> 2] = thatWords[j >>> 2];\n\t                }\n\t            }\n\t            this.sigBytes += thatSigBytes;\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Removes insignificant bits.\n\t         *\n\t         * @example\n\t         *\n\t         *     wordArray.clamp();\n\t         */\n\t        clamp: function () {\n\t            // Shortcuts\n\t            var words = this.words;\n\t            var sigBytes = this.sigBytes;\n\n\t            // Clamp\n\t            words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);\n\t            words.length = Math.ceil(sigBytes / 4);\n\t        },\n\n\t        /**\n\t         * Creates a copy of this word array.\n\t         *\n\t         * @return {WordArray} The clone.\n\t         *\n\t         * @example\n\t         *\n\t         *     var clone = wordArray.clone();\n\t         */\n\t        clone: function () {\n\t            var clone = Base.clone.call(this);\n\t            clone.words = this.words.slice(0);\n\n\t            return clone;\n\t        },\n\n\t        /**\n\t         * Creates a word array filled with random bytes.\n\t         *\n\t         * @param {number} nBytes The number of random bytes to generate.\n\t         *\n\t         * @return {WordArray} The random word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.lib.WordArray.random(16);\n\t         */\n\t        random: function (nBytes) {\n\t            var words = [];\n\n\t            for (var i = 0; i < nBytes; i += 4) {\n\t                words.push(cryptoSecureRandomInt());\n\t            }\n\n\t            return new WordArray.init(words, nBytes);\n\t        }\n\t    });\n\n\t    /**\n\t     * Encoder namespace.\n\t     */\n\t    var C_enc = C.enc = {};\n\n\t    /**\n\t     * Hex encoding strategy.\n\t     */\n\t    var Hex = C_enc.Hex = {\n\t        /**\n\t         * Converts a word array to a hex string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The hex string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\n\t            // Convert\n\t            var hexChars = [];\n\t            for (var i = 0; i < sigBytes; i++) {\n\t                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                hexChars.push((bite >>> 4).toString(16));\n\t                hexChars.push((bite & 0x0f).toString(16));\n\t            }\n\n\t            return hexChars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a hex string to a word array.\n\t         *\n\t         * @param {string} hexStr The hex string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);\n\t         */\n\t        parse: function (hexStr) {\n\t            // Shortcut\n\t            var hexStrLength = hexStr.length;\n\n\t            // Convert\n\t            var words = [];\n\t            for (var i = 0; i < hexStrLength; i += 2) {\n\t                words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);\n\t            }\n\n\t            return new WordArray.init(words, hexStrLength / 2);\n\t        }\n\t    };\n\n\t    /**\n\t     * Latin1 encoding strategy.\n\t     */\n\t    var Latin1 = C_enc.Latin1 = {\n\t        /**\n\t         * Converts a word array to a Latin1 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The Latin1 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            // Shortcuts\n\t            var words = wordArray.words;\n\t            var sigBytes = wordArray.sigBytes;\n\n\t            // Convert\n\t            var latin1Chars = [];\n\t            for (var i = 0; i < sigBytes; i++) {\n\t                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n\t                latin1Chars.push(String.fromCharCode(bite));\n\t            }\n\n\t            return latin1Chars.join('');\n\t        },\n\n\t        /**\n\t         * Converts a Latin1 string to a word array.\n\t         *\n\t         * @param {string} latin1Str The Latin1 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);\n\t         */\n\t        parse: function (latin1Str) {\n\t            // Shortcut\n\t            var latin1StrLength = latin1Str.length;\n\n\t            // Convert\n\t            var words = [];\n\t            for (var i = 0; i < latin1StrLength; i++) {\n\t                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);\n\t            }\n\n\t            return new WordArray.init(words, latin1StrLength);\n\t        }\n\t    };\n\n\t    /**\n\t     * UTF-8 encoding strategy.\n\t     */\n\t    var Utf8 = C_enc.Utf8 = {\n\t        /**\n\t         * Converts a word array to a UTF-8 string.\n\t         *\n\t         * @param {WordArray} wordArray The word array.\n\t         *\n\t         * @return {string} The UTF-8 string.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);\n\t         */\n\t        stringify: function (wordArray) {\n\t            try {\n\t                return decodeURIComponent(escape(Latin1.stringify(wordArray)));\n\t            } catch (e) {\n\t                throw new Error('Malformed UTF-8 data');\n\t            }\n\t        },\n\n\t        /**\n\t         * Converts a UTF-8 string to a word array.\n\t         *\n\t         * @param {string} utf8Str The UTF-8 string.\n\t         *\n\t         * @return {WordArray} The word array.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);\n\t         */\n\t        parse: function (utf8Str) {\n\t            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));\n\t        }\n\t    };\n\n\t    /**\n\t     * Abstract buffered block algorithm template.\n\t     *\n\t     * The property blockSize must be implemented in a concrete subtype.\n\t     *\n\t     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0\n\t     */\n\t    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({\n\t        /**\n\t         * Resets this block algorithm's data buffer to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     bufferedBlockAlgorithm.reset();\n\t         */\n\t        reset: function () {\n\t            // Initial values\n\t            this._data = new WordArray.init();\n\t            this._nDataBytes = 0;\n\t        },\n\n\t        /**\n\t         * Adds new data to this block algorithm's buffer.\n\t         *\n\t         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.\n\t         *\n\t         * @example\n\t         *\n\t         *     bufferedBlockAlgorithm._append('data');\n\t         *     bufferedBlockAlgorithm._append(wordArray);\n\t         */\n\t        _append: function (data) {\n\t            // Convert string to WordArray, else assume WordArray already\n\t            if (typeof data == 'string') {\n\t                data = Utf8.parse(data);\n\t            }\n\n\t            // Append\n\t            this._data.concat(data);\n\t            this._nDataBytes += data.sigBytes;\n\t        },\n\n\t        /**\n\t         * Processes available data blocks.\n\t         *\n\t         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.\n\t         *\n\t         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.\n\t         *\n\t         * @return {WordArray} The processed data.\n\t         *\n\t         * @example\n\t         *\n\t         *     var processedData = bufferedBlockAlgorithm._process();\n\t         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');\n\t         */\n\t        _process: function (doFlush) {\n\t            var processedWords;\n\n\t            // Shortcuts\n\t            var data = this._data;\n\t            var dataWords = data.words;\n\t            var dataSigBytes = data.sigBytes;\n\t            var blockSize = this.blockSize;\n\t            var blockSizeBytes = blockSize * 4;\n\n\t            // Count blocks ready\n\t            var nBlocksReady = dataSigBytes / blockSizeBytes;\n\t            if (doFlush) {\n\t                // Round up to include partial blocks\n\t                nBlocksReady = Math.ceil(nBlocksReady);\n\t            } else {\n\t                // Round down to include only full blocks,\n\t                // less the number of blocks that must remain in the buffer\n\t                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);\n\t            }\n\n\t            // Count words ready\n\t            var nWordsReady = nBlocksReady * blockSize;\n\n\t            // Count bytes ready\n\t            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);\n\n\t            // Process blocks\n\t            if (nWordsReady) {\n\t                for (var offset = 0; offset < nWordsReady; offset += blockSize) {\n\t                    // Perform concrete-algorithm logic\n\t                    this._doProcessBlock(dataWords, offset);\n\t                }\n\n\t                // Remove processed words\n\t                processedWords = dataWords.splice(0, nWordsReady);\n\t                data.sigBytes -= nBytesReady;\n\t            }\n\n\t            // Return processed words\n\t            return new WordArray.init(processedWords, nBytesReady);\n\t        },\n\n\t        /**\n\t         * Creates a copy of this object.\n\t         *\n\t         * @return {Object} The clone.\n\t         *\n\t         * @example\n\t         *\n\t         *     var clone = bufferedBlockAlgorithm.clone();\n\t         */\n\t        clone: function () {\n\t            var clone = Base.clone.call(this);\n\t            clone._data = this._data.clone();\n\n\t            return clone;\n\t        },\n\n\t        _minBufferSize: 0\n\t    });\n\n\t    /**\n\t     * Abstract hasher template.\n\t     *\n\t     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)\n\t     */\n\t    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({\n\t        /**\n\t         * Configuration options.\n\t         */\n\t        cfg: Base.extend(),\n\n\t        /**\n\t         * Initializes a newly created hasher.\n\t         *\n\t         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hasher = CryptoJS.algo.SHA256.create();\n\t         */\n\t        init: function (cfg) {\n\t            // Apply config defaults\n\t            this.cfg = this.cfg.extend(cfg);\n\n\t            // Set initial values\n\t            this.reset();\n\t        },\n\n\t        /**\n\t         * Resets this hasher to its initial state.\n\t         *\n\t         * @example\n\t         *\n\t         *     hasher.reset();\n\t         */\n\t        reset: function () {\n\t            // Reset data buffer\n\t            BufferedBlockAlgorithm.reset.call(this);\n\n\t            // Perform concrete-hasher logic\n\t            this._doReset();\n\t        },\n\n\t        /**\n\t         * Updates this hasher with a message.\n\t         *\n\t         * @param {WordArray|string} messageUpdate The message to append.\n\t         *\n\t         * @return {Hasher} This hasher.\n\t         *\n\t         * @example\n\t         *\n\t         *     hasher.update('message');\n\t         *     hasher.update(wordArray);\n\t         */\n\t        update: function (messageUpdate) {\n\t            // Append\n\t            this._append(messageUpdate);\n\n\t            // Update the hash\n\t            this._process();\n\n\t            // Chainable\n\t            return this;\n\t        },\n\n\t        /**\n\t         * Finalizes the hash computation.\n\t         * Note that the finalize operation is effectively a destructive, read-once operation.\n\t         *\n\t         * @param {WordArray|string} messageUpdate (Optional) A final message update.\n\t         *\n\t         * @return {WordArray} The hash.\n\t         *\n\t         * @example\n\t         *\n\t         *     var hash = hasher.finalize();\n\t         *     var hash = hasher.finalize('message');\n\t         *     var hash = hasher.finalize(wordArray);\n\t         */\n\t        finalize: function (messageUpdate) {\n\t            // Final message update\n\t            if (messageUpdate) {\n\t                this._append(messageUpdate);\n\t            }\n\n\t            // Perform concrete-hasher logic\n\t            var hash = this._doFinalize();\n\n\t            return hash;\n\t        },\n\n\t        blockSize: 512/32,\n\n\t        /**\n\t         * Creates a shortcut function to a hasher's object interface.\n\t         *\n\t         * @param {Hasher} hasher The hasher to create a helper for.\n\t         *\n\t         * @return {Function} The shortcut function.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);\n\t         */\n\t        _createHelper: function (hasher) {\n\t            return function (message, cfg) {\n\t                return new hasher.init(cfg).finalize(message);\n\t            };\n\t        },\n\n\t        /**\n\t         * Creates a shortcut function to the HMAC's object interface.\n\t         *\n\t         * @param {Hasher} hasher The hasher to use in this HMAC helper.\n\t         *\n\t         * @return {Function} The shortcut function.\n\t         *\n\t         * @static\n\t         *\n\t         * @example\n\t         *\n\t         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);\n\t         */\n\t        _createHmacHelper: function (hasher) {\n\t            return function (message, key) {\n\t                return new C_algo.HMAC.init(hasher, key).finalize(message);\n\t            };\n\t        }\n\t    });\n\n\t    /**\n\t     * Algorithm namespace.\n\t     */\n\t    var C_algo = C.algo = {};\n\n\t    return C;\n\t}(Math));\n\n\n\treturn CryptoJS;\n\n}));","/**\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright JS Foundation and other contributors <https://js.foundation/>\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\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\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    promiseTag = '[object Promise]',\n    proxyTag = '[object Proxy]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    undefinedTag = '[object Undefined]',\n    weakMapTag = '[object WeakMap]';\n\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/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\n/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction arraySome(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (predicate(array[index], index, array)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\n/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\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 */\nfunction cacheHas(cache, key) {\n  return cache.has(key);\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 */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\n/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    Symbol = root.Symbol,\n    Uint8Array = root.Uint8Array,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n    nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeKeys = overArg(Object.keys, Object);\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView'),\n    Map = getNative(root, 'Map'),\n    Promise = getNative(root, 'Promise'),\n    Set = getNative(root, 'Set'),\n    WeakMap = getNative(root, 'WeakMap'),\n    nativeCreate = getNative(Object, 'create');\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\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 */\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/**\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 */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\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 */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\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 */\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}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\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 */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\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 */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\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 */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\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 */\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  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\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 */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\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/**\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 */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\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 */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\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 */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\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 */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n  var index = -1,\n      length = values == null ? 0 : values.length;\n\n  this.__data__ = new MapCache;\n  while (++index < length) {\n    this.add(values[index]);\n  }\n}\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n  this.__data__.set(value, HASH_UNDEFINED);\n  return this;\n}\n\n/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n  return this.__data__.has(value);\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\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 */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\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 */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\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 */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\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 */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\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 */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\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)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * 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 */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Unordered comparison\n *  2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n  if (value === other) {\n    return true;\n  }\n  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n    return value !== value && other !== other;\n  }\n  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n  var objIsArr = isArray(object),\n      othIsArr = isArray(other),\n      objTag = objIsArr ? arrayTag : getTag(object),\n      othTag = othIsArr ? arrayTag : getTag(other);\n\n  objTag = objTag == argsTag ? objectTag : objTag;\n  othTag = othTag == argsTag ? objectTag : othTag;\n\n  var objIsObj = objTag == objectTag,\n      othIsObj = othTag == objectTag,\n      isSameTag = objTag == othTag;\n\n  if (isSameTag && isBuffer(object)) {\n    if (!isBuffer(other)) {\n      return false;\n    }\n    objIsArr = true;\n    objIsObj = false;\n  }\n  if (isSameTag && !objIsObj) {\n    stack || (stack = new Stack);\n    return (objIsArr || isTypedArray(object))\n      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n  }\n  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n    if (objIsWrapped || othIsWrapped) {\n      var objUnwrapped = objIsWrapped ? object.value() : object,\n          othUnwrapped = othIsWrapped ? other.value() : other;\n\n      stack || (stack = new Stack);\n      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n    }\n  }\n  if (!isSameTag) {\n    return false;\n  }\n  stack || (stack = new Stack);\n  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      arrLength = array.length,\n      othLength = other.length;\n\n  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n    return false;\n  }\n  // Assume cyclic values are equal.\n  var stacked = stack.get(array);\n  if (stacked && stack.get(other)) {\n    return stacked == other;\n  }\n  var index = -1,\n      result = true,\n      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n  stack.set(array, other);\n  stack.set(other, array);\n\n  // Ignore non-index properties.\n  while (++index < arrLength) {\n    var arrValue = array[index],\n        othValue = other[index];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, arrValue, index, other, array, stack)\n        : customizer(arrValue, othValue, index, array, other, stack);\n    }\n    if (compared !== undefined) {\n      if (compared) {\n        continue;\n      }\n      result = false;\n      break;\n    }\n    // Recursively compare arrays (susceptible to call stack limits).\n    if (seen) {\n      if (!arraySome(other, function(othValue, othIndex) {\n            if (!cacheHas(seen, othIndex) &&\n                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n              return seen.push(othIndex);\n            }\n          })) {\n        result = false;\n        break;\n      }\n    } else if (!(\n          arrValue === othValue ||\n            equalFunc(arrValue, othValue, bitmask, customizer, stack)\n        )) {\n      result = false;\n      break;\n    }\n  }\n  stack['delete'](array);\n  stack['delete'](other);\n  return result;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n  switch (tag) {\n    case dataViewTag:\n      if ((object.byteLength != other.byteLength) ||\n          (object.byteOffset != other.byteOffset)) {\n        return false;\n      }\n      object = object.buffer;\n      other = other.buffer;\n\n    case arrayBufferTag:\n      if ((object.byteLength != other.byteLength) ||\n          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n        return false;\n      }\n      return true;\n\n    case boolTag:\n    case dateTag:\n    case numberTag:\n      // Coerce booleans to `1` or `0` and dates to milliseconds.\n      // Invalid dates are coerced to `NaN`.\n      return eq(+object, +other);\n\n    case errorTag:\n      return object.name == other.name && object.message == other.message;\n\n    case regexpTag:\n    case stringTag:\n      // Coerce regexes to strings and treat strings, primitives and objects,\n      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n      // for more details.\n      return object == (other + '');\n\n    case mapTag:\n      var convert = mapToArray;\n\n    case setTag:\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n      convert || (convert = setToArray);\n\n      if (object.size != other.size && !isPartial) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked) {\n        return stacked == other;\n      }\n      bitmask |= COMPARE_UNORDERED_FLAG;\n\n      // Recursively compare objects (susceptible to call stack limits).\n      stack.set(object, other);\n      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n      stack['delete'](object);\n      return result;\n\n    case symbolTag:\n      if (symbolValueOf) {\n        return symbolValueOf.call(object) == symbolValueOf.call(other);\n      }\n  }\n  return false;\n}\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      objProps = getAllKeys(object),\n      objLength = objProps.length,\n      othProps = getAllKeys(other),\n      othLength = othProps.length;\n\n  if (objLength != othLength && !isPartial) {\n    return false;\n  }\n  var index = objLength;\n  while (index--) {\n    var key = objProps[index];\n    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n      return false;\n    }\n  }\n  // Assume cyclic values are equal.\n  var stacked = stack.get(object);\n  if (stacked && stack.get(other)) {\n    return stacked == other;\n  }\n  var result = true;\n  stack.set(object, other);\n  stack.set(other, object);\n\n  var skipCtor = isPartial;\n  while (++index < objLength) {\n    key = objProps[index];\n    var objValue = object[key],\n        othValue = other[key];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, objValue, key, other, object, stack)\n        : customizer(objValue, othValue, key, object, other, stack);\n    }\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(compared === undefined\n          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n          : compared\n        )) {\n      result = false;\n      break;\n    }\n    skipCtor || (skipCtor = key == 'constructor');\n  }\n  if (result && !skipCtor) {\n    var objCtor = object.constructor,\n        othCtor = other.constructor;\n\n    // Non `Object` object instances with different constructors are not equal.\n    if (objCtor != othCtor &&\n        ('constructor' in object && 'constructor' in other) &&\n        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n          typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n      result = false;\n    }\n  }\n  stack['delete'](object);\n  stack['delete'](other);\n  return result;\n}\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\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 */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\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  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n  if (object == null) {\n    return [];\n  }\n  object = Object(object);\n  return arrayFilter(nativeGetSymbols(object), function(symbol) {\n    return propertyIsEnumerable.call(object, symbol);\n  });\n};\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map && getTag(new Map) != mapTag) ||\n    (Promise && getTag(Promise.resolve()) != promiseTag) ||\n    (Set && getTag(new Set) != setTag) ||\n    (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = baseGetTag(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : '';\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\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 */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * 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 */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\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 */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * 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 */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.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 * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = isEqual;\n","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.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\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\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    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    weakMapTag = '[object WeakMap]';\n\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/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to match `RegExp` flags from their coerced string values. */\nvar reFlags = /\\w*$/;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values supported by `_.clone`. */\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/**\n * Adds the key-value `pair` to `map`.\n *\n * @private\n * @param {Object} map The map to modify.\n * @param {Array} pair The key-value pair to add.\n * @returns {Object} Returns `map`.\n */\nfunction addMapEntry(map, pair) {\n  // Don't return `map.set` because it's not chainable in IE 11.\n  map.set(pair[0], pair[1]);\n  return map;\n}\n\n/**\n * Adds `value` to `set`.\n *\n * @private\n * @param {Object} set The set to modify.\n * @param {*} value The value to add.\n * @returns {Object} Returns `set`.\n */\nfunction addSetEntry(set, value) {\n  // Don't return `set.add` because it's not chainable in IE 11.\n  set.add(value);\n  return set;\n}\n\n/**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n  var index = -1,\n      length = array ? array.length : 0;\n\n  while (++index < length) {\n    if (iteratee(array[index], index, array) === false) {\n      break;\n    }\n  }\n  return array;\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\n/**\n * A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @param {boolean} [initAccum] Specify using the first element of `array` as\n *  the initial value.\n * @returns {*} Returns the accumulated value.\n */\nfunction arrayReduce(array, iteratee, accumulator, initAccum) {\n  var index = -1,\n      length = array ? array.length : 0;\n\n  if (initAccum && length) {\n    accumulator = array[++index];\n  }\n  while (++index < length) {\n    accumulator = iteratee(accumulator, array[index], index, array);\n  }\n  return accumulator;\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * 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 */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\n/**\n * Checks if `value` is a host object in IE < 9.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a host object, else `false`.\n */\nfunction isHostObject(value) {\n  // Many host objects are `Object` objects that can coerce to strings\n  // despite having improperly defined `toString` methods.\n  var result = false;\n  if (value != null && typeof value.toString != 'function') {\n    try {\n      result = !!(value + '');\n    } catch (e) {}\n  }\n  return result;\n}\n\n/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\n/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to detect methods masquerading as native. */\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 decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\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 */\nvar objectToString = objectProto.toString;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    Symbol = root.Symbol,\n    Uint8Array = root.Uint8Array,\n    getPrototype = overArg(Object.getPrototypeOf, Object),\n    objectCreate = Object.create,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n    nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeKeys = overArg(Object.keys, Object);\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView'),\n    Map = getNative(root, 'Map'),\n    Promise = getNative(root, 'Promise'),\n    Set = getNative(root, 'Set'),\n    WeakMap = getNative(root, 'WeakMap'),\n    nativeCreate = getNative(Object, 'create');\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n}\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 */\nfunction hashDelete(key) {\n  return this.has(key) && delete this.__data__[key];\n}\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 */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\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 */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\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 */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n}\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 */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  return true;\n}\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 */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\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 */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\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 */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\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 */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries ? entries.length : 0;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\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 */\nfunction mapCacheDelete(key) {\n  return getMapData(this, key)['delete'](key);\n}\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 */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\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 */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\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 */\nfunction mapCacheSet(key, value) {\n  getMapData(this, key).set(key, value);\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\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 */\nfunction Stack(entries) {\n  this.__data__ = new ListCache(entries);\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n}\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 */\nfunction stackDelete(key) {\n  return this.__data__['delete'](key);\n}\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 */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\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 */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\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 */\nfunction stackSet(key, value) {\n  var cache = this.__data__;\n  if (cache instanceof ListCache) {\n    var pairs = cache.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      return this;\n    }\n    cache = this.__data__ = new MapCache(pairs);\n  }\n  cache.set(key, value);\n  return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  // Safari 9 makes `arguments.length` enumerable in strict mode.\n  var result = (isArray(value) || isArguments(value))\n    ? baseTimes(value.length, String)\n    : [];\n\n  var length = result.length,\n      skipIndexes = !!length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    object[key] = value;\n  }\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 */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssign(object, source) {\n  return object && copyObject(source, keys(source), object);\n}\n\n/**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @param {boolean} [isFull] Specify a clone including symbols.\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\nfunction baseClone(value, isDeep, isFull, customizer, key, object, stack) {\n  var result;\n  if (customizer) {\n    result = object ? customizer(value, key, object, stack) : customizer(value);\n  }\n  if (result !== undefined) {\n    return result;\n  }\n  if (!isObject(value)) {\n    return value;\n  }\n  var isArr = isArray(value);\n  if (isArr) {\n    result = initCloneArray(value);\n    if (!isDeep) {\n      return copyArray(value, result);\n    }\n  } else {\n    var tag = getTag(value),\n        isFunc = tag == funcTag || tag == genTag;\n\n    if (isBuffer(value)) {\n      return cloneBuffer(value, isDeep);\n    }\n    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n      if (isHostObject(value)) {\n        return object ? value : {};\n      }\n      result = initCloneObject(isFunc ? {} : value);\n      if (!isDeep) {\n        return copySymbols(value, baseAssign(result, value));\n      }\n    } else {\n      if (!cloneableTags[tag]) {\n        return object ? value : {};\n      }\n      result = initCloneByTag(value, tag, baseClone, isDeep);\n    }\n  }\n  // Check for circular references and return its corresponding clone.\n  stack || (stack = new Stack);\n  var stacked = stack.get(value);\n  if (stacked) {\n    return stacked;\n  }\n  stack.set(value, result);\n\n  if (!isArr) {\n    var props = isFull ? getAllKeys(value) : keys(value);\n  }\n  arrayEach(props || value, function(subValue, key) {\n    if (props) {\n      key = subValue;\n      subValue = value[key];\n    }\n    // Recursively populate clone (susceptible to call stack limits).\n    assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));\n  });\n  return result;\n}\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} prototype The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nfunction baseCreate(proto) {\n  return isObject(proto) ? objectCreate(proto) : {};\n}\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/**\n * The base implementation of `getTag`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  return objectToString.call(value);\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * 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 */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var result = new buffer.constructor(buffer.length);\n  buffer.copy(result);\n  return result;\n}\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 */\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/**\n * Creates a clone of `dataView`.\n *\n * @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n */\nfunction cloneDataView(dataView, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\n/**\n * Creates a clone of `map`.\n *\n * @private\n * @param {Object} map The map to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned map.\n */\nfunction cloneMap(map, isDeep, cloneFunc) {\n  var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map);\n  return arrayReduce(array, addMapEntry, new map.constructor);\n}\n\n/**\n * Creates a clone of `regexp`.\n *\n * @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n */\nfunction cloneRegExp(regexp) {\n  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n  result.lastIndex = regexp.lastIndex;\n  return result;\n}\n\n/**\n * Creates a clone of `set`.\n *\n * @private\n * @param {Object} set The set to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned set.\n */\nfunction cloneSet(set, isDeep, cloneFunc) {\n  var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set);\n  return arrayReduce(array, addSetEntry, new set.constructor);\n}\n\n/**\n * Creates a clone of the `symbol` object.\n *\n * @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n */\nfunction cloneSymbol(symbol) {\n  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\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 */\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/**\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 */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    assignValue(object, key, newValue === undefined ? source[key] : newValue);\n  }\n  return object;\n}\n\n/**\n * Copies own symbol properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbols(source, object) {\n  return copyObject(source, getSymbols(source), object);\n}\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\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 */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * Creates an array of the own enumerable symbol properties of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11,\n// for data views in Edge < 14, and promises in Node.js.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map && getTag(new Map) != mapTag) ||\n    (Promise && getTag(Promise.resolve()) != promiseTag) ||\n    (Set && getTag(new Set) != setTag) ||\n    (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = objectToString.call(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : undefined;\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\n/**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\nfunction initCloneArray(array) {\n  var length = array.length,\n      result = array.constructor(length);\n\n  // Add properties assigned by `RegExp#exec`.\n  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n    result.index = array.index;\n    result.input = array.input;\n  }\n  return result;\n}\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 */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\n/**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {Function} cloneFunc The function to clone values.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneByTag(object, tag, cloneFunc, isDeep) {\n  var Ctor = object.constructor;\n  switch (tag) {\n    case arrayBufferTag:\n      return cloneArrayBuffer(object);\n\n    case boolTag:\n    case dateTag:\n      return new Ctor(+object);\n\n    case dataViewTag:\n      return cloneDataView(object, isDeep);\n\n    case float32Tag: case float64Tag:\n    case int8Tag: case int16Tag: case int32Tag:\n    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n      return cloneTypedArray(object, isDeep);\n\n    case mapTag:\n      return cloneMap(object, isDeep, cloneFunc);\n\n    case numberTag:\n    case stringTag:\n      return new Ctor(object);\n\n    case regexpTag:\n      return cloneRegExp(object);\n\n    case setTag:\n      return cloneSet(object, isDeep, cloneFunc);\n\n    case symbolTag:\n      return cloneSymbol(object);\n  }\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length &&\n    (typeof value == 'number' || reIsUint.test(value)) &&\n    (value > -1 && value % 1 == 0 && value < length);\n}\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 */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to process.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * This method is like `_.clone` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @returns {*} Returns the deep cloned value.\n * @see _.clone\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n */\nfunction cloneDeep(value) {\n  return baseClone(value, true, true);\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nfunction isArguments(value) {\n  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.\n  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&\n    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);\n}\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\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 */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8-9 which returns 'object' for typed array and other constructors.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = cloneDeep;\n","(function (factory) {\n  typeof define === 'function' && define.amd ? define(factory) :\n  factory();\n})((function () { 'use strict';\n\n  function _arrayLikeToArray(r, a) {\n    (null == a || a > r.length) && (a = r.length);\n    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];\n    return n;\n  }\n  function _assertThisInitialized(e) {\n    if (void 0 === e) throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n    return e;\n  }\n  function _callSuper(t, o, e) {\n    return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));\n  }\n  function _classCallCheck(a, n) {\n    if (!(a instanceof n)) throw new TypeError(\"Cannot call a class as a function\");\n  }\n  function _defineProperties(e, r) {\n    for (var t = 0; t < r.length; t++) {\n      var o = r[t];\n      o.enumerable = o.enumerable || !1, o.configurable = !0, \"value\" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);\n    }\n  }\n  function _createClass(e, r, t) {\n    return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, \"prototype\", {\n      writable: !1\n    }), e;\n  }\n  function _createForOfIteratorHelper(r, e) {\n    var t = \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"];\n    if (!t) {\n      if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && \"number\" == typeof r.length) {\n        t && (r = t);\n        var n = 0,\n          F = function () {};\n        return {\n          s: F,\n          n: function () {\n            return n >= r.length ? {\n              done: !0\n            } : {\n              done: !1,\n              value: r[n++]\n            };\n          },\n          e: function (r) {\n            throw r;\n          },\n          f: F\n        };\n      }\n      throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n    }\n    var o,\n      a = !0,\n      u = !1;\n    return {\n      s: function () {\n        t = t.call(r);\n      },\n      n: function () {\n        var r = t.next();\n        return a = r.done, r;\n      },\n      e: function (r) {\n        u = !0, o = r;\n      },\n      f: function () {\n        try {\n          a || null == t.return || t.return();\n        } finally {\n          if (u) throw o;\n        }\n      }\n    };\n  }\n  function _get() {\n    return _get = \"undefined\" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) {\n      var p = _superPropBase(e, t);\n      if (p) {\n        var n = Object.getOwnPropertyDescriptor(p, t);\n        return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;\n      }\n    }, _get.apply(null, arguments);\n  }\n  function _getPrototypeOf(t) {\n    return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {\n      return t.__proto__ || Object.getPrototypeOf(t);\n    }, _getPrototypeOf(t);\n  }\n  function _inherits(t, e) {\n    if (\"function\" != typeof e && null !== e) throw new TypeError(\"Super expression must either be null or a function\");\n    t.prototype = Object.create(e && e.prototype, {\n      constructor: {\n        value: t,\n        writable: !0,\n        configurable: !0\n      }\n    }), Object.defineProperty(t, \"prototype\", {\n      writable: !1\n    }), e && _setPrototypeOf(t, e);\n  }\n  function _isNativeReflectConstruct() {\n    try {\n      var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    } catch (t) {}\n    return (_isNativeReflectConstruct = function () {\n      return !!t;\n    })();\n  }\n  function _possibleConstructorReturn(t, e) {\n    if (e && (\"object\" == typeof e || \"function\" == typeof e)) return e;\n    if (void 0 !== e) throw new TypeError(\"Derived constructors may only return object or undefined\");\n    return _assertThisInitialized(t);\n  }\n  function _setPrototypeOf(t, e) {\n    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {\n      return t.__proto__ = e, t;\n    }, _setPrototypeOf(t, e);\n  }\n  function _superPropBase(t, o) {\n    for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf(t)););\n    return t;\n  }\n  function _superPropGet(t, o, e, r) {\n    var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e);\n    return 2 & r && \"function\" == typeof p ? function (t) {\n      return p.apply(e, t);\n    } : p;\n  }\n  function _toPrimitive(t, r) {\n    if (\"object\" != typeof t || !t) return t;\n    var e = t[Symbol.toPrimitive];\n    if (void 0 !== e) {\n      var i = e.call(t, r || \"default\");\n      if (\"object\" != typeof i) return i;\n      throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n    }\n    return (\"string\" === r ? String : Number)(t);\n  }\n  function _toPropertyKey(t) {\n    var i = _toPrimitive(t, \"string\");\n    return \"symbol\" == typeof i ? i : i + \"\";\n  }\n  function _unsupportedIterableToArray(r, a) {\n    if (r) {\n      if (\"string\" == typeof r) return _arrayLikeToArray(r, a);\n      var t = {}.toString.call(r).slice(8, -1);\n      return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;\n    }\n  }\n\n  (function (self) {\n      return {\n        NativeAbortSignal: self.AbortSignal,\n        NativeAbortController: self.AbortController\n      };\n    })(typeof self !== 'undefined' ? self : global);\n\n  /**\n   * @param {any} reason abort reason\n   */\n  function createAbortEvent(reason) {\n    var event;\n    try {\n      event = new Event('abort');\n    } catch (e) {\n      if (typeof document !== 'undefined') {\n        if (!document.createEvent) {\n          // For Internet Explorer 8:\n          event = document.createEventObject();\n          event.type = 'abort';\n        } else {\n          // For Internet Explorer 11:\n          event = document.createEvent('Event');\n          event.initEvent('abort', false, false);\n        }\n      } else {\n        // Fallback where document isn't available:\n        event = {\n          type: 'abort',\n          bubbles: false,\n          cancelable: false\n        };\n      }\n    }\n    event.reason = reason;\n    return event;\n  }\n\n  /**\n   * @param {any} reason abort reason\n   */\n  function normalizeAbortReason(reason) {\n    if (reason === undefined) {\n      if (typeof document === 'undefined') {\n        reason = new Error('This operation was aborted');\n        reason.name = 'AbortError';\n      } else {\n        try {\n          reason = new DOMException('signal is aborted without reason');\n          // The DOMException does not support setting the name property directly.\n          Object.defineProperty(reason, 'name', {\n            value: 'AbortError'\n          });\n        } catch (err) {\n          // IE 11 does not support calling the DOMException constructor, use a\n          // regular error object on it instead.\n          reason = new Error('This operation was aborted');\n          reason.name = 'AbortError';\n        }\n      }\n    }\n    return reason;\n  }\n\n  var Emitter = /*#__PURE__*/function () {\n    function Emitter() {\n      _classCallCheck(this, Emitter);\n      Object.defineProperty(this, 'listeners', {\n        value: {},\n        writable: true,\n        configurable: true\n      });\n    }\n    return _createClass(Emitter, [{\n      key: \"addEventListener\",\n      value: function addEventListener(type, callback, options) {\n        if (!(type in this.listeners)) {\n          this.listeners[type] = [];\n        }\n        this.listeners[type].push({\n          callback: callback,\n          options: options\n        });\n      }\n    }, {\n      key: \"removeEventListener\",\n      value: function removeEventListener(type, callback) {\n        if (!(type in this.listeners)) {\n          return;\n        }\n        var stack = this.listeners[type];\n        for (var i = 0, l = stack.length; i < l; i++) {\n          if (stack[i].callback === callback) {\n            stack.splice(i, 1);\n            return;\n          }\n        }\n      }\n    }, {\n      key: \"dispatchEvent\",\n      value: function dispatchEvent(event) {\n        var _this = this;\n        if (!(event.type in this.listeners)) {\n          return;\n        }\n        var stack = this.listeners[event.type];\n        var stackToCall = stack.slice();\n        var _loop = function _loop() {\n          var listener = stackToCall[i];\n          try {\n            listener.callback.call(_this, event);\n          } catch (e) {\n            Promise.resolve().then(function () {\n              throw e;\n            });\n          }\n          if (listener.options && listener.options.once) {\n            _this.removeEventListener(event.type, listener.callback);\n          }\n        };\n        for (var i = 0, l = stackToCall.length; i < l; i++) {\n          _loop();\n        }\n        return !event.defaultPrevented;\n      }\n    }]);\n  }();\n  var AbortSignal = /*#__PURE__*/function (_Emitter) {\n    function AbortSignal() {\n      var _this2;\n      _classCallCheck(this, AbortSignal);\n      _this2 = _callSuper(this, AbortSignal);\n      // Some versions of babel does not transpile super() correctly for IE <= 10, if the parent\n      // constructor has failed to run, then \"this.listeners\" will still be undefined and then we call\n      // the parent constructor directly instead as a workaround. For general details, see babel bug:\n      // https://github.com/babel/babel/issues/3041\n      // This hack was added as a fix for the issue described here:\n      // https://github.com/Financial-Times/polyfill-library/pull/59#issuecomment-477558042\n      if (!_this2.listeners) {\n        Emitter.call(_this2);\n      }\n\n      // Compared to assignment, Object.defineProperty makes properties non-enumerable by default and\n      // we want Object.keys(new AbortController().signal) to be [] for compat with the native impl\n      Object.defineProperty(_this2, 'aborted', {\n        value: false,\n        writable: true,\n        configurable: true\n      });\n      Object.defineProperty(_this2, 'onabort', {\n        value: null,\n        writable: true,\n        configurable: true\n      });\n      Object.defineProperty(_this2, 'reason', {\n        value: undefined,\n        writable: true,\n        configurable: true\n      });\n      return _this2;\n    }\n    _inherits(AbortSignal, _Emitter);\n    return _createClass(AbortSignal, [{\n      key: \"toString\",\n      value: function toString() {\n        return '[object AbortSignal]';\n      }\n    }, {\n      key: \"dispatchEvent\",\n      value: function dispatchEvent(event) {\n        if (event.type === 'abort') {\n          this.aborted = true;\n          if (typeof this.onabort === 'function') {\n            this.onabort.call(this, event);\n          }\n        }\n        _superPropGet(AbortSignal, \"dispatchEvent\", this, 3)([event]);\n      }\n\n      /**\n       * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/API/AbortSignal/throwIfAborted}\n       */\n    }, {\n      key: \"throwIfAborted\",\n      value: function throwIfAborted() {\n        var aborted = this.aborted,\n          _this$reason = this.reason,\n          reason = _this$reason === void 0 ? 'Aborted' : _this$reason;\n        if (!aborted) return;\n        throw reason;\n      }\n\n      /**\n       * @see {@link https://developer.mozilla.org/zh-CN/docs/Web/API/AbortSignal/timeout_static}\n       * @param {number} time The \"active\" time in milliseconds before the returned {@link AbortSignal} will abort.\n       *                      The value must be within range of 0 and {@link Number.MAX_SAFE_INTEGER}.\n       * @returns {AbortSignal} The signal will abort with its {@link AbortSignal.reason} property set to a `TimeoutError` {@link DOMException} on timeout,\n       *                        or an `AbortError` {@link DOMException} if the operation was user-triggered.\n       */\n    }], [{\n      key: \"timeout\",\n      value: function timeout(time) {\n        var controller = new AbortController();\n        setTimeout(function () {\n          return controller.abort(new DOMException(\"This signal is timeout in \".concat(time, \"ms\"), 'TimeoutError'));\n        }, time);\n        return controller.signal;\n      }\n\n      /**\n       * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any_static}\n       * @param {Iterable<AbortSignal>} iterable An {@link Iterable} (such as an {@link Array}) of abort signals.\n       * @returns {AbortSignal} - **Already aborted**, if any of the abort signals given is already aborted.\n       *                          The returned {@link AbortSignal}'s reason will be already set to the `reason` of the first abort signal that was already aborted.\n       *                        - **Asynchronously aborted**, when any abort signal in `iterable` aborts.\n       *                          The `reason` will be set to the reason of the first abort signal that is aborted.\n       */\n    }, {\n      key: \"any\",\n      value: function any(iterable) {\n        var controller = new AbortController();\n        /**\n         * @this AbortSignal\n         */\n        function abort() {\n          controller.abort(this.reason);\n          clean();\n        }\n        function clean() {\n          var _iterator = _createForOfIteratorHelper(iterable),\n            _step;\n          try {\n            for (_iterator.s(); !(_step = _iterator.n()).done;) {\n              var signal = _step.value;\n              signal.removeEventListener('abort', abort);\n            }\n          } catch (err) {\n            _iterator.e(err);\n          } finally {\n            _iterator.f();\n          }\n        }\n        var _iterator2 = _createForOfIteratorHelper(iterable),\n          _step2;\n        try {\n          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n            var signal = _step2.value;\n            if (signal.aborted) {\n              controller.abort(signal.reason);\n              break;\n            } else signal.addEventListener('abort', abort);\n          }\n        } catch (err) {\n          _iterator2.e(err);\n        } finally {\n          _iterator2.f();\n        }\n        return controller.signal;\n      }\n    }]);\n  }(Emitter);\n  var AbortController = /*#__PURE__*/function () {\n    function AbortController() {\n      _classCallCheck(this, AbortController);\n      // Compared to assignment, Object.defineProperty makes properties non-enumerable by default and\n      // we want Object.keys(new AbortController()) to be [] for compat with the native impl\n      Object.defineProperty(this, 'signal', {\n        value: new AbortSignal(),\n        writable: true,\n        configurable: true\n      });\n    }\n    return _createClass(AbortController, [{\n      key: \"abort\",\n      value: function abort(reason) {\n        var signalReason = normalizeAbortReason(reason);\n        var event = createAbortEvent(signalReason);\n        this.signal.reason = signalReason;\n        this.signal.dispatchEvent(event);\n      }\n    }, {\n      key: \"toString\",\n      value: function toString() {\n        return '[object AbortController]';\n      }\n    }]);\n  }();\n  if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n    // These are necessary to make sure that we get correct output for:\n    // Object.prototype.toString.call(new AbortController())\n    AbortController.prototype[Symbol.toStringTag] = 'AbortController';\n    AbortSignal.prototype[Symbol.toStringTag] = 'AbortSignal';\n  }\n\n  function polyfillNeeded(self) {\n    if (self.__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL) {\n      console.log('__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL=true is set, will force install polyfill');\n      return true;\n    }\n\n    // Note that the \"unfetch\" minimal fetch polyfill defines fetch() without\n    // defining window.Request, and this polyfill need to work on top of unfetch\n    // so the below feature detection needs the !self.AbortController part.\n    // The Request.prototype check is also needed because Safari versions 11.1.2\n    // up to and including 12.1.x has a window.AbortController present but still\n    // does NOT correctly implement abortable fetch:\n    // https://bugs.webkit.org/show_bug.cgi?id=174980#c2\n    return typeof self.Request === 'function' && !self.Request.prototype.hasOwnProperty('signal') || !self.AbortController;\n  }\n\n  (function (self) {\n\n    if (!polyfillNeeded(self)) {\n      return;\n    }\n    self.AbortController = AbortController;\n    self.AbortSignal = AbortSignal;\n  })(typeof self !== 'undefined' ? self : global);\n\n}));\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = function(module) {\n\tvar getter = module && module.__esModule ?\n\t\tfunction() { return module['default']; } :\n\t\tfunction() { return module; };\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = function(exports, definition) {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","__webpack_require__.nmd = function(module) {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","/**\n * polyfill for CustomEvent in IE9,...\n */\n(function () {\n  if (typeof window.CustomEvent === 'function') {\n    return false;\n  }\n\n  function CustomEvent(event, params) {\n    params = params || { bubbles: false, cancelable: false, detail: undefined };\n    var evt = document.createEvent('CustomEvent');\n\n    evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);\n    return evt;\n  }\n\n  CustomEvent.prototype = window.Event.prototype;\n  window.CustomEvent = CustomEvent;\n})();\n","import { NullableBoolean } from './common';\n\nexport const ServiceValues = {\n  BASE: 'BASE',\n  TV: 'TV',\n  FULLTEXT: 'FULLTEXT',\n  NANO: 'NANO',\n  PARTNER: 'PARTNER',\n  SMALL: 'SMALL',\n} as const;\n\nexport const LoginStateValues = {\n  GREEN: 'GREEN',\n  ORANGE: 'ORANGE',\n  RED: 'RED',\n} as const;\n\nexport type Service = (typeof ServiceValues)[keyof typeof ServiceValues];\n\nexport type Premium = NullableBoolean;\n\nexport type LoginState = (typeof LoginStateValues)[keyof typeof LoginStateValues] | null;\n\nexport type UserAgreement = { dopo: boolean } | null;\n\nexport type Version = `${bigint}.${bigint}`;\n\nexport type ConfigValue = string | number | boolean;\n\nexport interface Config {\n  /* enable to index Data using string type */\n  [index: string]: any;\n\n  /* host of the URL we hit */\n  host: string;\n\n  /* we are hitting this URL, '__HOST__' will be replaced by Config.host */\n  url: string;\n\n  /* URL of iframe used for setting third-party cookies, '__HOST__' will be replaced by Config.host */\n  thirdPartyCookieUrl: string;\n\n  /* debouncing time of hitting scroll/resize [seconds] */\n  delay: number;\n\n  /* search query */\n  query: string;\n\n  /* service ID */\n  service: string;\n\n  /* local session ID */\n  lsid: string;\n\n  /* page ID */\n  id: string;\n\n  /* user ID for GDPR (sent as ri) */\n  rusId: number | '';\n\n  /* user ID (rusId) chifre */\n  said: string;\n\n  /* login state - logged in, orange, not logged in (sent as los) */\n  loginState: LoginState;\n\n  /* verze api */\n  version: Version;\n\n  /* true značí použití DOTu v SPA aplikaci */\n  spa: boolean;\n\n  /* ID for pairing backend data with collected hits (sent as pvid) */\n  pageViewId: string;\n\n  /* whether to send impress request automatically after configuration */\n  impress: boolean;\n\n  /* whether to start mousedown measuring automatically after configuration */\n  mousedown?: boolean;\n\n  /* whether to measure onLoad event */\n  load?: boolean;\n\n  /* whether to measure onError event and uncought exceptions */\n  error?: boolean;\n\n  /* AB testing version ID */\n  abtest: string;\n\n  /* service variant ID */\n  serviceVariant: string;\n\n  /* time limit of hit */\n  hitTimeout: number;\n\n  /* whether to save hits and hit them on beforeunload or next call of configure with lazyLoadingEnabled: false */\n  lazyLoadingEnabled?: boolean;\n\n  /* whether to send data-dot-data on mousedown event */\n  mousedownDataDotData?: boolean;\n\n  /* user agreement object for recass, sent along the spenttime hit */\n  u_agrm: UserAgreement;\n\n  /* whether the logged in user is a premium user */\n  premium: Premium;\n\n  /* whether to reset spenttime on configure call in SPA */\n  spenttimeSpaReset: boolean;\n\n  /* send all hits via beaconApi */\n  forceBeacon: boolean;\n\n  /* whether to use server-side refresher */\n  serverSideRefresher?: boolean;\n\n  /**\n   * enable dop_ param cleanup after spenttime initialized\n   */\n  dopParamCleanup?: boolean;\n\n  /**\n   * enable hit duplicating/propagating to the top window if this instance runs in a frame\n   */\n  propagateHits?: boolean;\n\n  /* login badge, if true medailonek is on a webpage */\n  badge?: boolean;\n\n  /* time (in seconds) after which sending spenttime hits should stop */\n  spenttimeDuration: number;\n\n  // properties only for certain variants have to be marked as optional\n}\n","/* eslint-disable no-unused-vars */\nimport { ServiceValues, LoginStateValues } from '../types/config';\nimport { SspAllowedSourcesObject } from '../types/types';\n\nexport const DOT_VERSION = process.env._DOT_VERSION;\n\nexport const SERVICE_VARIANT = ServiceValues;\n\nexport const PROTOCOL = 'https:';\nexport const API_HOST = 'h.seznam.cz';\n\nexport const REGEX_IMEDIA_HOST = /h\\.imedia(\\.dev\\.dszn\\.|\\.test\\.dszn\\.|\\.)cz/;\nexport const REGEX_DEV_OR_TEST_HOST = /h\\.seznam\\.(dev|test)\\.dszn\\.cz/;\n\nexport const LOGIN_STATE = LoginStateValues;\n\nexport const LAZY_HITTING_ENABLED = 1;\nexport const LAZY_HITTING_DISABLED = 0;\n\nexport const enum HTTP_METHODS {\n  POST = 'POST',\n}\n\n// Spenttime\nexport const FIRST_SPENTTIME_SLOT = 5;\nexport const SPENTTIME_MIN_DURATION = 3_600;\nexport const SPENTTIME_INTERVAL_CONFIG = [\n  {\n    endOfInterval: 10,\n    interval: FIRST_SPENTTIME_SLOT,\n  },\n  {\n    endOfInterval: 30,\n    interval: 20,\n  },\n  {\n    endOfInterval: 4 * 60,\n    interval: 30,\n  },\n  {\n    endOfInterval: 15 * 60,\n    interval: 60,\n  },\n  {\n    endOfInterval: SPENTTIME_MIN_DURATION,\n    interval: 5 * 60,\n  },\n];\n\n// localStorage key for lastSession\nexport const LAST_SESSION_KEY = 'dot_lastSession';\nexport const CDL_KEY = 'dot_cdl';\n\nexport enum EVENTS {\n  AFTER_CFG_EVENT = 'dot-cfg', // event fired when DOT is configured\n  COOKIE_EVENT = 'szn:dot:cookie', // CustomEvent name for cookie creation\n  GET_INFO_EVENT = 'szn:dot:getinfo', // iframe bridge message event\n  GET_INFO_COMPLETE = 'szn:dot:getinfocomplete', // iframe bridge finished info transfer\n  REDIRECT_SID = 'szn:dot:getsidfromredirect', // sid after redirect is cut from url\n  FIRST_IMPRESS_SENT = 'szn:dot:impressdone', // first impress on page is sent\n  PROPAGATE_HIT_MESSAGE = 'szn:dot:propagatehit', // postMessage to send hit data from iframe DOT to the top window DOT\n  CDL_DONE = 'szn:dot:cdldone', // cookieDeprecationLabel resolved\n  SCMP_CONSENT_SET = 'scmp_consent_set', // CMP event fired after saving consent cookie\n}\n\n// cfgFromTopFrame timeout (ms)\nexport const CFG_FROM_TOP_FRAME_TIMEOUT = 5000;\n\n// debugger\nexport const SERVICE_NAME = 'DOT';\nexport const LOG_COLOR_MIN = 0x66;\nexport const LOG_COLOR_MAX = 0x100;\nexport const LOG_COLOR_DEFAULT = '#FFF';\nexport const LOG_COLOR_BG = '#000';\n\n// IS\nexport const IS_TABLE_KEYS_SPECIAL = {\n  rusId: 'rusId',\n  said: 'said',\n  premium: 'premium',\n  loginState: 'state',\n};\nexport const IS_TABLE_LOGIN_STATE = {\n  green: 'login',\n  red: 'forget',\n  orange: 'logout',\n};\n\n// Propagate hits\nexport const PROPAGATE_HITS_BLACKLIST = ['impress', 'load'];\n\n// Additional check for sid request\nexport const MAX_ITERATIONS = 20;\nexport const INTERVAL_TIMEOUT = 500;\n\n// Udid request\nexport const UDID_REQUEST_TIMEOUT = 2000;\n\n// Cookie wall\nexport const CW_REFERRER_COOKIE_NAME = 'cw_referrer';\nexport const CW_REFERRER_CURRENT_COOKIE_NAME = 'cw_referrer_current';\nexport const CW_UTIL_COOKIE_NAME = 'cw_util';\n\n// SSP\nexport const SSP_ALLOWED_SOURCES = SspAllowedSourcesObject;\n\n// DOT timeout in IFRAME\nexport const DOT_TIMEOUT_IN_IFRAME_BRIDGE = 1000;\n","// SSP\nexport const SspAllowedSourcesObject = {\n  'hp_feed': 'hp_feed', // deprecated, but we cannot afford to break websites using this\n  'sekce-z-internetu': 'hp_feed',\n  'denni-tisk': 'novinky',\n  'novinky': 'novinky',\n  'media': 'media',\n  'z-boxiku': 'hp_box',\n  'hp_box': 'hp_box',\n  'search': 'search',\n  'software': 'software',\n  'sbrowser': 'sbrowser',\n  'radio': 'radio',\n  'tvseznam': 'tvseznam',\n} as const;\n\nexport type SspAllowedSources = typeof SspAllowedSourcesObject;\n","// Types\nimport { DOT } from '../../../classes/dot.class';\nimport { Service } from '../../../types/config';\nimport { NullableString } from '../../../types/common';\n// Constants\nimport { API_HOST, REGEX_DEV_OR_TEST_HOST, REGEX_IMEDIA_HOST, SERVICE_VARIANT, EVENTS } from '../../../constants/index';\n\n/**\n * Replace / escape specific chars ([]) from name\n * @param name Name of url param to be sanitized\n */\nexport const _sanitizeParamName = (name: string): string => {\n  return name.replace(/[\\[\\]]/g, '\\\\$&');\n};\n\n/**\n * Apply regex on string (url) -> find key/value pair -> return value\n * @param haystack String / part or url\n * @param needle Regular expression to be matched during search\n */\nexport const _getParamValueByRegExp = (haystack: string, needle: RegExp): NullableString => {\n  const results = needle.exec(haystack);\n  if (!results || !results[2]) {\n    return null;\n  }\n  return decodeURIComponent(results[2].replace(/\\+/g, ' '));\n};\n\n/**\n * Extract param value from url query (?)\n * @param name Name of url param (?) for which we want to retrieve value\n * @param url Uses current document URL if ommited\n */\nexport const getParameterFromURLQuery = (name: string, url?: string): NullableString => {\n  const regExp = new RegExp('[?&]' + _sanitizeParamName(name) + '(=([^&#]*)|&|#|$)');\n  return _getParamValueByRegExp(url || window.location.href, regExp);\n};\n\n/**\n * Extract param value from url hash (#)\n * @param name Name of url param (#) for which we want to retrieve value\n */\nexport const getParameterFromURLHash = (name: string): NullableString => {\n  const regExp = new RegExp('[#&]' + _sanitizeParamName(name) + '(=([^&]*)|&)');\n  return _getParamValueByRegExp(window.location.hash, regExp);\n};\n\n/**\n * Replace \"imedia\" with \"seznam\" in the URL string\n */\nexport const replaceImedia = (url: string): string => {\n  return url.replace(REGEX_IMEDIA_HOST, 'h.seznam$1cz');\n};\n\n/**\n * Return filename of current variant of DOT script\n * @param variant DOT variant\n */\nexport const _getScriptFilename = (variant: Service): string | Error => {\n  switch (variant) {\n    case SERVICE_VARIANT.BASE:\n      return 'dot-base.js';\n    case SERVICE_VARIANT.TV:\n      return 'dot-tv.js';\n    case SERVICE_VARIANT.NANO:\n      return 'dot-nano.js';\n    case SERVICE_VARIANT.PARTNER:\n      return 'dot-partner.js';\n    case SERVICE_VARIANT.SMALL:\n      return 'dot-small.js';\n    case SERVICE_VARIANT.FULLTEXT:\n      return 'dot-fulltext.js';\n    default:\n      return Error('Invalid DOT variant');\n  }\n};\n\n/**\n * Obtain URL of the (first) DOT script loaded into the page\n * @param variant DOT variant\n */\nexport const getDotSource = (variant: Service): string => {\n  const filename = _getScriptFilename(variant);\n  const scripts = document.querySelectorAll(`script[src*=\"/${filename}\"]`);\n  const dotScript = scripts.item(0);\n\n  return dotScript ? dotScript.getAttribute('src') : '';\n};\n\n/**\n * Get \"server\" param value from the DOT source URL query string\n * @param variant DOT variant\n */\nexport const _getAPIHostFromDotSourceParam = (variant: Service): NullableString => {\n  const dotSource = getDotSource(variant);\n  return getParameterFromURLQuery('server', dotSource);\n};\n\n/**\n * Get testing/development host from the DOT source URL\n * @param variant DOT variant\n */\nexport const _getTestAPIHostFromUrl = (variant: Service): NullableString => {\n  const dotSource = getDotSource(variant);\n\n  const match = replaceImedia(dotSource).match(REGEX_DEV_OR_TEST_HOST);\n  if (match && match[0]) {\n    return match[0];\n  }\n\n  return null;\n};\n\n/**\n * Decides where to hit API\n * @param variant DOT variant\n */\nexport const getAPIHost = (variant: Service): string => {\n  return _getAPIHostFromDotSourceParam(variant) || _getTestAPIHostFromUrl(variant) || API_HOST;\n};\n\n/*\n * Gets document location href. When on seznamzpravy.cz, gets only part before ?\n */\nexport const getDocumentUrl = (): string => {\n  const wlocation = window.location;\n\n  // hack for seznamzpravy.cz\n  const playerUrl = 'www.seznamzpravy.cz/iframe/player';\n  if (wlocation.href.includes(playerUrl)) {\n    return wlocation.href.substring(0, wlocation.href.indexOf('?'));\n  } else {\n    return wlocation.href;\n  }\n};\n\n/**\n * Gets $zn param from location search and adds current url to history without it\n * If $zn parameter does not exist returns null\n */\nexport const getZnStringFromLocationSearch = (dot: DOT): NullableString => {\n  const params = new URLSearchParams(window.location.search);\n  let znstring: NullableString = null;\n\n  params.forEach((value, key) => {\n    try {\n      const [decodedParamKey, decodedParamValue] = [decodeURIComponent(key), decodeURIComponent(value)];\n      if (decodedParamKey === '_zn') {\n        znstring = decodedParamValue;\n        history.replaceState({}, '', window.location.href.replace(`${key}=${value}`, '').replace('&&', '&'));\n        window.dispatchEvent(new CustomEvent(EVENTS.REDIRECT_SID));\n        dot.log(`Got hashed sid from redirect: ${znstring}`);\n        return;\n      }\n    } catch {\n      //NO OP\n    }\n  });\n\n  return znstring;\n};\n\nexport const hasTCStringInLocationSearch = (): boolean => {\n  return window.location.search.match(/[?&]_tc=/) !== null;\n};\n\n/**\n * Get domain part by desired level\n */\nexport const getDomainLevel = (hostname = window.location.hostname, level = 2, leadingDot = true): NullableString => {\n  if (typeof hostname !== 'string') {\n    return null;\n  }\n  hostname = hostname.replace(/https?:\\/\\//, '');\n  let availableLevels = 0;\n  const separators = hostname.match(/\\./g);\n  if (separators) {\n    availableLevels = separators.length + 1;\n  }\n\n  if (!availableLevels || level > availableLevels) {\n    return hostname;\n  } else {\n    return (leadingDot && level < availableLevels ? '.' : '') + hostname.split('.').slice(-level).join('.');\n  }\n};\n\n/**\n * Removes \"www.\" part from hostname\n * @param hostname page hostname\n */\nexport const omitWww = (hostname) => hostname.replace(/^www\\./, '');\n\n/**\n * Checks if page is loaded from local disk\n * @param protocol location protocol\n */\nexport const isPageOpenfromLocalFile = (): boolean => {\n  try {\n    return window.location.protocol === 'file:';\n  } catch {\n    return false;\n  }\n};\n\n/**\n * Checks if script is on seznam.cz domain or its subdomain\n */\nexport const isSeznamDomain = (): boolean => {\n  const hostname = omitWww(window.location?.hostname || '');\n  return hostname === 'seznam.cz' || hostname.endsWith('.seznam.cz');\n};\n\n// API\nexport default {\n  getDotSource,\n  getParameterFromURLQuery,\n  getParameterFromURLHash,\n  replaceImedia,\n  getAPIHost,\n  getDocumentUrl,\n  getZnStringFromLocationSearch,\n  getDomainLevel,\n};\n","import { EVENTS } from '../../../constants';\nimport { KeyValuePairs, NullableString } from '../../../types/common';\nimport { CookieData, CookieExpirationTuple } from '../../../types/cookie';\nimport { getDomainLevel } from '../general/url';\n\n/**\n * Time multipliers for time from NOW calculation\n */\nconst multipliers: KeyValuePairs<number> = {\n  seconds: 1000,\n  minutes: 60,\n  hours: 60,\n  days: 24,\n};\n\n/**\n * Default / common cookie values\n */\nconst cookieDefaults: CookieData = {\n  name: '',\n  value: '',\n  expires: [365, 'days'],\n  path: '/',\n  secure: null,\n  sameSite: null,\n  domain: null,\n};\n\n/**\n * Get expiration time as string suitable for cookie storing\n * @param expirationArray Tuple defining amount of units of expiration duration\n */\nexport const _getExpireTime = (expirationArray: CookieExpirationTuple): string => {\n  const [value, units] = expirationArray;\n  const multipliersKeys = Object.keys(multipliers);\n  const unitIndex = multipliersKeys.findIndex((unit) => unit === units);\n  const multiArray = !~unitIndex ? [] : multipliersKeys.map((k) => multipliers[k]).slice(0, unitIndex + 1);\n\n  const offset = multiArray.reduce(\n    (acc: number, current: number) => {\n      return acc * current;\n    },\n    multiArray.length ? value : 0\n  );\n\n  const date = new Date();\n  date.setTime(date.getTime() + offset);\n  return date.toUTCString();\n};\n\n/**\n * Get composed cookie value string (value + metadata)\n * @param cookieData Object representing cookie value/metadata to be stored\n * @param remove Flag defining creation / removing of cookie\n */\nexport const _getCookieString = (cookieData: CookieData, remove = false): string => {\n  if (!cookieData.name) {\n    throw new Error('No cookie name provided');\n  }\n\n  const cookieValues = { ...cookieDefaults, ...cookieData };\n  const { name, value, expires, path, secure, sameSite } = cookieValues;\n  let { domain } = cookieValues;\n  const expireTime = remove ? new Date(0).toUTCString() : _getExpireTime(expires as CookieExpirationTuple);\n\n  if (!domain) {\n    domain = getDomainLevel();\n  }\n\n  const cookieValue = [\n    `${name}=${value}`,\n    `Expires=${expireTime}`,\n    `Path=${path}`,\n    domain ? `Domain=${domain}` : '',\n    sameSite ? `SameSite=${sameSite}` : '',\n    secure ? 'Secure' : '',\n  ].filter((el) => !!el);\n\n  return cookieValue.join(';');\n};\n\n/**\n * Extract cookie Key / Value pair from single cookie string\n * @param cookieString single cookie key/value string\n */\nexport const _getCookieKeyValuePair = (cookieString: string): [string, string] => {\n  const separatorIndex = cookieString.indexOf('=');\n  const key = cookieString.substring(0, separatorIndex);\n  const value = cookieString.substring(separatorIndex + 1);\n  return [key.trim(), value.trim()];\n};\n\n/**\n * Get cookie value by name\n * @param requestedCookieName Name of cookie to retrieve\n */\nexport const getCookie = (requestedCookieName: string): NullableString => {\n  const cookies = document.cookie.split(';');\n\n  const foundCookie = cookies.reduce((acc, cookieString) => {\n    const [key, value] = _getCookieKeyValuePair(cookieString);\n    if (key === requestedCookieName) {\n      acc = value;\n    }\n    return acc;\n  }, null);\n\n  return foundCookie;\n};\n\n/**\n * Gets sid cookie value from local domain\n */\nexport const getSidCookie = (): NullableString => getCookie('sid');\n\n/**\n * Set cookie from data object\n * @param cookieData Data object for new cookie\n */\nexport const setCookie = (cookieData: CookieData): void => {\n  document.cookie = _getCookieString(cookieData);\n};\n\n/**\n *  Set cookie from data object + report by CustomEvent\n */\nexport const setCookieAndReport = (cookieData: CookieData): void => {\n  setCookie(cookieData);\n  window.dispatchEvent(new CustomEvent(EVENTS.COOKIE_EVENT, { detail: cookieData }));\n};\n\n/**\n * Delete cookie (set expiration in past)\n * @param cookieData Data object for cookie to be removed\n */\nexport const removeCookie = (cookieData: CookieData): void => {\n  document.cookie = _getCookieString(cookieData, true);\n};\n\n// API\nexport default { getCookie, setCookie, removeCookie, getSidCookie, setCookieAndReport };\n","// Types\nimport { KeyValuePairs } from 'types/common';\nimport { IS_TABLE_KEYS_SPECIAL, IS_TABLE_LOGIN_STATE } from '../../constants/index';\nimport { IDENTITIES_SIMPLIFIED_SPECIAL } from '@iva/types/identity-storage';\n\n/**\n * Converts login color values to \"login\" | \"logout\" | forget. When non-color value in param presented, returns undefined\n * @param loginValue green | orange | red\n */\nexport const _convertLoginValue = (loginValue: string): string | undefined => {\n  return IS_TABLE_LOGIN_STATE[loginValue];\n};\n\n/**\n * Update special identities (rusId, said, premium) in sznIVA.IS from DOT config object\n * @param configObject dot config object\n */\nexport const updateIdentitiesFromConfig = (customConfig: KeyValuePairs<unknown>): void => {\n  if (!window.sznIVA?.IS || !customConfig) {\n    return;\n  }\n\n  const identitiesSpecial: IDENTITIES_SIMPLIFIED_SPECIAL = {};\n\n  const specialKeys = Object.keys(IS_TABLE_KEYS_SPECIAL);\n\n  specialKeys.forEach((key) => {\n    const identityKey = IS_TABLE_KEYS_SPECIAL[key];\n\n    if (customConfig[key] !== undefined) {\n      identitiesSpecial[identityKey] = customConfig[key];\n\n      if (identityKey === IS_TABLE_KEYS_SPECIAL.loginState) {\n        identitiesSpecial[identityKey] = _convertLoginValue(customConfig[key] as string) || customConfig[key];\n      }\n    }\n  });\n\n  if (!!Object.keys(identitiesSpecial).length) {\n    window.sznIVA.IS.updateIdentities(identitiesSpecial);\n  }\n};\n\n/**\n * Updates sid in sznIVA.IS\n * @param sid string value\n */\nexport const updateSidIdentity = (sid: string): void => {\n  if (window.sznIVA?.IS && sid) {\n    window.sznIVA.IS.updateIdentities({ sid });\n  }\n};\n\n/**\n * Checks if current user is admin from helpdesk\n */\nexport const isSznAdmin = (): boolean => {\n  const login = window.sznIVA?.IS?.getIdentity('login');\n\n  if (!login) {\n    return false;\n  }\n\n  const flag = (login as KeyValuePairs<unknown>).adminName;\n\n  return !!flag;\n};\n\n// API\nexport default { updateIdentitiesFromConfig, updateSidIdentity, isSznAdmin };\n","import { SPENTTIME_MIN_DURATION } from '../../constants';\nimport { KeyValuePairs } from '../../types/common';\n\nexport const _validateRusId = (rusId: any): number | '' => {\n  const NumberRusId = parseInt(rusId, 10);\n  return Number.isNaN(NumberRusId) ? '' : NumberRusId;\n};\n\nexport const _validateSpenttimeDuration = (spenttimeDuration: unknown): number => {\n  const duration = Number(spenttimeDuration);\n\n  if (Number.isNaN(duration)) {\n    return SPENTTIME_MIN_DURATION;\n  }\n\n  return duration < SPENTTIME_MIN_DURATION ? SPENTTIME_MIN_DURATION : duration;\n};\n\n/**\n * Validates dot config object\n * @param customConfig DOT config object\n */\nexport const validateConfig = (customConfig: KeyValuePairs<unknown>): void => {\n  if (!customConfig) {\n    return;\n  }\n\n  if (customConfig.rusId !== undefined) {\n    customConfig.rusId = _validateRusId(customConfig.rusId);\n  }\n\n  if (customConfig.spenttimeDuration !== undefined) {\n    customConfig.spenttimeDuration = _validateSpenttimeDuration(customConfig.spenttimeDuration);\n  }\n};\n\n// API\nexport default { validateConfig };\n","// Types\nimport { KeyValuePairs } from '../../types/common';\nimport { DOT } from '../../classes/dot.class';\nimport { Config, Service, ConfigValue } from '../../types/config';\n// Methods\nimport { getCookie } from '../utils/cookie/cookie';\nimport { getAPIHost, replaceImedia } from '../utils/general/url';\nimport { updateIdentitiesFromConfig } from '../identityObject/identityObject';\nimport { validateConfig } from './validation';\n// Constants\nimport { EVENTS, SERVICE_VARIANT, PROTOCOL, SPENTTIME_MIN_DURATION } from '../../constants/index';\n\n/**\n * Return config object for specified DOT variant\n * @param variant DOT variant\n */\nexport const getConfig = (variant?: Service): Config => {\n  const config: Config = {\n    host: getAPIHost(variant),\n    url: PROTOCOL + '//__HOST__/hit',\n    thirdPartyCookieUrl: PROTOCOL + '//__HOST__/sid',\n    delay: 800,\n    query: '',\n    service: '',\n    lsid: '',\n    id: '',\n    rusId: '',\n    said: '',\n    loginState: null,\n    version: '1.0',\n    spa: false,\n    pageViewId: '',\n    impress: true,\n    abtest: '',\n    serviceVariant: '',\n    hitTimeout: 60000,\n    // eslint-disable-next-line camelcase\n    u_agrm: null,\n    premium: null,\n    spenttimeSpaReset: true,\n    forceBeacon: false,\n    dopParamCleanup: true,\n    propagateHits: false,\n    badge: false,\n    spenttimeDuration: SPENTTIME_MIN_DURATION,\n  };\n\n  switch (variant) {\n    case SERVICE_VARIANT.BASE:\n      return {\n        ...config,\n      };\n\n    case SERVICE_VARIANT.TV:\n      return {\n        ...config,\n        mousedown: true,\n        mousedownDataDotData: true,\n        url: 'http://__HOST__/hit',\n      };\n\n    case SERVICE_VARIANT.NANO:\n      return {\n        ...config,\n        serverSideRefresher: getCookie('szncsr') !== null,\n      };\n\n    case SERVICE_VARIANT.SMALL:\n      return {\n        ...config,\n        mousedown: true,\n        load: true,\n        error: false,\n        mousedownDataDotData: true,\n        lazyLoadingEnabled: false,\n        serverSideRefresher: getCookie('szncsr') !== null,\n      };\n\n    case SERVICE_VARIANT.FULLTEXT:\n      return {\n        ...config,\n        mousedown: true,\n        load: true,\n        error: false,\n        mousedownDataDotData: true,\n        lazyLoadingEnabled: false,\n        serverSideRefresher: getCookie('szncsr') !== null,\n      };\n\n    case SERVICE_VARIANT.PARTNER:\n      return {\n        ...config,\n        serverSideRefresher: getCookie('szncsr') !== null,\n      };\n\n    default:\n      return config;\n  }\n};\n\n/**\n * Sends hit after configuration, if allowed\n * @param dot DOT instance\n */\nexport const _fireAfterCfgEvent = (dot: DOT): void => {\n  if (dot.fireEventAfterCfg) {\n    const event = new CustomEvent(EVENTS.AFTER_CFG_EVENT);\n    window.dispatchEvent(event);\n  }\n};\n\n/**\n * Turns on hitting after the first call of configure()\n * Returns The name of the custom event.\n * @param dot DOT instance\n */\nexport const enableAfterCfgEvent = (dot: DOT): string => {\n  dot.fireEventAfterCfg = true;\n  return EVENTS.AFTER_CFG_EVENT;\n};\n\n/**\n * Configures the DOT instance\n * @param dot DOT instance\n * @param customConfig Custom configuration object\n * @param impressCallback called when impress is sent\n */\nexport const configure = (dot: DOT, customConfig?: KeyValuePairs<unknown>): void => {\n  // validate config values\n  validateConfig(customConfig);\n\n  // set data\n  for (const p in customConfig) {\n    if (dot._cfg[p] !== undefined) {\n      dot._cfg[p] = customConfig[p];\n    }\n  }\n\n  updateIdentitiesFromConfig(customConfig);\n\n  // repair host\n  // TODO remove when all services change it to seznam domain\n  dot._cfg.host = replaceImedia(dot._cfg.host);\n\n  if (dot._cfg.url === '//h.imedia.cz/hit/?') {\n    dot._cfg.url = '//__HOST__/hit';\n  }\n\n  dot.log('Configure:', 'table', dot._cfg);\n};\n\n/**\n * Whether the configure() was called\n *\n * @param dot DOT instance\n */\nexport const isInstanceConfigured = (dot: DOT): boolean => dot.configured;\n\n/**\n * Returns value from instance config\n * @param dot DOT instance\n * @param key key of config value\n */\nexport const getValue = (dot: DOT, key: string): ConfigValue | null => {\n  return dot._cfg[key] ?? null;\n};\n\n// API\nexport default { getConfig, configure, isInstanceConfigured, enableAfterCfgEvent, getValue };\n","import { NullableString } from '../../../types/common';\n\n/**\n * Checks if localStorage functionality is available\n */\nexport const isLocalStorageAvailable = (): boolean => {\n  const test = 'localStorageTest';\n  try {\n    // even access to `localStorage` property can raise SecurityError on some browsers\n    if (!window.localStorage) {\n      return false;\n    }\n    localStorage.setItem(test, test);\n    localStorage.removeItem(test);\n    return true;\n  } catch {\n    return false;\n  }\n};\n\n/**\n * Sets the value of the pair identified by key to value into localStorage\n * If localStorage is not available, returns false, otherwise returns true\n * @param key item key\n * @param value item value\n */\nexport const setToLocalStorage = (key: string, value: string): boolean => {\n  if (!isLocalStorageAvailable()) {\n    return false;\n  }\n\n  // if run out of the allowed storage space limit per app/domain\n  try {\n    localStorage.setItem(key, value);\n    return true;\n  } catch {\n    return false;\n  }\n};\n\n/**\n * Returns item from localStorage\n * @param key item key\n */\nexport const getFromLocalStorage = (key: string): NullableString => {\n  if (!isLocalStorageAvailable()) {\n    return null;\n  }\n\n  // if run out of the allowed storage space limit per app/domain\n  try {\n    return localStorage.getItem(key);\n  } catch {\n    return null;\n  }\n};\n\n// API\nexport default { isLocalStorageAvailable, setToLocalStorage, getFromLocalStorage };\n","import { debug } from './modules/debug.js';\n/**\n * Method 'parseKeyValuePairs' splits the substring (partOfURL) according to the separator into array of {key, value}\n * @param {String} partOfURL query or hash\n * @param {String} [separator='&'] Separator between parameters in hash\n * @return {Object[]} Array with separated key and value\n * Example:\n * parseKeyValuePairs('header&a=1&b=&c=3')\n * => [{key: 'header', value: undefined}, {key: 'a', value: '1'}, {key: 'b', value: ''}, {key: 'c', value: '3'}]\n */\nconst parseKeyValuePairs = (partOfURL, separator = '&') => {\n    const keyValueList = partOfURL\n        .split(separator)\n        .map((pair) => {\n        const [key, value] = pair.split('=');\n        if (key === undefined || key === '') {\n            return null;\n        }\n        return { key, value };\n    })\n        .filter((pair) => pair != null);\n    return keyValueList;\n};\n/**\n * Method 'composeKeyValuePairs' collects a string of individual {key, value}\n * @param {Object[]} arr Array with separated key and value\n * @param {String} [separator='&'] Separator between parameters in hash\n * @return {Object[]} partOfURL (query or hash)\n * Example:\n * composeKeyValuePairs([{key: 'header', value: undefined}, {key: 'a', value: '1'}, {key: 'b', value: ''}, {key: 'c', value: '3'}])\n * => 'header&a=1&b=&c=3')\n */\nconst composeKeyValuePairs = (arr, separator = '&') => \n// eslint-disable-next-line no-nested-ternary\narr.map(({ key, value }) => (key === '' ? '' : value === undefined ? key : `${key}=${value}`)).join(separator);\n/**\n * Method 'getUrlSpecs' returns the specification from the url\n */\nconst getUrlSpecs = (url, hash = false, hashSeparator) => ({\n    partOfURL: hash ? url.hash.substring(1) : url.search.substring(1),\n    separator: hash ? hashSeparator || '&' : '&',\n    delimiter: hash ? '#' : '?',\n});\n/**\n * Method 'decodeValue' decodes part of url\n */\nconst decodeValue = (str) => decodeURI(str).replace(/\\+/g, ' ');\n/**\n * Method 'getParamVal' searches for and returns the parameter value(s) by name\n * @param {String} paramName - Parameter name (it can't be empty, it can't be made up of spaces only)\n * @param {String} [url = window.location.href] - URL-line\n * @param {Object} [configuration = {}] - Additional configuration of the function\n * @param {Boolean} [configuration.all] - Flag for searching for all values\n * all = false (default), the first value found is returned\n * all = true, the found values are returned in an array (one or more values)\n * @param {String} [configuration.part] - Part of url\n * part = 'query' (default)\n * part = 'hash'\n * @param {String} [configuration.hashSeparator] - Separator between parameters in hash\n * @return {String | String[] | null} returns a decoded value of the parameter (if there are several parameters, it returns the first value)\n * or returns null if the parameter is not found or if url is incorrect\n */\nconst getParamVal = (paramName, url = window.location.href, configuration = {}) => {\n    try {\n        debug({ state: 'start', message: 'getParamVal started', paramName, url, configuration });\n        if (!paramName.trim()) {\n            debug({\n                message: 'The parameter name (paramName) is empty or consists only of spaces',\n                paramName,\n            });\n            return null;\n        }\n        const urlObj = new URL(url);\n        const { partOfURL, separator } = getUrlSpecs(urlObj, configuration.part === 'hash', configuration.hashSeparator);\n        const encodedParamName = encodeURI(paramName);\n        const pairsArr = parseKeyValuePairs(partOfURL, separator);\n        if (configuration.all) {\n            // return array of value or null\n            const targetPairsArr = pairsArr\n                .filter((pair) => pair.key === encodedParamName)\n                .map((pair) => decodeValue(pair.value || ''));\n            const result = targetPairsArr.length > 0 ? targetPairsArr : null;\n            debug({ message: 'getParamVal finished', result });\n            return result;\n        }\n        else {\n            // return value or null\n            const targetPair = pairsArr.find((pair) => pair.key === encodedParamName);\n            const result = targetPair ? decodeValue(targetPair.value || '') : null;\n            debug({ message: 'getParamVal finished', result });\n            return result;\n        }\n    }\n    catch (error) {\n        debug({ type: 'error', message: 'Execution error', error });\n        return null;\n    }\n};\n/**\n * Method 'setParam' ADDS a parameter to url (if url doesn't have a parameter yet)\n *                or UPDATES the value in an existing parameter\n * @param {String} paramName - Parameter name (it can't be empty, it can't be made up of spaces only)\n * @param {String} paramValue - Parameter value\n * @param {String} [url = window.location.href] - URL-line\n * @param {Object} [configuration = {}] - additional configuration of the function\n * @param {String} [configuration.rewrite] -\n * rewrite is missing - the parameter will be added\n * rewrite = 'first' (default) - if there is one or more parameters with the same name, the value of the FIRST parameter will be overwritten, otherwise it will be added\n * rewrite = 'all' - if there is one or more parameters with the same name, then ALL their values will be overwritten, otherwise it will be added\n * rewrite = 'no' - only adds parameter, there is no check for the existence of the parameter\n * @param {String} [configuration.part] - Part of url\n * part = 'query' (default)\n * part = 'hash'\n * @param {String} [configuration.hashSeparator] - Separator between parameters in hash\n * @return {String | null} returns the encoded url with parametr\n * or returns null (if url is incorrect or something went wrong)\n */\nconst setParam = (paramName, paramValue = '', url = window.location.href, configuration = {}) => {\n    try {\n        debug({ message: 'setParam started', paramName, paramValue, url, configuration });\n        if (!paramName.trim()) {\n            debug({ message: 'The parameter name (paramName) is empty or consists only of spaces', url });\n            return url;\n        }\n        const urlObj = new URL(url);\n        const { partOfURL, separator, delimiter } = getUrlSpecs(urlObj, configuration.part === 'hash', configuration.hashSeparator);\n        let pairsArr = parseKeyValuePairs(partOfURL, separator);\n        let wasUpdate = false;\n        if (configuration.rewrite !== 'no') {\n            let canUpdate = true;\n            pairsArr = pairsArr.map((pair) => {\n                if (pair.key === paramName && canUpdate) {\n                    pair.value = paramValue;\n                    canUpdate = configuration.rewrite === 'all';\n                    wasUpdate = true;\n                }\n                return pair;\n            });\n        }\n        if (configuration.rewrite === 'no' || !wasUpdate) {\n            pairsArr.push({ key: paramName, value: paramValue });\n        }\n        const targetPartOfURL = delimiter + composeKeyValuePairs(pairsArr, separator);\n        if (configuration.part === 'hash') {\n            urlObj.hash = targetPartOfURL;\n        }\n        else {\n            urlObj.search = targetPartOfURL;\n        }\n        const result = urlObj.toString();\n        debug({ message: 'setParam finished', result });\n        return result;\n    }\n    catch (error) {\n        debug({ type: 'error', message: 'Execution error', error });\n        return null;\n    }\n};\n/**\n * Method 'getDomainLevel' gets domain part by desired level\n * @param {String} [hostname=window.location.hostname] URL\n * @param {Number} [level=2] Domain level\n * @param {Boolean} [leadingDot=true] The need to add a leading dot at the beginning\n * @return {String | null} Domain part\n */\nconst getDomainLevel = (hostname = window.location.hostname, level = 2, leadingDot = true) => {\n    if (level <= 0) {\n        return level === 0 ? '.' : null;\n    }\n    hostname = hostname.replace(/https?:\\/\\//, ''); // https://site.com -> site.com\n    [hostname = ''] = hostname.split(/[\\?#:\\/]/); //site.com/page?a=1#head -> site.com\n    let availableLevels = 0;\n    const separators = hostname.match(/\\./g);\n    if (separators) {\n        availableLevels = separators.length + 1;\n    }\n    if (!availableLevels || level > availableLevels) {\n        return hostname;\n    }\n    else {\n        return (leadingDot && level < availableLevels ? '.' : '') + hostname.split('.').slice(-level).join('.');\n    }\n};\n/**\n * Removes UTM parametr (whole key=value pair) from URL.\n * @param {*} sourceURL - URL to remove UTM from.\n * @param {*} paramName - Name (key) of param to remove.\n * @return {String} URL without specific UTM.\n */\nconst removeParam = (sourceURL, paramName) => {\n    const regex = new RegExp(`[?#&](${paramName}=[^&#]*&?)`);\n    const matches = regex.exec(sourceURL);\n    if (!matches || matches.length < 2) {\n        return sourceURL;\n    }\n    const { [1]: stringToReplace } = matches;\n    if (!stringToReplace) {\n        return sourceURL;\n    }\n    const newUrl = sourceURL\n        // remove sznclid\n        .replace(stringToReplace, '')\n        // remove extra & at the end\n        .replace(/&$/, '')\n        // remove empty UTM followed by hash\n        .replace(/\\?#/, '#')\n        // remove empty UTM or hash at the end of the URL\n        .replace(/[?#]$/, '');\n    return newUrl;\n};\nexport { setParam, getParamVal, getDomainLevel, removeParam };\n","// Types\nimport { Dimensions, Geometry } from '../../types/document';\n\n/**\n * Check collection of html elements for visibility (aggregate its data-elm atributes)\n * @param dataElms Collection of html elements for visibility check\n * @param dimensions Dimensions object (scroll position, size, ...)\n */\nexport const _getVisibleDataElm = (dataElms: HTMLElement[], dimensions: Dimensions): string[] => {\n  const { x, y, w, h } = dimensions;\n  const results = [];\n\n  for (let i = 0; i < dataElms.length; i++) {\n    let elm = dataElms[i];\n    let left = elm.offsetWidth / 2;\n    let top = elm.offsetHeight / 2;\n    while (elm) {\n      left += elm.offsetLeft;\n      top += elm.offsetTop;\n      elm = elm.offsetParent as HTMLElement;\n    }\n\n    if (left >= x && left <= x + w && top >= y && top <= y + h) {\n      results.push(dataElms[i].getAttribute('data-elm'));\n      dataElms.splice(i, 1);\n      i--;\n    }\n  }\n\n  return results;\n};\n\n/**\n * Get scroll position / dimensions of screen / root element\n */\nexport const _getDimensions = (): Dimensions => {\n  const x = document.documentElement.scrollLeft || document.body.scrollLeft || 0;\n  const y = document.documentElement.scrollTop || document.body.scrollTop || 0;\n  const w = document.documentElement.clientWidth || document.body.clientWidth || 0;\n  const h = document.documentElement.clientHeight || document.body.clientHeight || 0;\n  const page = document.body.offsetWidth + ',' + document.body.offsetHeight;\n  const scrn = screen.width + ',' + screen.height + ',' + screen.colorDepth;\n\n  return { x, y, w, h, page, scrn };\n};\n\n/**\n * Generate geometry object which can be attached to hit data (d: {...})\n * @param dataElms Collection (array) of html elements for visibility check\n */\nexport const getGeometry = (dataElms: HTMLElement[] = []): Geometry => {\n  if (!document.body) {\n    return {};\n  }\n\n  let geometry: Geometry = {};\n\n  const dimensions = _getDimensions();\n\n  const { x, y, w, h, page, scrn } = dimensions;\n\n  geometry = {\n    scroll: `${x},${y}`,\n    port: `${w},${h}`,\n    page,\n    screen: scrn,\n  };\n\n  const visible = _getVisibleDataElm(dataElms, dimensions);\n  if (visible.length) {\n    geometry.elm = visible.join(',');\n  }\n  return geometry;\n};\n\n// API\nexport default { getGeometry };\n","// Types\nimport { Data } from '../../types/hit';\nimport { DOT } from '../../classes/dot.class';\nimport { SpenttimeIntervalConfig } from '../../types/spenttime';\n// Methods\nimport { getParameterFromURLHash } from '../utils/general/url';\nimport { URL } from '@iva/utils';\n// Constants\nimport { FIRST_SPENTTIME_SLOT, SPENTTIME_INTERVAL_CONFIG } from '../../constants/index';\nimport { getPerformanceEntriesBy } from '../../modules/load/load';\n\nexport const callsOnHiddenPage = [];\n\n/**\n * Checks if page is visible\n * @returns {boolean} True if page is visible\n */\nexport const isPageVisible = (): boolean =>\n  document.visibilityState === 'visible' || (typeof document.visibilityState === 'undefined' && !document.hidden);\n\n/**\n * Checks if page is hidden\n * @returns {boolean} True if page is hidden\n */\nexport const isPageHidden = (): boolean =>\n  document.visibilityState === 'hidden' || (typeof document.visibilityState === 'undefined' && document.hidden);\n\n/**\n * Visibilitychange event handler for first time user sees page (e.g. when user switches to new opened tab)\n */\nexport const _firstVisibilityPageChangeHandler = (): void => {\n  if (isPageVisible()) {\n    callsOnHiddenPage.forEach(({ dot, data }) => {\n      // eslint-disable-next-line no-use-before-define\n      spenttime(dot, data);\n    });\n    callsOnHiddenPage.length = 0;\n    document.removeEventListener('visibilitychange', _firstVisibilityPageChangeHandler);\n  }\n};\n\n/**\n * Adds spenttime call to queue when page is hidden and DOT.spenttime is called (e.g. when right click on link and open new tab in Chrome)\n * @param dot DOT instance\n * @param data spenttime data\n */\nexport const _addToCallsQueue = (dot: DOT, data: Data): void => {\n  if (!callsOnHiddenPage.length) {\n    // add event listener only once\n    document.addEventListener('visibilitychange', _firstVisibilityPageChangeHandler);\n  }\n  callsOnHiddenPage.push({ dot, data });\n};\n\n/**\n * Stops and removes spenttime interval\n */\nexport const clearSpenttimeInterval = (dot: DOT): void => {\n  if (dot.spenttimeState?.intervalId) {\n    clearTimeout(dot.spenttimeState.intervalId);\n    dot.spenttimeState.intervalId = null;\n  }\n};\n\n/**\n * Removes visibilitychange event handler\n */\nexport const clearVisibilitychangeEvent = (dot: DOT): void => {\n  if (dot.spenttimeConfigured) {\n    dot.spenttimeConfigured = false;\n    if (dot.spenttimeState?.visibilitychangeListener) {\n      document.removeEventListener('visibilitychange', dot.spenttimeState.visibilitychangeListener, false);\n      document.removeEventListener('pagehide', dot.spenttimeState.visibilitychangeListener, false);\n    }\n  }\n};\n\n/**\n * Send spenttime hit\n * @param time Time from session start in seconds\n */\nexport const _hit = (dot: DOT, data: Data, time: number): void => {\n  if (!dot.spenttimeConfigured) {\n    return;\n  }\n\n  if (!data.d) {\n    data.d = {};\n  }\n\n  data.d.action = 'spenttime';\n  data.d.time = time;\n\n  dot.hit('event', { ...data }, null, true);\n};\n\n/**\n * Tries to send spenttime hit when leaving page\n * @param dot DOT instance\n * @param data spenttime data\n * @param time spent time on page\n */\nexport const _blurHit = (dot: DOT, data: Data, time: number): void => {\n  data.d.type = 'final';\n  _hit(dot, data, time);\n};\n\n/**\n * Sends first spenttime hit when website is loaded\n * Uses first-contentful-paint from web vitals\n */\nexport const _fcpHit = (dot: DOT) => {\n  const fcp = getPerformanceEntriesBy('name', 'first-contentful-paint', {\n    startTime: null,\n  } as PerformanceEntry);\n  const fcpValue = fcp.startTime / 1000; // convert to seconds\n\n  // prevent duplicate hit on SPA website\n  if (dot._cfg.spa && fcpValue === dot.lastFCP) {\n    return;\n  }\n\n  if (fcpValue < FIRST_SPENTTIME_SLOT) {\n    dot.lastFCP = fcpValue;\n    _hit(dot, dot.spenttimeState.data, fcpValue);\n  }\n};\n\n/**\n * Creates sequence in which spenttime hits are sent, based on SPENTTIME_INTERVAL_CONFIG\n * First hit is sent in 5s, second 10s, third 30s,then every 30sec till 4 minutes,then every  minute till 15 minutes after that every 5 minutes till one hour\n */\nexport const _createIntervalSequence = (\n  config: SpenttimeIntervalConfig[],\n  spenttimeDuration: number\n): { intervalSequence: number[]; totalTime: number } => {\n  return config.reduce(\n    ({ intervalSequence, totalTime }, { endOfInterval, interval }, index) => {\n      const currentEndOfInterval = index === config.length - 1 ? spenttimeDuration : endOfInterval;\n      while (totalTime < currentEndOfInterval) {\n        totalTime += interval;\n        intervalSequence = [...intervalSequence, interval];\n      }\n      return { intervalSequence, totalTime };\n    },\n    { intervalSequence: [], totalTime: 0 }\n  );\n};\n\n/**\n * Creates timeout, which sends spenttime hit and calls next iteration\n */\nexport const _createInterval = (dot: DOT) => {\n  const {\n    spenttimeState,\n    _cfg: { spenttimeDuration },\n  } = dot;\n\n  if (!spenttimeState) {\n    // spenttime was already canceled\n    return;\n  }\n\n  const { intervalSequence } = _createIntervalSequence(SPENTTIME_INTERVAL_CONFIG, spenttimeDuration);\n\n  const lastTotalSpenttime = intervalSequence.slice(0, spenttimeState.i).reduce((acc, val) => acc + val, 0);\n\n  // Spenttime stops hitting after duration\n  if (lastTotalSpenttime >= spenttimeDuration || !intervalSequence.length) {\n    return;\n  }\n\n  const nextIntervalTime = (intervalSequence[spenttimeState.i] || intervalSequence[intervalSequence.length - 1]) * 1000;\n\n  // if the interval was cleared, we need calculate elapsed time before interval reset\n  const elapsedTime = spenttimeState.intervalId ? 0 : (spenttimeState.pageTime - lastTotalSpenttime) * 1000;\n\n  spenttimeState.intervalId = setTimeout((): void => {\n    spenttimeState.data.d.type = 'regular';\n    spenttimeState.i++;\n\n    const currentTotalSpenttime = intervalSequence.slice(0, spenttimeState.i).reduce((acc, val) => acc + val, 0);\n\n    _hit(dot, spenttimeState.data, currentTotalSpenttime);\n    _createInterval(dot);\n  }, nextIntervalTime - elapsedTime);\n};\n\n/**\n * Returns current timestamp\n * @return {number} Current timestamp in seconds\n */\nexport const _getCurrentTime = (): number => {\n  return new Date().getTime() / 1000;\n};\n\n/**\n * Vytvori spenttime objekt\n */\nexport const _init = (dot: DOT, data: Data): void => {\n  dot.spenttimeState = {\n    data,\n    i: 0,\n    intervalId: null,\n    lastVisit: _getCurrentTime(),\n    visibilitychangeListener: null,\n    pageTime: 0,\n    blurEventCalled: false,\n    unloadListener: null,\n  };\n};\n\n/**\n * Visibilitychange event handler (window minimalization, tab switching)\n */\nexport const _handleVisibilityChange = (dot: DOT): void => {\n  if (isPageVisible()) {\n    // change to visible\n    dot.spenttimeState.lastVisit = _getCurrentTime();\n    dot.spenttimeState.blurEventCalled = false;\n    _createInterval(dot);\n  } else if (!dot.spenttimeState.blurEventCalled) {\n    // change to hidden\n    clearSpenttimeInterval(dot);\n    dot.spenttimeState.pageTime += _getCurrentTime() - dot.spenttimeState.lastVisit;\n    _blurHit(dot, dot.spenttimeState.data, dot.spenttimeState.pageTime);\n    dot.spenttimeState.blurEventCalled = true;\n  }\n};\n\n/**\n * Unload and Beforeunload event handler\n * @param dot DOT instance\n */\nexport const _handleUnload = (dot: DOT): void => {\n  if (!dot.spenttimeState) {\n    // spenttime was already canceled\n    dot.log('spenttime: (_handleUnload) already canceled');\n    return;\n  }\n\n  if (dot.spenttimeState.blurEventCalled) {\n    // avoid double \"blur hit\" send\n    dot.log('spenttime: double blur hit prevented');\n    return;\n  }\n\n  dot.spenttimeState.blurEventCalled = true;\n  dot.spenttimeState.pageTime += _getCurrentTime() - dot.spenttimeState.lastVisit;\n  _blurHit(dot, dot.spenttimeState.data, dot.spenttimeState.pageTime);\n};\n\n// helper for temporary solution for migrating internal services to SSP initiated Spenttime\nexport const getSpenttimeInitiator = (data: Data): 'ssp' | string | undefined => {\n  return data && data.initiator;\n};\n\n/**\n * Stops spenttime measurment and hitting\n */\nexport const cancelSpenttime = (dot: DOT): void => {\n  clearSpenttimeInterval(dot);\n  clearVisibilitychangeEvent(dot);\n\n  dot.spenttimeState = null;\n  dot.spenttimeConfigured = false;\n};\n\n/**\n * Start spenttime measurement and hitting.\n * Hits are sent as following: first hit 5s, second 10s, third 30s, then every 30sec till 4 minutes, then every minute till 15 minutes after that every 5 minutes till one hour\n * Measuring stops after one hour\n */\nexport const spenttime = (dot: DOT, data?: Data): void => {\n  if (isPageHidden()) {\n    _addToCallsQueue(dot, data);\n    return;\n  }\n\n  // If dot.spenttimeState is not undefined (initialization didn't happen yet) or empty object (spenttime was cancelled),\n  // it means the duplicate initialization and we need to avoid it.\n  if (dot.spenttimeState && Object.keys(dot.spenttimeState).length) {\n    // Cancel current running spenttime if the new one is initiated by SSP and the current one not.\n    if (getSpenttimeInitiator(data) === 'ssp' && getSpenttimeInitiator(dot.spenttimeState?.data) !== 'ssp') {\n      dot.log('spenttime: Canceling custom initiated spenttime and initiating by SSP.');\n      cancelSpenttime(dot);\n    }\n\n    // Break new spenttime initiation if the old one is initiated by SSP and the new one not.\n    if (getSpenttimeInitiator(data) !== 'ssp' && getSpenttimeInitiator(dot.spenttimeState?.data) === 'ssp') {\n      dot.log('spenttime: Spenttime was already initiated by SSP. Terminating.');\n      return;\n    }\n  }\n\n  clearSpenttimeInterval(dot);\n\n  if (!data?.d) {\n    data = { ...(data || {}), d: {} };\n  }\n\n  const { d } = data;\n  const dopAbVariant = getParameterFromURLHash('dop_ab_variant');\n  const dopReqId = getParameterFromURLHash('dop_req_id');\n  const dopSourceZoneName = getParameterFromURLHash('dop_source_zone_name');\n  const dopId = getParameterFromURLHash('dop_id');\n  const dopVertId = getParameterFromURLHash('dop_vert_id');\n  const dopVertAb = getParameterFromURLHash('dop_vert_ab');\n\n  let newUrl = window.location.href;\n\n  /* doporucovani article ID has to overwrite data.d.id */\n  if (dopId) {\n    d.id = dopId;\n    newUrl = URL.removeParam(newUrl, 'dop_id');\n  }\n\n  if (dopAbVariant) {\n    // eslint-disable-next-line camelcase\n    d.dop_ab_variant = dopAbVariant;\n  }\n\n  if (dopReqId) {\n    // eslint-disable-next-line camelcase\n    d.dop_req_id = dopReqId;\n    newUrl = URL.removeParam(newUrl, 'dop_req_id');\n  }\n\n  if (dopSourceZoneName) {\n    // eslint-disable-next-line camelcase\n    d.dop_source_zone_name = dopSourceZoneName;\n  }\n\n  if (dopVertId) {\n    // eslint-disable-next-line camelcase\n    d.dop_vert_id = dopVertId;\n    newUrl = URL.removeParam(newUrl, 'dop_vert_id');\n  }\n\n  if (dopVertAb) {\n    // eslint-disable-next-line camelcase\n    d.dop_vert_ab = dopVertAb;\n    newUrl = URL.removeParam(newUrl, 'dop_vert_ab');\n  }\n\n  if (\n    !!dot.getCfgValue('dopParamCleanup') &&\n    window.location.href !== newUrl &&\n    getSpenttimeInitiator(data) === 'ssp'\n  ) {\n    window.history.replaceState(window.history.state, '', newUrl);\n  }\n\n  if (data.atricleId) {\n    d.articleId = data.atricleId;\n  }\n\n  if (!d.type) {\n    d.type = 'initial';\n  }\n\n  _init(dot, data);\n\n  if (!dot.spenttimeConfigured) {\n    dot.spenttimeConfigured = true;\n    dot.spenttimeState.visibilitychangeListener = (): void => _handleVisibilityChange(dot);\n    dot.spenttimeState.unloadListener = (): void => _handleUnload(dot);\n    document.addEventListener('visibilitychange', dot.spenttimeState.visibilitychangeListener);\n    document.addEventListener('pagehide', dot.spenttimeState.visibilitychangeListener);\n    window.addEventListener('unload', dot.spenttimeState.unloadListener);\n    window.addEventListener('beforeunload', dot.spenttimeState.unloadListener);\n  }\n\n  if ('PerformancePaintTiming' in window) {\n    _fcpHit(dot);\n  }\n\n  _createInterval(dot);\n};\n\n/**\n * Adds spenttime API to DOT instance\n * @param dot DOT instance\n */\nexport const addSpenttime = (dot: DOT): void => {\n  dot.spenttime = (data?: Data): void => {\n    spenttime(dot, data);\n  };\n\n  dot.cancelSpenttime = (): void => {\n    cancelSpenttime(dot);\n  };\n};\n\nexport default {\n  cancelSpenttime,\n  clearSpenttimeInterval,\n  clearVisibilitychangeEvent,\n  spenttime,\n  addSpenttime,\n};\n","export var IDENTITY_STATE;\n(function (IDENTITY_STATE) {\n    IDENTITY_STATE[\"cache\"] = \"cache\";\n    IDENTITY_STATE[\"fresh\"] = \"fresh\";\n})(IDENTITY_STATE || (IDENTITY_STATE = {}));\nexport var VALUES_TYPES;\n(function (VALUES_TYPES) {\n    VALUES_TYPES[\"string\"] = \"string\";\n    VALUES_TYPES[\"integer\"] = \"integer\";\n    VALUES_TYPES[\"boolean\"] = \"boolean\";\n    VALUES_TYPES[\"object\"] = \"object\";\n    VALUES_TYPES[\"array\"] = \"array\";\n    VALUES_TYPES[\"number\"] = \"number\";\n    VALUES_TYPES[\"hashString\"] = \"hashString\";\n    VALUES_TYPES[\"addressObject\"] = \"addressObject\";\n    VALUES_TYPES[\"phone\"] = \"phone\";\n    VALUES_TYPES[\"email\"] = \"email\";\n    VALUES_TYPES[\"secid\"] = \"secid\";\n})(VALUES_TYPES || (VALUES_TYPES = {}));\nexport var IDENTITIES_KEYS;\n(function (IDENTITIES_KEYS) {\n    IDENTITIES_KEYS[\"sid\"] = \"sid\";\n    IDENTITIES_KEYS[\"login\"] = \"login\";\n    IDENTITIES_KEYS[\"consent\"] = \"consent\";\n    IDENTITIES_KEYS[\"udid\"] = \"udid\";\n    IDENTITIES_KEYS[\"eid\"] = \"eid\";\n    IDENTITIES_KEYS[\"id5\"] = \"id5\";\n    IDENTITIES_KEYS[\"tid\"] = \"tid\";\n    IDENTITIES_KEYS[\"aid\"] = \"aid\";\n    IDENTITIES_KEYS[\"secid\"] = \"secid\";\n})(IDENTITIES_KEYS || (IDENTITIES_KEYS = {}));\nexport var IDENTITIES_KEYS_SPECIAL;\n(function (IDENTITIES_KEYS_SPECIAL) {\n    IDENTITIES_KEYS_SPECIAL[\"rusId\"] = \"rusId\";\n    IDENTITIES_KEYS_SPECIAL[\"premium\"] = \"premium\";\n    IDENTITIES_KEYS_SPECIAL[\"sbr\"] = \"sbr\";\n    IDENTITIES_KEYS_SPECIAL[\"said\"] = \"said\";\n    IDENTITIES_KEYS_SPECIAL[\"state\"] = \"state\";\n    IDENTITIES_KEYS_SPECIAL[\"pid\"] = \"pid\";\n    IDENTITIES_KEYS_SPECIAL[\"login\"] = \"login\";\n})(IDENTITIES_KEYS_SPECIAL || (IDENTITIES_KEYS_SPECIAL = {}));\n// input data types (can differ from output data types -> updateIdentities({consent: \"consentString\"}) -> getIdentity(\"consent\") -> consent object)\nexport var IDENTITIES_VALUES_TYPES;\n(function (IDENTITIES_VALUES_TYPES) {\n    IDENTITIES_VALUES_TYPES[\"sid\"] = \"string\";\n    IDENTITIES_VALUES_TYPES[\"login\"] = \"object\";\n    IDENTITIES_VALUES_TYPES[\"consent\"] = \"object\";\n    IDENTITIES_VALUES_TYPES[\"udid\"] = \"string\";\n    IDENTITIES_VALUES_TYPES[\"pid\"] = \"string\";\n    IDENTITIES_VALUES_TYPES[\"eid\"] = \"email\";\n    IDENTITIES_VALUES_TYPES[\"rusId\"] = \"integer\";\n    IDENTITIES_VALUES_TYPES[\"premium\"] = \"boolean\";\n    IDENTITIES_VALUES_TYPES[\"sbr\"] = \"boolean\";\n    IDENTITIES_VALUES_TYPES[\"said\"] = \"string\";\n    IDENTITIES_VALUES_TYPES[\"state\"] = \"string\";\n    IDENTITIES_VALUES_TYPES[\"id5\"] = \"string\";\n    IDENTITIES_VALUES_TYPES[\"tid\"] = \"phone\";\n    IDENTITIES_VALUES_TYPES[\"aid\"] = \"addressObject\";\n    IDENTITIES_VALUES_TYPES[\"secid\"] = \"secid\";\n})(IDENTITIES_VALUES_TYPES || (IDENTITIES_VALUES_TYPES = {}));\nexport var ADDRESS;\n(function (ADDRESS) {\n    ADDRESS[\"state\"] = \"a1\";\n    ADDRESS[\"city\"] = \"a2\";\n    ADDRESS[\"street\"] = \"a3\";\n    ADDRESS[\"houseNumber\"] = \"a4\";\n    ADDRESS[\"postalCode\"] = \"a5\";\n})(ADDRESS || (ADDRESS = {}));\nexport var PHONE;\n(function (PHONE) {\n    PHONE[\"areaCode\"] = \"t1\";\n    PHONE[\"number\"] = \"t2\";\n})(PHONE || (PHONE = {}));\nexport var DOT_CONFIG_PROPERTIES;\n(function (DOT_CONFIG_PROPERTIES) {\n    DOT_CONFIG_PROPERTIES[\"badge\"] = \"badge\";\n})(DOT_CONFIG_PROPERTIES || (DOT_CONFIG_PROPERTIES = {}));\n","// localStorage key for cache\nexport const LS_KEY_CACHE = 'szn:idnts:cch';\n// events name\nexport const EVENT_NAME = 'szn:identities';\nexport const EVENT_NAME_BEFORE_UPDATE = 'szn:identities:beforeupdate';\nexport const EVENT_NAME_READY = 'szn:identities:ready';\nexport const EVENT_FROM_TOP_NAME = 'szn:identities:fromtop';\nexport const EVENT_TO_TOP_NAME = 'szn:identities:totop';\n// cache max age\nexport const CACHE_MAX_AGE = 1000 * 60 * 60;\n// global timeout for identitites to be settled\nexport const TIMEOUT = 5000;\n// premature timeout (login)\nexport const TIMEOUT_PREMATURE_LOGIN = 1000;\n// default \"get\" rules\nexport const DEFAULT_GET_RULES = { rich: false, justSettled: true, cacheEnough: false };\n// id5\nexport const ID5_URL = 'https://cdn.id5-sync.com/api/1.0/id5-api.js';\n","import cloneDeep from 'lodash.clonedeep';\n/**\n * Logs message into console if proper UTM set to truthy value.\n * @param {object} - Configuration with log details.\n * @param {('log'|'warn'|'error'|'info'|'table')} [type = 'log'] - Type of console, if not specified defaults to \"log\".\n * @param {string | number} [subName] - additional service name subtype, can be used to log error code number\n * @param {unknown[]} [messages] - Data to be displayed as in console.\n */\nconst log = (config, type = 'log', subName, ...messages) => {\n    const { name, fColor, bColor } = config;\n    const style = `display: inline-block; color: ${fColor}; background: ${bColor}; padding: 1px 4px; border-radius: 3px;`;\n    const badge = `%c${name}${subName ? ' ' + subName : ''}`;\n    const messagesCopy = (messages !== null && messages !== void 0 ? messages : []).map((v) => cloneDeep(v));\n    if (type === 'table' && messagesCopy.length === 1) {\n        // print data in table, badge in the separate log\n        console.log(badge, style);\n        console.table(messagesCopy[0]);\n    }\n    else if (type === 'table' && messagesCopy.length === 2) {\n        // print data in table, badge and message in the separate log\n        console.log(badge, style, messagesCopy[0]);\n        console.table(messagesCopy[1]);\n    }\n    else {\n        // print any messages with a badge\n        console[type](badge, style, ...messagesCopy);\n    }\n};\nexport { log };\n","const ENABLER = 'sznivadbg';\nconst PERMANENT_ENABLER = 'sznivadbgsave';\nconst EVENT_PREFIX = 'iva_dbg_event_';\nconst DEFAULTS = {\n    FCOLOR: 'white',\n    BCOLOR: 'black',\n};\nexport { ENABLER, EVENT_PREFIX, DEFAULTS, PERMANENT_ENABLER };\n","import { getDebuggerRule } from './getShouldLog';\nimport { EVENT_PREFIX } from './constants';\nimport { log } from './log';\nimport { getInternalConfig } from './index';\nconst isTopLevel = (win = window) => (win.top === win.self || !!win.Cypress) && !win.frameElement;\n/**\n * Gets debugger window object from window.sznIVA.debugger, or returns undefined if it doesn't exist.\n * @returns\n */\nconst getGlobalDebuggerObject = () => { var _a; return (_a = window.sznIVA) === null || _a === void 0 ? void 0 : _a.debugger; };\n/**\n * Creates or updates debugger window object in window.sznIVA.debugger.\n * @param windowObject Object with properties to update.\n */\nconst upsertGlobalDebuggerObject = (windowObject) => {\n    window.sznIVA = window.sznIVA || {};\n    window.sznIVA.debugger = Object.assign(Object.assign({}, window.sznIVA.debugger), windowObject);\n};\n/**\n * Returns top frame debugger rule saved in the window object.\n */\nconst getTopFrameRule = () => { var _a; return (_a = getGlobalDebuggerObject()) === null || _a === void 0 ? void 0 : _a.topFrameRule; };\n/**\n * Handles message event from iframes requesting debugger rule.\n */\nconst handlerFromChildMessage = (event) => {\n    var _a, _b, _c;\n    try {\n        if (typeof ((_a = event === null || event === void 0 ? void 0 : event.source) === null || _a === void 0 ? void 0 : _a.postMessage) === 'function' &&\n            ((_b = event === null || event === void 0 ? void 0 : event.data) === null || _b === void 0 ? void 0 : _b.type) === `${EVENT_PREFIX}request_debug_settings`) {\n            const rule = getDebuggerRule();\n            event.source.postMessage({\n                type: `${EVENT_PREFIX}debug_settings`,\n                rule,\n            }, { targetOrigin: '*' });\n            if (!((_c = getGlobalDebuggerObject()) === null || _c === void 0 ? void 0 : _c.iframeBridgeNotified)) {\n                if (rule) {\n                    log(getInternalConfig(), undefined, undefined, `Top frame sends a debugger rule \"${rule}\" to iframes.`);\n                }\n                upsertGlobalDebuggerObject({ iframeBridgeNotified: true });\n            }\n        }\n    }\n    catch (e) {\n        log(getInternalConfig(), 'error', undefined, `${e instanceof Error ? e.message : 'An unknown error occurred in handlerFromChildMessage'}`);\n    }\n};\n/**\n * Handles message event from top window containing debugger rule.\n */\nconst handlerFromTopMessage = (event) => {\n    if (event.data.type === `${EVENT_PREFIX}debug_settings`) {\n        upsertGlobalDebuggerObject({ topFrameRule: event.data.rule });\n    }\n};\n/**\n * Init mechanism of getting current debugging rule from top window.\n */\nconst initIframeBridge = () => {\n    if (isTopLevel()) {\n        window.addEventListener('message', (event) => handlerFromChildMessage(event));\n    }\n    else {\n        window.addEventListener('message', (event) => handlerFromTopMessage(event));\n        try {\n            window.top.postMessage({ type: `${EVENT_PREFIX}request_debug_settings` }, document.referrer || '*');\n        }\n        catch (e) {\n            log(getInternalConfig(), 'error', undefined, `${e instanceof Error ? e.message : 'An unknown error occurred during initIframeBridge'}`);\n        }\n    }\n};\nexport { getInternalConfig, getTopFrameRule, getGlobalDebuggerObject, initIframeBridge, isTopLevel, upsertGlobalDebuggerObject, };\n","const getParamValue = (param) => {\n    const queryString = window.location.search || '';\n    const paramRegex = new RegExp(`${param}=([^&]*)`);\n    const matches = queryString.match(paramRegex) || [];\n    return matches.length > 1 ? matches[1] : null;\n};\nexport { getParamValue };\n","import { getGlobalDebuggerObject, getTopFrameRule, isTopLevel, upsertGlobalDebuggerObject } from './window';\nimport { ENABLER } from './constants';\nimport { getParamValue } from './url';\nimport { log } from './log';\nimport { getInternalConfig } from './index';\nconst getDebuggerRule = () => {\n    var _a;\n    const paramValue = getParamValue(ENABLER);\n    if (paramValue) {\n        return paramValue;\n    }\n    const topFrameRule = getTopFrameRule();\n    if (topFrameRule) {\n        return topFrameRule;\n    }\n    try {\n        const localStorageRule = ((_a = window.localStorage) === null || _a === void 0 ? void 0 : _a.getItem(ENABLER)) || '';\n        if (localStorageRule) {\n            return localStorageRule;\n        }\n    }\n    catch (error) {\n        log(getInternalConfig(), 'warn', undefined, JSON.stringify(error));\n    }\n    return '';\n};\n/**\n * Finds component name in provided string and decides whether to log based on it.\n * @param {String | null} paramValue Value of debug UTM\n * @param {*} name Name of current library\n * @return {Boolean} Should log or not\n */\nconst findNameInValue = (paramValue, name) => {\n    // empty string, or any falsey\n    if (!paramValue) {\n        return false;\n    }\n    // if paramValue === \"1\" always log\n    if (paramValue === '1') {\n        return true;\n    }\n    // if paramValue contains \"!\" allowed libraries are defined by exclusion\n    if (~paramValue.indexOf('!')) {\n        if (~paramValue.toLowerCase().indexOf(`!${name.toLowerCase()}`)) {\n            return false;\n        }\n        return true;\n    }\n    // if paramValue isn't \"1\" and contains name - should log\n    if (~paramValue.toLowerCase().indexOf(name.toLowerCase())) {\n        return true;\n    }\n    // did not fit any category - should NOT log\n    return false;\n};\n/**\n * Decides whether current library should be logging.\n * @param {*} name Name of current library\n * @return {Boolean} Should log or not\n */\nconst getShouldLog = (name) => {\n    var _a;\n    const rule = getDebuggerRule();\n    if (!((_a = getGlobalDebuggerObject()) === null || _a === void 0 ? void 0 : _a.welcomeNotified) && rule && isTopLevel()) {\n        upsertGlobalDebuggerObject({ welcomeNotified: true });\n        log(getInternalConfig(), 'log', undefined, '===============================================\\n' +\n            ` | 🕷 DEBUGGER is set to \"${rule}\".\\n` +\n            ` | Use \"1\" to let any component log or use component name[s] to filter them.\\n` +\n            ` | Using \\\"!component\\\" lets log all components except those listed.\\n` +\n            ` | Save the rule to local storage using GET parameter \"?sznivadbgsave=${rule}\"\\n` +\n            ` | and remove it by \"?sznivadbgsave=\".\\n` +\n            ` \\`=======================================================`);\n    }\n    return findNameInValue(rule, name);\n};\nexport { findNameInValue, getShouldLog, getDebuggerRule };\n","var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { log } from './log';\nimport { status } from './status';\nimport { getShouldLog } from './getShouldLog';\nimport { DEFAULTS } from './constants';\nimport { initIframeBridge } from './window';\nimport { permanentEnabler } from './permanent';\n/**\n * Returns debugger Config for the debugger itself.\n * @returns Debugger Config\n */\nconst getInternalConfig = () => ({\n    name: 'debugger',\n    fColor: '#AAA',\n    bColor: '#777',\n});\ninitIframeBridge();\n/**\n * Returns debug function based on config (name and colors)\n */\nconst debugFactory = (config) => {\n    permanentEnabler();\n    config = Object.assign({ fColor: DEFAULTS.FCOLOR, bColor: DEFAULTS.BCOLOR }, config);\n    if (!(config && config.name && config.fColor && config.bColor)) {\n        // in order not to break whomever is importing\n        // return a function that can still be called\n        return () => false;\n    }\n    const debug = (...args) => {\n        const types = ['log', 'warn', 'error', 'info', 'table'];\n        const argsCount = args.length;\n        const shouldLog = getShouldLog(config.name);\n        if (!shouldLog || argsCount === 0) {\n            // nothing to log, just return shouldLog\n            return shouldLog;\n        }\n        // debug({type: 'error', subName: '7845', message: 'Oh no', data: {...}, ...});\n        // or debug({state: '...', ...})\n        if (argsCount === 1 && typeof args[0] === 'object' && !Array.isArray(args[0]) && args[0] !== null) {\n            const [firstArg] = args;\n            const { state, type, subName, message } = firstArg, data = __rest(firstArg, [\"state\", \"type\", \"subName\", \"message\"]);\n            if (shouldLog) {\n                const logArgs = [];\n                if (message !== undefined) {\n                    logArgs.push(message);\n                }\n                if (Object.values(data).length === 1) {\n                    logArgs.push(data[Object.keys(data)[0]]);\n                }\n                else if (Object.values(data).length) {\n                    logArgs.push(data);\n                }\n                log(config, type, subName, ...logArgs);\n            }\n            if (state) {\n                status(config, state, data);\n            }\n            return shouldLog;\n        }\n        // debug('Look what happens.');\n        // debug(['someData', '...'}); anything else then object\n        if (shouldLog && argsCount === 1) {\n            log(config, 'log', undefined, args[0]);\n            return shouldLog;\n        }\n        // debug('error', 'Oh no, there is an error.');   or other types, like warn, info, table...\n        // debug('error', {someData: '...'});\n        if (shouldLog && argsCount === 2 && ~types.indexOf(args[0])) {\n            log(config, args[0], undefined, args[1]);\n            return shouldLog;\n        }\n        // debug('Look at this data', data, [moreData, ...]);\n        if (shouldLog && argsCount > 1 && !~types.indexOf(args[0])) {\n            log(config, 'log', undefined, ...args);\n            return shouldLog;\n        }\n        // debug('error', 'Oh no, there is an error, look at this data', data, [moreData, ...]);\n        // debug('table', 'Look at this data', data);\n        if (shouldLog && argsCount > 2 && ~types.indexOf(args[0])) {\n            log(config, args[0], undefined, ...args.slice(1));\n            return shouldLog;\n        }\n        // Some other args combination we forgot to cover? This shouldn't happen.\n        log(getInternalConfig(), 'warn', undefined, 'Debugger received unknown argument combination. args:', args);\n        return shouldLog;\n    };\n    return debug;\n};\nexport { debugFactory, getInternalConfig };\n","import { getInternalConfig } from './window';\nimport { log } from './log';\nimport { ENABLER, PERMANENT_ENABLER } from './constants';\nimport { getParamValue } from './url';\n/**\n * Checking of save command in GET params and saving the value to local storage.\n */\nconst permanentEnabler = () => {\n    var _a, _b, _c;\n    const paramValue = getParamValue(PERMANENT_ENABLER);\n    // nothing in URL\n    if (paramValue === null) {\n        return;\n    }\n    const lastValue = (_a = window.localStorage) === null || _a === void 0 ? void 0 : _a.getItem(ENABLER);\n    if (\n    // rule in URL is the same as the saved one (preventing console bloating)\n    paramValue === lastValue ||\n        // rule was already deleted\n        (lastValue === null && paramValue === '')) {\n        // do nothing\n        return;\n    }\n    if (paramValue === '') {\n        // blank string to remove the saved rule\n        (_b = window.localStorage) === null || _b === void 0 ? void 0 : _b.removeItem(ENABLER);\n        log(getInternalConfig(), undefined, undefined, 'Rule was removed from the local storage.');\n    }\n    else {\n        // a string to save to the local storage\n        (_c = window.localStorage) === null || _c === void 0 ? void 0 : _c.setItem(ENABLER, paramValue !== null && paramValue !== void 0 ? paramValue : '');\n        log(getInternalConfig(), undefined, undefined, `Rule \"${paramValue}\" was saved to the local storage.`);\n    }\n};\nexport { permanentEnabler };\n","import { EVENT_PREFIX } from './constants';\n/**\n * Saves current progress into window object and emits CustomEvent\n * @param {Object} config Object holding necessary constants\n * @param {('start'|'done'|'error')} state Event describing current state\n * @param {Object} data Data to be saved to window and emitted with event\n */\nconst status = (config, state, data) => {\n    const { name } = config;\n    const EVENT_TYPE = `${EVENT_PREFIX}${name}`;\n    const detail = Object.assign({ state }, data);\n    // Add to window\n    window.sznIVA = window.sznIVA || {};\n    window.sznIVA[name] = window.sznIVA[name] || {};\n    // Overwrite data, but do not remove any properties\n    Object.assign(window.sznIVA[name], detail);\n    // Emit CustomEvent\n    const event = new CustomEvent(EVENT_TYPE, { detail });\n    window.dispatchEvent(event);\n};\nexport { status };\n","import { debugFactory } from '@iva/debugger';\n// debugger\nconst config = {\n    name: 'IdentityStorage',\n    fColor: 'white',\n    bColor: '#ccc',\n};\nconst debug = debugFactory(config);\n// logger\nlet dotInstance = null;\nconst initDot = () => {\n    if (window.DOT) {\n        dotInstance = window.DOT.getNewInstance();\n        dotInstance.cfg({ service: 'idt', mousedown: false, load: false, impress: false });\n    }\n};\nconst dotLog = (data) => {\n    if (!dotInstance) {\n        initDot();\n    }\n    dotInstance === null || dotInstance === void 0 ? void 0 : dotInstance.hit('event', data);\n};\nconst sendToConfessor = (msg, msgType = 'error', stack) => {\n    var _a;\n    const data = Object.assign({ msg,\n        msgType, href: window.location.href, referrer: document.referrer }, (stack && { stack }));\n    (_a = navigator.sendBeacon) === null || _a === void 0 ? void 0 : _a.call(navigator, `https://confessor.iva.seznam.cz/identity-storage`, new URLSearchParams(data));\n};\nexport { debug, dotLog, sendToConfessor };\n","import { LS_KEY_CACHE } from './consts';\nimport { debug } from './debug';\n/**\n * LocalStorage helpers\n */\nexport const isStorageSupported = (() => {\n    const test = 'localStorageTest';\n    try {\n        localStorage.setItem(test, test);\n        localStorage.removeItem(test);\n        return true;\n    }\n    catch (e) {\n        return false;\n    }\n})();\nexport const getLocalStorageValue = (key) => {\n    try {\n        return isStorageSupported ? window.localStorage.getItem(key) : null;\n    }\n    catch (_a) {\n        debug({ type: 'error', message: 'LocalStorage getItem error' });\n        return null;\n    }\n};\nexport const setLocalStorageValue = (key, value) => {\n    if (isStorageSupported) {\n        try {\n            window.localStorage.setItem(key, value);\n        }\n        catch (_a) {\n            // no-op\n            debug({ type: 'error', message: 'LocalStorage setItem error' });\n        }\n    }\n};\n/**\n * Update cache.\n * Expects serialized identitites\n */\nexport const setCache = (identities) => setLocalStorageValue(LS_KEY_CACHE, identities);\n/**\n * Pull from cache\n */\nexport const getCache = () => getLocalStorageValue(LS_KEY_CACHE);\n","const _toBinary = (content) => {\n    const codeUnits = new Uint16Array(content.length);\n    for (let i = 0; i < codeUnits.length; i++) {\n        codeUnits[i] = content.charCodeAt(i);\n    }\n    const charCodes = new Uint8Array(codeUnits.buffer);\n    let result = '';\n    for (let i = 0; i < charCodes.byteLength; i++) {\n        result += String.fromCharCode(charCodes[i]);\n    }\n    return result;\n};\nconst _fromBinary = (binary) => {\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < bytes.length; i++) {\n        bytes[i] = binary.charCodeAt(i);\n    }\n    const charCodes = new Uint16Array(bytes.buffer);\n    let result = '';\n    for (let i = 0; i < charCodes.length; i++) {\n        result += String.fromCharCode(charCodes[i]);\n    }\n    return result;\n};\n/**\n * Encode string as base64\n */\nexport const encodeString = (content) => {\n    try {\n        return window.btoa(_toBinary(content));\n    }\n    catch (_a) {\n        // ancient browsers -> do not encode\n        return content;\n    }\n};\n/**\n * Decode string from base64\n */\nexport const decodeString = (content) => {\n    try {\n        return _fromBinary(window.atob(content));\n    }\n    catch (_a) {\n        // ancient browsers -> do not encode\n        return content;\n    }\n};\n","export class Base64Url {\n    /**\n     * Base 64 URL character set.  Different from standard Base64 char set\n     * in that '+' and '/' are replaced with '-' and '_'.\n     */\n    static DICT = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';\n    static REVERSE_DICT = new Map([\n        ['A', 0],\n        ['B', 1],\n        ['C', 2],\n        ['D', 3],\n        ['E', 4],\n        ['F', 5],\n        ['G', 6],\n        ['H', 7],\n        ['I', 8],\n        ['J', 9],\n        ['K', 10],\n        ['L', 11],\n        ['M', 12],\n        ['N', 13],\n        ['O', 14],\n        ['P', 15],\n        ['Q', 16],\n        ['R', 17],\n        ['S', 18],\n        ['T', 19],\n        ['U', 20],\n        ['V', 21],\n        ['W', 22],\n        ['X', 23],\n        ['Y', 24],\n        ['Z', 25],\n        ['a', 26],\n        ['b', 27],\n        ['c', 28],\n        ['d', 29],\n        ['e', 30],\n        ['f', 31],\n        ['g', 32],\n        ['h', 33],\n        ['i', 34],\n        ['j', 35],\n        ['k', 36],\n        ['l', 37],\n        ['m', 38],\n        ['n', 39],\n        ['o', 40],\n        ['p', 41],\n        ['q', 42],\n        ['r', 43],\n        ['s', 44],\n        ['t', 45],\n        ['u', 46],\n        ['v', 47],\n        ['w', 48],\n        ['x', 49],\n        ['y', 50],\n        ['z', 51],\n        ['0', 52],\n        ['1', 53],\n        ['2', 54],\n        ['3', 55],\n        ['4', 56],\n        ['5', 57],\n        ['6', 58],\n        ['7', 59],\n        ['8', 60],\n        ['9', 61],\n        ['-', 62],\n        ['_', 63],\n    ]);\n    /**\n     * log2(64) = 6\n     */\n    static BASIS = 6;\n    static LCM = 24;\n    /**\n     * Simple polyfill for the method String.prototype.repeat https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat\n     * to support IE without the need to polyfill\n     * @param str String that should be repeated\n     * @param count How many times\n     * @returns\n     */\n    static repeatStr(str, count) {\n        let res = '';\n        for (let i = 0; i < count; i++) {\n            res += str;\n        }\n        return res;\n    }\n    /**\n     * encodes an arbitrary-length bitfield string into base64url\n     *\n     * @static\n     * @param {string} str - arbitrary-length bitfield string to be encoded to base64url\n     * @return {string} - base64url encoded result\n     */\n    static encode(str) {\n        /**\n         * should only be 0 or 1\n         */\n        if (!/^[0-1]+$/.test(str)) {\n            throw new Error('Invalid bitField');\n        }\n        /**\n         * Pad the end of the string to the least common mutliple of 6 (basis for\n         * base64) and 8 (one byte)\n         */\n        const padding = str.length % this.LCM;\n        str += padding ? this.repeatStr('0', this.LCM - padding) : '';\n        let result = '';\n        for (let i = 0; i < str.length; i += this.BASIS) {\n            result += this.DICT[parseInt(str.substr(i, this.BASIS), 2)];\n        }\n        return result;\n    }\n    /**\n     * decodes a base64url encoded bitfield string\n     *\n     * @static\n     * @param {string} str - base64url encoded bitfield string to be decoded\n     * @return {string} - bitfield string\n     */\n    static decode(str) {\n        /**\n         * should contain only characters from the base64url set\n         */\n        if (!/^[A-Za-z0-9\\-_]+$/.test(str)) {\n            throw new Error('Invalidly encoded Base64URL string');\n        }\n        let result = '';\n        for (const strByte of str) {\n            /**\n             * index the binary value of the character from out reverse map\n             */\n            const strBits = this.REVERSE_DICT.get(strByte)?.toString(2);\n            if (typeof strBits === 'undefined') {\n                throw new Error('Invalidly encoded Base64URL string');\n            }\n            /**\n             * Since a bit string converted to an integer on encoding will lose\n             * leading zeros – pad to the left for those missing leading zeros\n             */\n            result += this.repeatStr('0', this.BASIS - strBits.length) + strBits;\n        }\n        return result;\n    }\n}\n","import { Base64Url } from '#cmp/iabtcf/Base64Url.js';\nexport const decodePurposeOne = (encodedTCString) => {\n    const segments = encodedTCString.split('.');\n    // documentation says its always the first one for v2\n    const [coreSegment] = segments;\n    if (!coreSegment) {\n        return false;\n    }\n    const bitField = Base64Url.decode(coreSegment);\n    const { [152]: purposeOneBit } = bitField;\n    return purposeOneBit === '1';\n};\n","/**\n * Method 'getCookie' gets cookie with provided name.\n * @param {String} name - Name of the cookie\n * @return {null | String } - description of each case:\n * null there is not cookie\n * string with value of cookie\n * string[] array of value of cookies (several cookies of the same name were found)\n */\nexport const getCookie = (name) => {\n    const matches = document.cookie.match(new RegExp('(?:^|; )' + name.replace(/([\\.$?*|{}\\(\\)\\[\\]\\\\\\/\\+^])/g, '\\\\$1') + '=([^;]*)'));\n    return matches && matches[1] ? decodeURIComponent(matches[1]) : null;\n};\n","import { decodePurposeOne } from '#cmp/cmpone.js';\nimport { getCookie } from '#cmp/cookie.js';\nexport const CONSENT_COOKIE_NAME = 'euconsent-v2';\nexport const CONSENT_PURPOSE_ONE_COOKIE_NAME = 'szncmpone';\nexport const CONSENT_GOOGLE_COOKIE_NAME = 'FCCDCF';\nexport const CONSENT_COOKIE_NAMES = [\n    CONSENT_COOKIE_NAME,\n    'eupubconsent-v2',\n    'ibb_euconsent',\n    'gdpr_consent',\n    'sas_cmp_cookie_consentData',\n    'csent',\n    CONSENT_GOOGLE_COOKIE_NAME,\n];\n/**\n * Extract consent string from cookie (special cases -> tc string wrapped inside non primitive).\n */\nconst extractConsentString = (cookieName, cookieValue) => {\n    try {\n        // GOOGLE consent\n        if (cookieName === CONSENT_GOOGLE_COOKIE_NAME && cookieValue) {\n            return JSON.parse(decodeURIComponent(cookieValue))[3][0];\n        }\n    }\n    catch {\n        return null;\n    }\n    // trust nobody\n    return cookieValue && typeof cookieValue === 'string' ? cookieValue : null;\n};\nexport const PurposeId = {\n    /**\n     * Purpose one is not supposed to be saved to purposeLegitimateInterests because we have purposeOneTreatment true,\n     * but it should be saved to purposeConsents, because RTB needs it.\n     */\n    COOKIE: 1,\n    // implicit consent\n    BASIC_ADS: 2,\n    MEASURE_ADS: 7,\n    MEASURE_PERFORMANCE: 8,\n    MARKET_RESEARCH: 9,\n    IMPROVE: 10,\n    // user choice\n    ADS_PROFILE: 3,\n    ADS: 4,\n    CONTENT_PROFILE: 5,\n    CONTENT: 6,\n};\nexport const hasPurposeOne = (consentString) => {\n    if (typeof consentString !== 'string') {\n        return false;\n    }\n    return decodePurposeOne(consentString);\n};\nconst getResult = (euconsentString, name) => {\n    return {\n        version: 'v2',\n        consentString: euconsentString,\n        name,\n        purposeOne: hasPurposeOne(euconsentString),\n    };\n};\n// wait for TCF API v2 for TCData\nlet receivedTCFData = '';\nlet listeningTCFApi = false;\nconst receiverCallbackList = [];\nconst tcCallback = (tcData, success) => {\n    if (success && tcData.eventStatus === 'useractioncomplete') {\n        // do something with tcData.tcString\n        receivedTCFData = tcData.tcString;\n        const result = getResult(receivedTCFData);\n        for (const receiverCallback of receiverCallbackList) {\n            receiverCallback(result);\n        }\n        receiverCallbackList.length = 0;\n    }\n};\nconst hasTCFApi = () => typeof window.__tcfapi === 'function';\n// listen to TCF api (just once)\nconst listenToTCFApi = () => {\n    if (hasTCFApi() && !listeningTCFApi) {\n        listeningTCFApi = true;\n        window.__tcfapi('addEventListener', 2, tcCallback);\n    }\n};\nlistenToTCFApi();\n/**\n * Get consent TCF cookie from predefined list.\n * @param receiverCallback if set you can wait until consent is set using TCF API v2\n * or you get no result it mean there is no TCF API\n * @returns Object ConsentResult from existing cookie or null if not found.\n */\nexport const getConsentFromCookieList = (receiverCallback) => {\n    if (!document) {\n        return null;\n    }\n    // in some cases TCF api is available after some time -> attach listener (if not already attached)\n    listenToTCFApi();\n    for (const cookie of CONSENT_COOKIE_NAMES) {\n        const cookieValue = extractConsentString(cookie, getCookie(cookie));\n        if (cookieValue) {\n            return getResult(cookieValue, cookie);\n        }\n    }\n    if (receivedTCFData) {\n        return getResult(receivedTCFData);\n    }\n    else if (typeof receiverCallback === 'function') {\n        if (hasTCFApi()) {\n            receiverCallbackList.push(receiverCallback);\n        }\n        else {\n            receiverCallback();\n        }\n    }\n    return null;\n};\nexport const hasPurposeOneFromCookieList = () => {\n    const consent = getConsentFromCookieList();\n    return consent ? hasPurposeOne(consent.consentString) : false;\n};\n","import { getConsentFromCookieList } from '#cmp/consent.js';\n/**\n * its timeout for page load, yes it will skip later user consent set,\n * but it will work on next page\n */\nconst TIME_TO_TIMEOUT = 2000;\nfunction isRedirectPage() {\n    return window.document.location.href.startsWith('https://www.seznam.cz/nastaveni-souhlasu');\n}\n/**\n * SID storing checker.\n * Uses Promise\n * @param timeout custom waiting timeout\n */\nexport const sidLegalStoreCheckPromise = (timeout) => {\n    return new Promise((resolveConsent) => {\n        const timeoutOk = typeof timeout === 'number' && timeout >= 0;\n        if (isRedirectPage()) {\n            window.addEventListener('scmp_closed', (event) => {\n                resolveConsent(event.detail.purposeConsents.has(1));\n            });\n        }\n        else {\n            let timer = window.setTimeout(() => {\n                resolveConsent(false);\n            }, timeoutOk ? timeout : TIME_TO_TIMEOUT);\n            const consentCallback = (consentResult) => {\n                if (consentResult) {\n                    resolveConsent(consentResult.purposeOne);\n                    if (timer) {\n                        window.clearTimeout(timer);\n                        timer = null;\n                    }\n                }\n            };\n            consentCallback(getConsentFromCookieList(consentCallback));\n        }\n    });\n};\n/**\n * SID storing checker.\n * Uses callback\n * @param callbackOk called when sid CAN be legally stored\n * @param callbackNotOk called when sid CANNOT be legally stored\n * @param timeout custom waiting timeout\n */\nexport const sidLegalStoreCheck = (callbackOk, callbackNotOk, timeout) => {\n    // callback runner\n    const call = (fn) => {\n        if (typeof fn === 'function') {\n            fn();\n        }\n    };\n    const timeoutOk = typeof timeout === 'number' && timeout >= 0;\n    // legality checker\n    const check = (purposeOne) => {\n        call(purposeOne ? callbackOk : callbackNotOk);\n    };\n    if (isRedirectPage()) {\n        window.addEventListener('scmp_closed', (event) => {\n            check(event.detail.purposeConsents.has(1));\n        });\n    }\n    else {\n        let timer = window.setTimeout(() => {\n            check(false);\n        }, timeoutOk ? timeout : TIME_TO_TIMEOUT);\n        const consentCallback = (consentResult) => {\n            if (consentResult) {\n                check(consentResult.purposeOne);\n                if (timer) {\n                    window.clearTimeout(timer);\n                    timer = null;\n                }\n            }\n        };\n        consentCallback(getConsentFromCookieList(consentCallback));\n    }\n};\n","/**\n * Get global namespaces\n */\nexport const getIS = () => { var _a; return (_a = window.sznIVA) === null || _a === void 0 ? void 0 : _a.IS; };\nexport const getISconfig = () => { var _a; return (_a = window.sznIVA) === null || _a === void 0 ? void 0 : _a.ISConfig; };\n/**\n * Initial State object (for example propagated from site BE, to hydrate IS on FE)\n */\nexport const getInitialState = () => window.__SZN_IS_INITIAL_STATE__;\nexport const cleanupInitialState = () => delete window.__SZN_IS_INITIAL_STATE__;\n","import equal from 'lodash.isequal';\nimport { sendToConfessor } from './debug';\n/**\n * Check equality (deep)\n */\nexport const isEqual = (obj1, obj2) => equal(obj1, obj2);\n/**\n * No own properties? -> return null\n */\nexport const getNullableObject = (object, nullable = false) => nullable && isObject(object) && !Object.keys(object).length ? null : object;\n/**\n * Is value Object?\n */\nexport const isObject = (item) => !!(item && typeof item === 'object' && !Array.isArray(item));\n/**\n * Is value valid SHA256 string?\n */\nexport const isValidSHA256String = (value) => typeof value === 'string' && /^[a-f0-9]{64}$/gi.test(value);\n/**\n * IS value valid UUID (any version, just simple char types + length check) string\n */\nexport const isValidUUID = (value) => typeof value === 'string' && /^[0-9a-f-]{36}$/gi.test(value);\n/**\n * Cast Boolean from other types\n */\nexport const castBoolean = (value) => {\n    if ([0, 'false', false].includes(value)) {\n        return false;\n    }\n    if ([1, 'true', true].includes(value)) {\n        return true;\n    }\n    return null;\n};\n/**\n * Browser detection helpers\n */\nexport const browser = {\n    isSafari: () => navigator.userAgent.includes('Safari/') &&\n        !navigator.userAgent.includes('Chrome/') &&\n        !navigator.userAgent.includes('Chromium/'),\n    isFirefox: () => navigator.userAgent.includes('Firefox/') && !navigator.userAgent.includes('Seamonkey/'),\n};\n/**\n * Load external script (apend to DOM a handle as promise).\n */\nexport const loadScript = (url, id) => {\n    const identifier = `identity-storage-ext-script:${id}`;\n    const markLoaded = 'loaded';\n    const element = document.getElementById(identifier);\n    // external script tag already created\n    if (element) {\n        return element.classList.contains(markLoaded) ? Promise.resolve() : Promise.reject();\n    }\n    // create external script tag (+ handle load states)\n    return new Promise((resolve, reject) => {\n        const script = document.createElement('script');\n        const _reportAndReject = () => {\n            sendToConfessor(`ScriptLoadError (${url})`);\n            reject();\n        };\n        const _markAndResolve = () => {\n            script.classList.add(markLoaded);\n            resolve();\n        };\n        script.src = url;\n        script.id = identifier;\n        script.onload = _markAndResolve;\n        script.onerror = _reportAndReject;\n        script.onabort = _reportAndReject;\n        (document.body || document.head || document.documentElement).appendChild(script);\n    });\n};\n// get HOSTNAME\nexport const getHostname = () => { var _a, _b; return (_b = (_a = window.location) === null || _a === void 0 ? void 0 : _a.hostname) === null || _b === void 0 ? void 0 : _b.replace(/^www\\./, ''); };\n// typeguard for IDENTITIES_SIMPLIFIED\nexport const isIdentitiesSimplifiedObject = (identities) => {\n    if (!isObject(identities)) {\n        return false;\n    }\n    const requiredKeys = ['value', 'created', 'updated', 'state', 'settled'];\n    const isIdentityObject = Object.values(identities || {}).every((value) => {\n        return isObject(value) && requiredKeys.every((key) => key in value);\n    });\n    return !isIdentityObject;\n};\n","import { cleanupInitialState, getISconfig, getInitialState } from './namespace';\nimport { isObject } from './utils';\n/**\n * Optional storage config\n */\nexport const getGlobalConfig = () => (isObject(getISconfig()) ? getISconfig() : null);\nexport const isAvailable = (identificator) => {\n    var _a;\n    const availables = (_a = getGlobalConfig()) === null || _a === void 0 ? void 0 : _a.available;\n    return !availables || ~availables.indexOf(identificator);\n};\nexport const isCrossFrameBridgeActive = () => {\n    var _a;\n    const bridgeConfig = (_a = getGlobalConfig()) === null || _a === void 0 ? void 0 : _a.framesBridge;\n    return bridgeConfig === undefined || bridgeConfig;\n};\n/**\n * Use optional INIT object, copy data and clean it up\n */\nexport const pullInitialIdentities = () => {\n    const initIdentities = getInitialState();\n    if (!initIdentities) {\n        return {};\n    }\n    const output = Object.assign({}, initIdentities);\n    cleanupInitialState();\n    return output;\n};\n","export var ADDRESS;\n(function (ADDRESS) {\n    ADDRESS[\"state\"] = \"a1\";\n    ADDRESS[\"city\"] = \"a2\";\n    ADDRESS[\"street\"] = \"a3\";\n    ADDRESS[\"houseNumber\"] = \"a4\";\n    ADDRESS[\"postalCode\"] = \"a5\";\n})(ADDRESS || (ADDRESS = {}));\n","/* eslint-disable no-use-before-define */\n\nconst crypto =\n  (typeof globalThis != 'undefined' ? globalThis : void 0)?.crypto ||\n  (typeof global != 'undefined' ? global : void 0)?.crypto ||\n  (typeof window != 'undefined' ? window : void 0)?.crypto ||\n  (typeof self != 'undefined' ? self : void 0)?.crypto ||\n  (typeof frames != 'undefined' ? frames : void 0)?.[0]?.crypto;\n\nlet randomWordArray;\n\nif (crypto) {\n  randomWordArray = (nBytes) => {\n    const words = [];\n\n    for (let i = 0, rcache; i < nBytes; i += 4) {\n      words.push(crypto.getRandomValues(new Uint32Array(1))[0]);\n    }\n\n    return new WordArray(words, nBytes);\n  }\n} else {\n  // Because there is no global crypto property in this context, cryptographically unsafe Math.random() is used.\n\n  randomWordArray = (nBytes) => {\n    const words = [];\n  \n    const r = (m_w) => {\n      let _m_w = m_w;\n      let _m_z = 0x3ade68b1;\n      const mask = 0xffffffff;\n  \n      return () => {\n        _m_z = (0x9069 * (_m_z & 0xFFFF) + (_m_z >> 0x10)) & mask;\n        _m_w = (0x4650 * (_m_w & 0xFFFF) + (_m_w >> 0x10)) & mask;\n        let result = ((_m_z << 0x10) + _m_w) & mask;\n        result /= 0x100000000;\n        result += 0.5;\n        return result * (Math.random() > 0.5 ? 1 : -1);\n      };\n    };\n  \n    for (let i = 0, rcache; i < nBytes; i += 4) {\n      const _r = r((rcache || Math.random()) * 0x100000000);\n  \n      rcache = _r() * 0x3ade67b7;\n      words.push((_r() * 0x100000000) | 0);\n    }\n  \n    return new WordArray(words, nBytes);\n  }\n}\n\n/**\n * Base class for inheritance.\n */\nexport class Base {\n  /**\n   * Extends this object and runs the init method.\n   * Arguments to create() will be passed to init().\n   *\n   * @return {Object} The new object.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var instance = MyType.create();\n   */\n  static create(...args) {\n    return new this(...args);\n  }\n\n  /**\n   * Copies properties into this object.\n   *\n   * @param {Object} properties The properties to mix in.\n   *\n   * @example\n   *\n   *     MyType.mixIn({\n   *         field: 'value'\n   *     });\n   */\n  mixIn(properties) {\n    return Object.assign(this, properties);\n  }\n\n  /**\n   * Creates a copy of this object.\n   *\n   * @return {Object} The clone.\n   *\n   * @example\n   *\n   *     var clone = instance.clone();\n   */\n  clone() {\n    const clone = new this.constructor();\n    Object.assign(clone, this);\n    return clone;\n  }\n}\n\n/**\n * An array of 32-bit words.\n *\n * @property {Array} words The array of 32-bit words.\n * @property {number} sigBytes The number of significant bytes in this word array.\n */\nexport class WordArray extends Base {\n  /**\n   * Initializes a newly created word array.\n   *\n   * @param {Array} words (Optional) An array of 32-bit words.\n   * @param {number} sigBytes (Optional) The number of significant bytes in the words.\n   *\n   * @example\n   *\n   *     var wordArray = CryptoJS.lib.WordArray.create();\n   *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);\n   *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);\n   */\n  constructor(words = [], sigBytes = words.length * 4) {\n    super();\n\n    let typedArray = words;\n    // Convert buffers to uint8\n    if (typedArray instanceof ArrayBuffer) {\n      typedArray = new Uint8Array(typedArray);\n    }\n\n    // Convert other array views to uint8\n    if (\n      typedArray instanceof Int8Array\n      || typedArray instanceof Uint8ClampedArray\n      || typedArray instanceof Int16Array\n      || typedArray instanceof Uint16Array\n      || typedArray instanceof Int32Array\n      || typedArray instanceof Uint32Array\n      || typedArray instanceof Float32Array\n      || typedArray instanceof Float64Array\n    ) {\n      typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);\n    }\n\n    // Handle Uint8Array\n    if (typedArray instanceof Uint8Array) {\n      // Shortcut\n      const typedArrayByteLength = typedArray.byteLength;\n\n      // Extract bytes\n      const _words = [];\n      for (let i = 0; i < typedArrayByteLength; i += 1) {\n        _words[i >>> 2] |= typedArray[i] << (24 - (i % 4) * 8);\n      }\n\n      // Initialize this word array\n      this.words = _words;\n      this.sigBytes = typedArrayByteLength;\n    } else {\n      // Else call normal init\n      this.words = words;\n      this.sigBytes = sigBytes;\n    }\n  }\n\n  /**\n   * Creates a word array filled with random bytes.\n   *\n   * @param {number} nBytes The number of random bytes to generate.\n   *\n   * @return {WordArray} The random word array.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var wordArray = CryptoJS.lib.WordArray.random(16);\n   */\n  static random = randomWordArray;\n\n  /**\n   * Converts this word array to a string.\n   *\n   * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex\n   *\n   * @return {string} The stringified word array.\n   *\n   * @example\n   *\n   *     var string = wordArray + '';\n   *     var string = wordArray.toString();\n   *     var string = wordArray.toString(CryptoJS.enc.Utf8);\n   */\n  toString(encoder = Hex) {\n    return encoder.stringify(this);\n  }\n\n  /**\n   * Concatenates a word array to this word array.\n   *\n   * @param {WordArray} wordArray The word array to append.\n   *\n   * @return {WordArray} This word array.\n   *\n   * @example\n   *\n   *     wordArray1.concat(wordArray2);\n   */\n  concat(wordArray) {\n    // Shortcuts\n    const thisWords = this.words;\n    const thatWords = wordArray.words;\n    const thisSigBytes = this.sigBytes;\n    const thatSigBytes = wordArray.sigBytes;\n\n    // Clamp excess bits\n    this.clamp();\n\n    // Concat\n    if (thisSigBytes % 4) {\n      // Copy one byte at a time\n      for (let i = 0; i < thatSigBytes; i += 1) {\n        const thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n        thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);\n      }\n    } else {\n      // Copy one word at a time\n      for (let i = 0; i < thatSigBytes; i += 4) {\n        thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];\n      }\n    }\n    this.sigBytes += thatSigBytes;\n\n    // Chainable\n    return this;\n  }\n\n  /**\n   * Removes insignificant bits.\n   *\n   * @example\n   *\n   *     wordArray.clamp();\n   */\n  clamp() {\n    // Shortcuts\n    const { words, sigBytes } = this;\n\n    // Clamp\n    words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);\n    words.length = Math.ceil(sigBytes / 4);\n  }\n\n  /**\n   * Creates a copy of this word array.\n   *\n   * @return {WordArray} The clone.\n   *\n   * @example\n   *\n   *     var clone = wordArray.clone();\n   */\n  clone() {\n    const clone = super.clone.call(this);\n    clone.words = this.words.slice(0);\n\n    return clone;\n  }\n}\n\n/**\n * Hex encoding strategy.\n */\nexport const Hex = {\n  /**\n   * Converts a word array to a hex string.\n   *\n   * @param {WordArray} wordArray The word array.\n   *\n   * @return {string} The hex string.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);\n   */\n  stringify(wordArray) {\n    // Shortcuts\n    const { words, sigBytes } = wordArray;\n\n    // Convert\n    const hexChars = [];\n    for (let i = 0; i < sigBytes; i += 1) {\n      const bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n      hexChars.push((bite >>> 4).toString(16));\n      hexChars.push((bite & 0x0f).toString(16));\n    }\n\n    return hexChars.join('');\n  },\n\n  /**\n   * Converts a hex string to a word array.\n   *\n   * @param {string} hexStr The hex string.\n   *\n   * @return {WordArray} The word array.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var wordArray = CryptoJS.enc.Hex.parse(hexString);\n   */\n  parse(hexStr) {\n    // Shortcut\n    const hexStrLength = hexStr.length;\n\n    // Convert\n    const words = [];\n    for (let i = 0; i < hexStrLength; i += 2) {\n      words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);\n    }\n\n    return new WordArray(words, hexStrLength / 2);\n  },\n};\n\n/**\n * Latin1 encoding strategy.\n */\nexport const Latin1 = {\n  /**\n   * Converts a word array to a Latin1 string.\n   *\n   * @param {WordArray} wordArray The word array.\n   *\n   * @return {string} The Latin1 string.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);\n   */\n  stringify(wordArray) {\n    // Shortcuts\n    const { words, sigBytes } = wordArray;\n\n    // Convert\n    const latin1Chars = [];\n    for (let i = 0; i < sigBytes; i += 1) {\n      const bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n      latin1Chars.push(String.fromCharCode(bite));\n    }\n\n    return latin1Chars.join('');\n  },\n\n  /**\n   * Converts a Latin1 string to a word array.\n   *\n   * @param {string} latin1Str The Latin1 string.\n   *\n   * @return {WordArray} The word array.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);\n   */\n  parse(latin1Str) {\n    // Shortcut\n    const latin1StrLength = latin1Str.length;\n\n    // Convert\n    const words = [];\n    for (let i = 0; i < latin1StrLength; i += 1) {\n      words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);\n    }\n\n    return new WordArray(words, latin1StrLength);\n  },\n};\n\n/**\n * UTF-8 encoding strategy.\n */\nexport const Utf8 = {\n  /**\n   * Converts a word array to a UTF-8 string.\n   *\n   * @param {WordArray} wordArray The word array.\n   *\n   * @return {string} The UTF-8 string.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);\n   */\n  stringify(wordArray) {\n    try {\n      return decodeURIComponent(escape(Latin1.stringify(wordArray)));\n    } catch (e) {\n      throw new Error('Malformed UTF-8 data');\n    }\n  },\n\n  /**\n   * Converts a UTF-8 string to a word array.\n   *\n   * @param {string} utf8Str The UTF-8 string.\n   *\n   * @return {WordArray} The word array.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);\n   */\n  parse(utf8Str) {\n    return Latin1.parse(unescape(encodeURIComponent(utf8Str)));\n  },\n};\n\n/**\n * Abstract buffered block algorithm template.\n *\n * The property blockSize must be implemented in a concrete subtype.\n *\n * @property {number} _minBufferSize\n *\n *     The number of blocks that should be kept unprocessed in the buffer. Default: 0\n */\nexport class BufferedBlockAlgorithm extends Base {\n  constructor() {\n    super();\n    this._minBufferSize = 0;\n  }\n\n  /**\n   * Resets this block algorithm's data buffer to its initial state.\n   *\n   * @example\n   *\n   *     bufferedBlockAlgorithm.reset();\n   */\n  reset() {\n    // Initial values\n    this._data = new WordArray();\n    this._nDataBytes = 0;\n  }\n\n  /**\n   * Adds new data to this block algorithm's buffer.\n   *\n   * @param {WordArray|string} data\n   *\n   *     The data to append. Strings are converted to a WordArray using UTF-8.\n   *\n   * @example\n   *\n   *     bufferedBlockAlgorithm._append('data');\n   *     bufferedBlockAlgorithm._append(wordArray);\n   */\n  _append(data) {\n    let m_data = data;\n\n    // Convert string to WordArray, else assume WordArray already\n    if (typeof m_data === 'string') {\n      m_data = Utf8.parse(m_data);\n    }\n\n    // Append\n    this._data.concat(m_data);\n    this._nDataBytes += m_data.sigBytes;\n  }\n\n  /**\n   * Processes available data blocks.\n   *\n   * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.\n   *\n   * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.\n   *\n   * @return {WordArray} The processed data.\n   *\n   * @example\n   *\n   *     var processedData = bufferedBlockAlgorithm._process();\n   *     var processedData = bufferedBlockAlgorithm._process(!!'flush');\n   */\n  _process(doFlush) {\n    let processedWords;\n\n    // Shortcuts\n    const { _data: data, blockSize } = this;\n    const dataWords = data.words;\n    const dataSigBytes = data.sigBytes;\n    const blockSizeBytes = blockSize * 4;\n\n    // Count blocks ready\n    let nBlocksReady = dataSigBytes / blockSizeBytes;\n    if (doFlush) {\n      // Round up to include partial blocks\n      nBlocksReady = Math.ceil(nBlocksReady);\n    } else {\n      // Round down to include only full blocks,\n      // less the number of blocks that must remain in the buffer\n      nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);\n    }\n\n    // Count words ready\n    const nWordsReady = nBlocksReady * blockSize;\n\n    // Count bytes ready\n    const nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);\n\n    // Process blocks\n    if (nWordsReady) {\n      for (let offset = 0; offset < nWordsReady; offset += blockSize) {\n        // Perform concrete-algorithm logic\n        this._doProcessBlock(dataWords, offset);\n      }\n\n      // Remove processed words\n      processedWords = dataWords.splice(0, nWordsReady);\n      data.sigBytes -= nBytesReady;\n    }\n\n    // Return processed words\n    return new WordArray(processedWords, nBytesReady);\n  }\n\n  /**\n   * Creates a copy of this object.\n   *\n   * @return {Object} The clone.\n   *\n   * @example\n   *\n   *     var clone = bufferedBlockAlgorithm.clone();\n   */\n  clone() {\n    const clone = super.clone.call(this);\n    clone._data = this._data.clone();\n\n    return clone;\n  }\n}\n\n/**\n * Abstract hasher template.\n *\n * @property {number} blockSize\n *\n *     The number of 32-bit words this hasher operates on. Default: 16 (512 bits)\n */\nexport class Hasher extends BufferedBlockAlgorithm {\n  constructor(cfg) {\n    super();\n\n    this.blockSize = 512 / 32;\n\n    /**\n     * Configuration options.\n     */\n    this.cfg = Object.assign(new Base(), cfg);\n\n    // Set initial values\n    this.reset();\n  }\n\n  /**\n   * Creates a shortcut function to a hasher's object interface.\n   *\n   * @param {Hasher} SubHasher The hasher to create a helper for.\n   *\n   * @return {Function} The shortcut function.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);\n   */\n  static _createHelper(SubHasher) {\n    return (message, cfg) => new SubHasher(cfg).finalize(message);\n  }\n\n  /**\n   * Creates a shortcut function to the HMAC's object interface.\n   *\n   * @param {Hasher} SubHasher The hasher to use in this HMAC helper.\n   *\n   * @return {Function} The shortcut function.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);\n   */\n  static _createHmacHelper(SubHasher) {\n    return (message, key) => new HMAC(SubHasher, key).finalize(message);\n  }\n\n  /**\n   * Resets this hasher to its initial state.\n   *\n   * @example\n   *\n   *     hasher.reset();\n   */\n  reset() {\n    // Reset data buffer\n    super.reset.call(this);\n\n    // Perform concrete-hasher logic\n    this._doReset();\n  }\n\n  /**\n   * Updates this hasher with a message.\n   *\n   * @param {WordArray|string} messageUpdate The message to append.\n   *\n   * @return {Hasher} This hasher.\n   *\n   * @example\n   *\n   *     hasher.update('message');\n   *     hasher.update(wordArray);\n   */\n  update(messageUpdate) {\n    // Append\n    this._append(messageUpdate);\n\n    // Update the hash\n    this._process();\n\n    // Chainable\n    return this;\n  }\n\n  /**\n   * Finalizes the hash computation.\n   * Note that the finalize operation is effectively a destructive, read-once operation.\n   *\n   * @param {WordArray|string} messageUpdate (Optional) A final message update.\n   *\n   * @return {WordArray} The hash.\n   *\n   * @example\n   *\n   *     var hash = hasher.finalize();\n   *     var hash = hasher.finalize('message');\n   *     var hash = hasher.finalize(wordArray);\n   */\n  finalize(messageUpdate) {\n    // Final message update\n    if (messageUpdate) {\n      this._append(messageUpdate);\n    }\n\n    // Perform concrete-hasher logic\n    const hash = this._doFinalize();\n\n    return hash;\n  }\n}\n\n/**\n * HMAC algorithm.\n */\nexport class HMAC extends Base {\n  /**\n   * Initializes a newly created HMAC.\n   *\n   * @param {Hasher} SubHasher The hash algorithm to use.\n   * @param {WordArray|string} key The secret key.\n   *\n   * @example\n   *\n   *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);\n   */\n  constructor(SubHasher, key) {\n    super();\n\n    const hasher = new SubHasher();\n    this._hasher = hasher;\n\n    // Convert string to WordArray, else assume WordArray already\n    let _key = key;\n    if (typeof _key === 'string') {\n      _key = Utf8.parse(_key);\n    }\n\n    // Shortcuts\n    const hasherBlockSize = hasher.blockSize;\n    const hasherBlockSizeBytes = hasherBlockSize * 4;\n\n    // Allow arbitrary length keys\n    if (_key.sigBytes > hasherBlockSizeBytes) {\n      _key = hasher.finalize(key);\n    }\n\n    // Clamp excess bits\n    _key.clamp();\n\n    // Clone key for inner and outer pads\n    const oKey = _key.clone();\n    this._oKey = oKey;\n    const iKey = _key.clone();\n    this._iKey = iKey;\n\n    // Shortcuts\n    const oKeyWords = oKey.words;\n    const iKeyWords = iKey.words;\n\n    // XOR keys with pad constants\n    for (let i = 0; i < hasherBlockSize; i += 1) {\n      oKeyWords[i] ^= 0x5c5c5c5c;\n      iKeyWords[i] ^= 0x36363636;\n    }\n    oKey.sigBytes = hasherBlockSizeBytes;\n    iKey.sigBytes = hasherBlockSizeBytes;\n\n    // Set initial values\n    this.reset();\n  }\n\n  /**\n   * Resets this HMAC to its initial state.\n   *\n   * @example\n   *\n   *     hmacHasher.reset();\n   */\n  reset() {\n    // Shortcut\n    const hasher = this._hasher;\n\n    // Reset\n    hasher.reset();\n    hasher.update(this._iKey);\n  }\n\n  /**\n   * Updates this HMAC with a message.\n   *\n   * @param {WordArray|string} messageUpdate The message to append.\n   *\n   * @return {HMAC} This HMAC instance.\n   *\n   * @example\n   *\n   *     hmacHasher.update('message');\n   *     hmacHasher.update(wordArray);\n   */\n  update(messageUpdate) {\n    this._hasher.update(messageUpdate);\n\n    // Chainable\n    return this;\n  }\n\n  /**\n   * Finalizes the HMAC computation.\n   * Note that the finalize operation is effectively a destructive, read-once operation.\n   *\n   * @param {WordArray|string} messageUpdate (Optional) A final message update.\n   *\n   * @return {WordArray} The HMAC.\n   *\n   * @example\n   *\n   *     var hmac = hmacHasher.finalize();\n   *     var hmac = hmacHasher.finalize('message');\n   *     var hmac = hmacHasher.finalize(wordArray);\n   */\n  finalize(messageUpdate) {\n    // Shortcut\n    const hasher = this._hasher;\n\n    // Compute HMAC\n    const innerHash = hasher.finalize(messageUpdate);\n    hasher.reset();\n    const hmac = hasher.finalize(this._oKey.clone().concat(innerHash));\n\n    return hmac;\n  }\n}\n","import {\n  Base,\n  WordArray,\n} from './core.js';\n\nconst X32WordArray = WordArray;\n\n/**\n * A 64-bit word.\n */\nexport class X64Word extends Base {\n  /**\n   * Initializes a newly created 64-bit word.\n   *\n   * @param {number} high The high 32 bits.\n   * @param {number} low The low 32 bits.\n   *\n   * @example\n   *\n   *     var x64Word = CryptoJS.x64.Word.create(0x00010203, 0x04050607);\n   */\n  constructor(high, low) {\n    super();\n\n    this.high = high;\n    this.low = low;\n  }\n}\n\n/**\n * An array of 64-bit words.\n *\n * @property {Array} words The array of CryptoJS.x64.Word objects.\n * @property {number} sigBytes The number of significant bytes in this word array.\n */\nexport class X64WordArray extends Base {\n  /**\n   * Initializes a newly created word array.\n   *\n   * @param {Array} words (Optional) An array of CryptoJS.x64.Word objects.\n   * @param {number} sigBytes (Optional) The number of significant bytes in the words.\n   *\n   * @example\n   *\n   *     var wordArray = CryptoJS.x64.WordArray.create();\n   *\n   *     var wordArray = CryptoJS.x64.WordArray.create([\n   *         CryptoJS.x64.Word.create(0x00010203, 0x04050607),\n   *         CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)\n   *     ]);\n   *\n   *     var wordArray = CryptoJS.x64.WordArray.create([\n   *         CryptoJS.x64.Word.create(0x00010203, 0x04050607),\n   *         CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)\n   *     ], 10);\n   */\n  constructor(words = [], sigBytes = words.length * 8) {\n    super();\n\n    this.words = words;\n    this.sigBytes = sigBytes;\n  }\n\n  /**\n   * Converts this 64-bit word array to a 32-bit word array.\n   *\n   * @return {CryptoJS.lib.WordArray} This word array's data as a 32-bit word array.\n   *\n   * @example\n   *\n   *     var x32WordArray = x64WordArray.toX32();\n   */\n  toX32() {\n    // Shortcuts\n    const x64Words = this.words;\n    const x64WordsLength = x64Words.length;\n\n    // Convert\n    const x32Words = [];\n    for (let i = 0; i < x64WordsLength; i += 1) {\n      const x64Word = x64Words[i];\n      x32Words.push(x64Word.high);\n      x32Words.push(x64Word.low);\n    }\n\n    return X32WordArray.create(x32Words, this.sigBytes);\n  }\n\n  /**\n   * Creates a copy of this word array.\n   *\n   * @return {X64WordArray} The clone.\n   *\n   * @example\n   *\n   *     var clone = x64WordArray.clone();\n   */\n  clone() {\n    const clone = super.clone.call(this);\n\n    // Clone \"words\" array\n    clone.words = this.words.slice(0);\n    const { words } = clone;\n\n    // Clone each X64Word object\n    const wordsLength = words.length;\n    for (let i = 0; i < wordsLength; i += 1) {\n      words[i] = words[i].clone();\n    }\n\n    return clone;\n  }\n}\n","import {\n  WordArray,\n} from './core.js';\n\nexport const parseLoop = (base64Str, base64StrLength, reverseMap) => {\n  const words = [];\n  let nBytes = 0;\n  for (let i = 0; i < base64StrLength; i += 1) {\n    if (i % 4) {\n      const bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);\n      const bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);\n      const bitsCombined = bits1 | bits2;\n      words[nBytes >>> 2] |= bitsCombined << (24 - (nBytes % 4) * 8);\n      nBytes += 1;\n    }\n  }\n  return WordArray.create(words, nBytes);\n};\n\n/**\n * Base64 encoding strategy.\n */\nexport const Base64 = {\n  /**\n   * Converts a word array to a Base64 string.\n   *\n   * @param {WordArray} wordArray The word array.\n   *\n   * @return {string} The Base64 string.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const base64String = CryptoJS.enc.Base64.stringify(wordArray);\n   */\n  stringify(wordArray) {\n    // Shortcuts\n    const { words, sigBytes } = wordArray;\n    const map = this._map;\n\n    // Clamp excess bits\n    wordArray.clamp();\n\n    // Convert\n    const base64Chars = [];\n    for (let i = 0; i < sigBytes; i += 3) {\n      const byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n      const byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;\n      const byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;\n\n      const triplet = (byte1 << 16) | (byte2 << 8) | byte3;\n\n      for (let j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j += 1) {\n        base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));\n      }\n    }\n\n    // Add padding\n    const paddingChar = map.charAt(64);\n    if (paddingChar) {\n      while (base64Chars.length % 4) {\n        base64Chars.push(paddingChar);\n      }\n    }\n\n    return base64Chars.join('');\n  },\n\n  /**\n   * Converts a Base64 string to a word array.\n   *\n   * @param {string} base64Str The Base64 string.\n   *\n   * @return {WordArray} The word array.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const wordArray = CryptoJS.enc.Base64.parse(base64String);\n   */\n  parse(base64Str) {\n    // Shortcuts\n    let base64StrLength = base64Str.length;\n    const map = this._map;\n    let reverseMap = this._reverseMap;\n\n    if (!reverseMap) {\n      this._reverseMap = [];\n      reverseMap = this._reverseMap;\n      for (let j = 0; j < map.length; j += 1) {\n        reverseMap[map.charCodeAt(j)] = j;\n      }\n    }\n\n    // Ignore padding\n    const paddingChar = map.charAt(64);\n    if (paddingChar) {\n      const paddingIndex = base64Str.indexOf(paddingChar);\n      if (paddingIndex !== -1) {\n        base64StrLength = paddingIndex;\n      }\n    }\n\n    // Convert\n    return parseLoop(base64Str, base64StrLength, reverseMap);\n  },\n\n  _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',\n};\n","import {\n  WordArray,\n  Hasher,\n} from './core.js';\n\n// Constants table\nconst T = [];\n\n// Compute constants\nfor (let i = 0; i < 64; i += 1) {\n  T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;\n}\n\nconst FF = (a, b, c, d, x, s, t) => {\n  const n = a + ((b & c) | (~b & d)) + x + t;\n  return ((n << s) | (n >>> (32 - s))) + b;\n};\n\nconst GG = (a, b, c, d, x, s, t) => {\n  const n = a + ((b & d) | (c & ~d)) + x + t;\n  return ((n << s) | (n >>> (32 - s))) + b;\n};\n\nconst HH = (a, b, c, d, x, s, t) => {\n  const n = a + (b ^ c ^ d) + x + t;\n  return ((n << s) | (n >>> (32 - s))) + b;\n};\n\nconst II = (a, b, c, d, x, s, t) => {\n  const n = a + (c ^ (b | ~d)) + x + t;\n  return ((n << s) | (n >>> (32 - s))) + b;\n};\n\n/**\n * MD5 hash algorithm.\n */\nexport class MD5Algo extends Hasher {\n  _doReset() {\n    this._hash = new WordArray([\n      0x67452301,\n      0xefcdab89,\n      0x98badcfe,\n      0x10325476,\n    ]);\n  }\n\n  _doProcessBlock(M, offset) {\n    const _M = M;\n\n    // Swap endian\n    for (let i = 0; i < 16; i += 1) {\n      // Shortcuts\n      const offset_i = offset + i;\n      const M_offset_i = M[offset_i];\n\n      _M[offset_i] = (\n        (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff)\n          | (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)\n      );\n    }\n\n    // Shortcuts\n    const H = this._hash.words;\n\n    const M_offset_0 = _M[offset + 0];\n    const M_offset_1 = _M[offset + 1];\n    const M_offset_2 = _M[offset + 2];\n    const M_offset_3 = _M[offset + 3];\n    const M_offset_4 = _M[offset + 4];\n    const M_offset_5 = _M[offset + 5];\n    const M_offset_6 = _M[offset + 6];\n    const M_offset_7 = _M[offset + 7];\n    const M_offset_8 = _M[offset + 8];\n    const M_offset_9 = _M[offset + 9];\n    const M_offset_10 = _M[offset + 10];\n    const M_offset_11 = _M[offset + 11];\n    const M_offset_12 = _M[offset + 12];\n    const M_offset_13 = _M[offset + 13];\n    const M_offset_14 = _M[offset + 14];\n    const M_offset_15 = _M[offset + 15];\n\n    // Working varialbes\n    let a = H[0];\n    let b = H[1];\n    let c = H[2];\n    let d = H[3];\n\n    // Computation\n    a = FF(a, b, c, d, M_offset_0, 7, T[0]);\n    d = FF(d, a, b, c, M_offset_1, 12, T[1]);\n    c = FF(c, d, a, b, M_offset_2, 17, T[2]);\n    b = FF(b, c, d, a, M_offset_3, 22, T[3]);\n    a = FF(a, b, c, d, M_offset_4, 7, T[4]);\n    d = FF(d, a, b, c, M_offset_5, 12, T[5]);\n    c = FF(c, d, a, b, M_offset_6, 17, T[6]);\n    b = FF(b, c, d, a, M_offset_7, 22, T[7]);\n    a = FF(a, b, c, d, M_offset_8, 7, T[8]);\n    d = FF(d, a, b, c, M_offset_9, 12, T[9]);\n    c = FF(c, d, a, b, M_offset_10, 17, T[10]);\n    b = FF(b, c, d, a, M_offset_11, 22, T[11]);\n    a = FF(a, b, c, d, M_offset_12, 7, T[12]);\n    d = FF(d, a, b, c, M_offset_13, 12, T[13]);\n    c = FF(c, d, a, b, M_offset_14, 17, T[14]);\n    b = FF(b, c, d, a, M_offset_15, 22, T[15]);\n\n    a = GG(a, b, c, d, M_offset_1, 5, T[16]);\n    d = GG(d, a, b, c, M_offset_6, 9, T[17]);\n    c = GG(c, d, a, b, M_offset_11, 14, T[18]);\n    b = GG(b, c, d, a, M_offset_0, 20, T[19]);\n    a = GG(a, b, c, d, M_offset_5, 5, T[20]);\n    d = GG(d, a, b, c, M_offset_10, 9, T[21]);\n    c = GG(c, d, a, b, M_offset_15, 14, T[22]);\n    b = GG(b, c, d, a, M_offset_4, 20, T[23]);\n    a = GG(a, b, c, d, M_offset_9, 5, T[24]);\n    d = GG(d, a, b, c, M_offset_14, 9, T[25]);\n    c = GG(c, d, a, b, M_offset_3, 14, T[26]);\n    b = GG(b, c, d, a, M_offset_8, 20, T[27]);\n    a = GG(a, b, c, d, M_offset_13, 5, T[28]);\n    d = GG(d, a, b, c, M_offset_2, 9, T[29]);\n    c = GG(c, d, a, b, M_offset_7, 14, T[30]);\n    b = GG(b, c, d, a, M_offset_12, 20, T[31]);\n\n    a = HH(a, b, c, d, M_offset_5, 4, T[32]);\n    d = HH(d, a, b, c, M_offset_8, 11, T[33]);\n    c = HH(c, d, a, b, M_offset_11, 16, T[34]);\n    b = HH(b, c, d, a, M_offset_14, 23, T[35]);\n    a = HH(a, b, c, d, M_offset_1, 4, T[36]);\n    d = HH(d, a, b, c, M_offset_4, 11, T[37]);\n    c = HH(c, d, a, b, M_offset_7, 16, T[38]);\n    b = HH(b, c, d, a, M_offset_10, 23, T[39]);\n    a = HH(a, b, c, d, M_offset_13, 4, T[40]);\n    d = HH(d, a, b, c, M_offset_0, 11, T[41]);\n    c = HH(c, d, a, b, M_offset_3, 16, T[42]);\n    b = HH(b, c, d, a, M_offset_6, 23, T[43]);\n    a = HH(a, b, c, d, M_offset_9, 4, T[44]);\n    d = HH(d, a, b, c, M_offset_12, 11, T[45]);\n    c = HH(c, d, a, b, M_offset_15, 16, T[46]);\n    b = HH(b, c, d, a, M_offset_2, 23, T[47]);\n\n    a = II(a, b, c, d, M_offset_0, 6, T[48]);\n    d = II(d, a, b, c, M_offset_7, 10, T[49]);\n    c = II(c, d, a, b, M_offset_14, 15, T[50]);\n    b = II(b, c, d, a, M_offset_5, 21, T[51]);\n    a = II(a, b, c, d, M_offset_12, 6, T[52]);\n    d = II(d, a, b, c, M_offset_3, 10, T[53]);\n    c = II(c, d, a, b, M_offset_10, 15, T[54]);\n    b = II(b, c, d, a, M_offset_1, 21, T[55]);\n    a = II(a, b, c, d, M_offset_8, 6, T[56]);\n    d = II(d, a, b, c, M_offset_15, 10, T[57]);\n    c = II(c, d, a, b, M_offset_6, 15, T[58]);\n    b = II(b, c, d, a, M_offset_13, 21, T[59]);\n    a = II(a, b, c, d, M_offset_4, 6, T[60]);\n    d = II(d, a, b, c, M_offset_11, 10, T[61]);\n    c = II(c, d, a, b, M_offset_2, 15, T[62]);\n    b = II(b, c, d, a, M_offset_9, 21, T[63]);\n\n    // Intermediate hash value\n    H[0] = (H[0] + a) | 0;\n    H[1] = (H[1] + b) | 0;\n    H[2] = (H[2] + c) | 0;\n    H[3] = (H[3] + d) | 0;\n  }\n  /* eslint-ensable no-param-reassign */\n\n  _doFinalize() {\n    // Shortcuts\n    const data = this._data;\n    const dataWords = data.words;\n\n    const nBitsTotal = this._nDataBytes * 8;\n    const nBitsLeft = data.sigBytes * 8;\n\n    // Add padding\n    dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - (nBitsLeft % 32));\n\n    const nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);\n    const nBitsTotalL = nBitsTotal;\n    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (\n      (((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff)\n        | (((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00)\n    );\n    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (\n      (((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff)\n        | (((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00)\n    );\n\n    data.sigBytes = (dataWords.length + 1) * 4;\n\n    // Hash final blocks\n    this._process();\n\n    // Shortcuts\n    const hash = this._hash;\n    const H = hash.words;\n\n    // Swap endian\n    for (let i = 0; i < 4; i += 1) {\n      // Shortcut\n      const H_i = H[i];\n\n      H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff)\n        | (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);\n    }\n\n    // Return final computed hash\n    return hash;\n  }\n\n  clone() {\n    const clone = super.clone.call(this);\n    clone._hash = this._hash.clone();\n\n    return clone;\n  }\n}\n\n/**\n * Shortcut function to the hasher's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n *\n * @return {WordArray} The hash.\n *\n * @static\n *\n * @example\n *\n *     var hash = CryptoJS.MD5('message');\n *     var hash = CryptoJS.MD5(wordArray);\n */\nexport const MD5 = Hasher._createHelper(MD5Algo);\n\n/**\n * Shortcut function to the HMAC's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n * @param {WordArray|string} key The secret key.\n *\n * @return {WordArray} The HMAC.\n *\n * @static\n *\n * @example\n *\n *     var hmac = CryptoJS.HmacMD5(message, key);\n */\nexport const HmacMD5 = Hasher._createHmacHelper(MD5Algo);\n","import {\n  Base,\n  WordArray,\n} from './core.js';\nimport { MD5Algo } from './md5.js';\n\n/**\n * This key derivation function is meant to conform with EVP_BytesToKey.\n * www.openssl.org/docs/crypto/EVP_BytesToKey.html\n */\nexport class EvpKDFAlgo extends Base {\n  /**\n   * Initializes a newly created key derivation function.\n   *\n   * @param {Object} cfg (Optional) The configuration options to use for the derivation.\n   *\n   * @example\n   *\n   *     const kdf = CryptoJS.algo.EvpKDF.create();\n   *     const kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });\n   *     const kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });\n   */\n  constructor(cfg) {\n    super();\n\n    /**\n     * Configuration options.\n     *\n     * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)\n     * @property {Hasher} hasher The hash algorithm to use. Default: MD5\n     * @property {number} iterations The number of iterations to perform. Default: 1\n     */\n    this.cfg = Object.assign(\n      new Base(),\n      {\n        keySize: 128 / 32,\n        hasher: MD5Algo,\n        iterations: 1,\n      },\n      cfg,\n    );\n  }\n\n  /**\n   * Derives a key from a password.\n   *\n   * @param {WordArray|string} password The password.\n   * @param {WordArray|string} salt A salt.\n   *\n   * @return {WordArray} The derived key.\n   *\n   * @example\n   *\n   *     const key = kdf.compute(password, salt);\n   */\n  compute(password, salt) {\n    let block;\n\n    // Shortcut\n    const { cfg } = this;\n\n    // Init hasher\n    const hasher = cfg.hasher.create();\n\n    // Initial values\n    const derivedKey = WordArray.create();\n\n    // Shortcuts\n    const derivedKeyWords = derivedKey.words;\n    const { keySize, iterations } = cfg;\n\n    // Generate key\n    while (derivedKeyWords.length < keySize) {\n      if (block) {\n        hasher.update(block);\n      }\n      block = hasher.update(password).finalize(salt);\n      hasher.reset();\n\n      // Iterations\n      for (let i = 1; i < iterations; i += 1) {\n        block = hasher.finalize(block);\n        hasher.reset();\n      }\n\n      derivedKey.concat(block);\n    }\n    derivedKey.sigBytes = keySize * 4;\n\n    return derivedKey;\n  }\n}\n\n/**\n * Derives a key from a password.\n *\n * @param {WordArray|string} password The password.\n * @param {WordArray|string} salt A salt.\n * @param {Object} cfg (Optional) The configuration options to use for this computation.\n *\n * @return {WordArray} The derived key.\n *\n * @static\n *\n * @example\n *\n *     var key = CryptoJS.EvpKDF(password, salt);\n *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });\n *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });\n */\nexport const EvpKDF = (password, salt, cfg) => EvpKDFAlgo.create(cfg).compute(password, salt);\n","/* eslint-disable no-use-before-define */\n\nimport {\n  Base,\n  WordArray,\n  BufferedBlockAlgorithm,\n} from './core.js';\nimport { Base64 } from './enc-base64.js';\nimport { EvpKDFAlgo } from './evpkdf.js';\n\n/**\n * Abstract base cipher template.\n *\n * @property {number} keySize This cipher's key size. Default: 4 (128 bits)\n * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)\n * @property {number} _ENC_XFORM_MODE A constant representing encryption mode.\n * @property {number} _DEC_XFORM_MODE A constant representing decryption mode.\n */\nexport class Cipher extends BufferedBlockAlgorithm {\n  /**\n   * Initializes a newly created cipher.\n   *\n   * @param {number} xformMode Either the encryption or decryption transormation mode constant.\n   * @param {WordArray} key The key.\n   * @param {Object} cfg (Optional) The configuration options to use for this operation.\n   *\n   * @example\n   *\n   *     const cipher = CryptoJS.algo.AES.create(\n   *       CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray }\n   *     );\n   */\n  constructor(xformMode, key, cfg) {\n    super();\n\n    /**\n     * Configuration options.\n     *\n     * @property {WordArray} iv The IV to use for this operation.\n     */\n    this.cfg = Object.assign(new Base(), cfg);\n\n    // Store transform mode and key\n    this._xformMode = xformMode;\n    this._key = key;\n\n    // Set initial values\n    this.reset();\n  }\n\n  /**\n   * Creates this cipher in encryption mode.\n   *\n   * @param {WordArray} key The key.\n   * @param {Object} cfg (Optional) The configuration options to use for this operation.\n   *\n   * @return {Cipher} A cipher instance.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });\n   */\n  static createEncryptor(key, cfg) {\n    return this.create(this._ENC_XFORM_MODE, key, cfg);\n  }\n\n  /**\n   * Creates this cipher in decryption mode.\n   *\n   * @param {WordArray} key The key.\n   * @param {Object} cfg (Optional) The configuration options to use for this operation.\n   *\n   * @return {Cipher} A cipher instance.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });\n   */\n  static createDecryptor(key, cfg) {\n    return this.create(this._DEC_XFORM_MODE, key, cfg);\n  }\n\n  /**\n   * Creates shortcut functions to a cipher's object interface.\n   *\n   * @param {Cipher} cipher The cipher to create a helper for.\n   *\n   * @return {Object} An object with encrypt and decrypt shortcut functions.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);\n   */\n  static _createHelper(SubCipher) {\n    const selectCipherStrategy = (key) => {\n      if (typeof key === 'string') {\n        return PasswordBasedCipher;\n      }\n      return SerializableCipher;\n    };\n\n    return {\n      encrypt(message, key, cfg) {\n        return selectCipherStrategy(key).encrypt(SubCipher, message, key, cfg);\n      },\n\n      decrypt(ciphertext, key, cfg) {\n        return selectCipherStrategy(key).decrypt(SubCipher, ciphertext, key, cfg);\n      },\n    };\n  }\n\n  /**\n   * Resets this cipher to its initial state.\n   *\n   * @example\n   *\n   *     cipher.reset();\n   */\n  reset() {\n    // Reset data buffer\n    super.reset.call(this);\n\n    // Perform concrete-cipher logic\n    this._doReset();\n  }\n\n  /**\n   * Adds data to be encrypted or decrypted.\n   *\n   * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.\n   *\n   * @return {WordArray} The data after processing.\n   *\n   * @example\n   *\n   *     const encrypted = cipher.process('data');\n   *     const encrypted = cipher.process(wordArray);\n   */\n  process(dataUpdate) {\n    // Append\n    this._append(dataUpdate);\n\n    // Process available blocks\n    return this._process();\n  }\n\n  /**\n   * Finalizes the encryption or decryption process.\n   * Note that the finalize operation is effectively a destructive, read-once operation.\n   *\n   * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.\n   *\n   * @return {WordArray} The data after final processing.\n   *\n   * @example\n   *\n   *     const encrypted = cipher.finalize();\n   *     const encrypted = cipher.finalize('data');\n   *     const encrypted = cipher.finalize(wordArray);\n   */\n  finalize(dataUpdate) {\n    // Final data update\n    if (dataUpdate) {\n      this._append(dataUpdate);\n    }\n\n    // Perform concrete-cipher logic\n    const finalProcessedData = this._doFinalize();\n\n    return finalProcessedData;\n  }\n}\nCipher._ENC_XFORM_MODE = 1;\nCipher._DEC_XFORM_MODE = 2;\nCipher.keySize = 128 / 32;\nCipher.ivSize = 128 / 32;\n\n/**\n * Abstract base stream cipher template.\n *\n * @property {number} blockSize\n *\n *     The number of 32-bit words this cipher operates on. Default: 1 (32 bits)\n */\nexport class StreamCipher extends Cipher {\n  constructor(...args) {\n    super(...args);\n\n    this.blockSize = 1;\n  }\n\n  _doFinalize() {\n    // Process partial blocks\n    const finalProcessedBlocks = this._process(!!'flush');\n\n    return finalProcessedBlocks;\n  }\n}\n\n/**\n * Abstract base block cipher mode template.\n */\nexport class BlockCipherMode extends Base {\n  /**\n   * Initializes a newly created mode.\n   *\n   * @param {Cipher} cipher A block cipher instance.\n   * @param {Array} iv The IV words.\n   *\n   * @example\n   *\n   *     const mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);\n   */\n  constructor(cipher, iv) {\n    super();\n\n    this._cipher = cipher;\n    this._iv = iv;\n  }\n\n  /**\n   * Creates this mode for encryption.\n   *\n   * @param {Cipher} cipher A block cipher instance.\n   * @param {Array} iv The IV words.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);\n   */\n  static createEncryptor(cipher, iv) {\n    return this.Encryptor.create(cipher, iv);\n  }\n\n  /**\n   * Creates this mode for decryption.\n   *\n   * @param {Cipher} cipher A block cipher instance.\n   * @param {Array} iv The IV words.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);\n   */\n  static createDecryptor(cipher, iv) {\n    return this.Decryptor.create(cipher, iv);\n  }\n}\n\nfunction xorBlock(words, offset, blockSize) {\n  const _words = words;\n  let block;\n\n  // Shortcut\n  const iv = this._iv;\n\n  // Choose mixing block\n  if (iv) {\n    block = iv;\n\n    // Remove IV for subsequent blocks\n    this._iv = undefined;\n  } else {\n    block = this._prevBlock;\n  }\n\n  // XOR blocks\n  for (let i = 0; i < blockSize; i += 1) {\n    _words[offset + i] ^= block[i];\n  }\n}\n\n/**\n * Cipher Block Chaining mode.\n */\n\n/**\n * Abstract base CBC mode.\n */\nexport class CBC extends BlockCipherMode {\n}\n/**\n * CBC encryptor.\n */\nCBC.Encryptor = class extends CBC {\n  /**\n   * Processes the data block at offset.\n   *\n   * @param {Array} words The data words to operate on.\n   * @param {number} offset The offset where the block starts.\n   *\n   * @example\n   *\n   *     mode.processBlock(data.words, offset);\n   */\n  processBlock(words, offset) {\n    // Shortcuts\n    const cipher = this._cipher;\n    const { blockSize } = cipher;\n\n    // XOR and encrypt\n    xorBlock.call(this, words, offset, blockSize);\n    cipher.encryptBlock(words, offset);\n\n    // Remember this block to use with next block\n    this._prevBlock = words.slice(offset, offset + blockSize);\n  }\n};\n/**\n * CBC decryptor.\n */\nCBC.Decryptor = class extends CBC {\n  /**\n   * Processes the data block at offset.\n   *\n   * @param {Array} words The data words to operate on.\n   * @param {number} offset The offset where the block starts.\n   *\n   * @example\n   *\n   *     mode.processBlock(data.words, offset);\n   */\n  processBlock(words, offset) {\n    // Shortcuts\n    const cipher = this._cipher;\n    const { blockSize } = cipher;\n\n    // Remember this block to use with next block\n    const thisBlock = words.slice(offset, offset + blockSize);\n\n    // Decrypt and XOR\n    cipher.decryptBlock(words, offset);\n    xorBlock.call(this, words, offset, blockSize);\n\n    // This block becomes the previous block\n    this._prevBlock = thisBlock;\n  }\n};\n\n/**\n * PKCS #5/7 padding strategy.\n */\nexport const Pkcs7 = {\n  /**\n   * Pads data using the algorithm defined in PKCS #5/7.\n   *\n   * @param {WordArray} data The data to pad.\n   * @param {number} blockSize The multiple that the data should be padded to.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     CryptoJS.pad.Pkcs7.pad(wordArray, 4);\n   */\n  pad(data, blockSize) {\n    // Shortcut\n    const blockSizeBytes = blockSize * 4;\n\n    // Count padding bytes\n    const nPaddingBytes = blockSizeBytes - (data.sigBytes % blockSizeBytes);\n\n    // Create padding word\n    const paddingWord = (nPaddingBytes << 24)\n      | (nPaddingBytes << 16)\n      | (nPaddingBytes << 8)\n      | nPaddingBytes;\n\n    // Create padding\n    const paddingWords = [];\n    for (let i = 0; i < nPaddingBytes; i += 4) {\n      paddingWords.push(paddingWord);\n    }\n    const padding = WordArray.create(paddingWords, nPaddingBytes);\n\n    // Add padding\n    data.concat(padding);\n  },\n\n  /**\n   * Unpads data that had been padded using the algorithm defined in PKCS #5/7.\n   *\n   * @param {WordArray} data The data to unpad.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     CryptoJS.pad.Pkcs7.unpad(wordArray);\n   */\n  unpad(data) {\n    const _data = data;\n\n    // Get number of padding bytes from last byte\n    const nPaddingBytes = _data.words[(_data.sigBytes - 1) >>> 2] & 0xff;\n\n    // Remove padding\n    _data.sigBytes -= nPaddingBytes;\n  },\n};\n\n/**\n * Abstract base block cipher template.\n *\n * @property {number} blockSize\n *\n *    The number of 32-bit words this cipher operates on. Default: 4 (128 bits)\n */\nexport class BlockCipher extends Cipher {\n  constructor(xformMode, key, cfg) {\n    /**\n     * Configuration options.\n     *\n     * @property {Mode} mode The block mode to use. Default: CBC\n     * @property {Padding} padding The padding strategy to use. Default: Pkcs7\n     */\n    super(xformMode, key, Object.assign(\n      {\n        mode: CBC,\n        padding: Pkcs7,\n      },\n      cfg,\n    ));\n\n    this.blockSize = 128 / 32;\n  }\n\n  reset() {\n    let modeCreator;\n\n    // Reset cipher\n    super.reset.call(this);\n\n    // Shortcuts\n    const { cfg } = this;\n    const { iv, mode } = cfg;\n\n    // Reset block mode\n    if (this._xformMode === this.constructor._ENC_XFORM_MODE) {\n      modeCreator = mode.createEncryptor;\n    } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {\n      modeCreator = mode.createDecryptor;\n      // Keep at least one block in the buffer for unpadding\n      this._minBufferSize = 1;\n    }\n\n    this._mode = modeCreator.call(mode, this, iv && iv.words);\n    this._mode.__creator = modeCreator;\n  }\n\n  _doProcessBlock(words, offset) {\n    this._mode.processBlock(words, offset);\n  }\n\n  _doFinalize() {\n    let finalProcessedBlocks;\n\n    // Shortcut\n    const { padding } = this.cfg;\n\n    // Finalize\n    if (this._xformMode === this.constructor._ENC_XFORM_MODE) {\n      // Pad data\n      padding.pad(this._data, this.blockSize);\n\n      // Process final blocks\n      finalProcessedBlocks = this._process(!!'flush');\n    } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {\n      // Process final blocks\n      finalProcessedBlocks = this._process(!!'flush');\n\n      // Unpad data\n      padding.unpad(finalProcessedBlocks);\n    }\n\n    return finalProcessedBlocks;\n  }\n}\n\n/**\n * A collection of cipher parameters.\n *\n * @property {WordArray} ciphertext The raw ciphertext.\n * @property {WordArray} key The key to this ciphertext.\n * @property {WordArray} iv The IV used in the ciphering operation.\n * @property {WordArray} salt The salt used with a key derivation function.\n * @property {Cipher} algorithm The cipher algorithm.\n * @property {Mode} mode The block mode used in the ciphering operation.\n * @property {Padding} padding The padding scheme used in the ciphering operation.\n * @property {number} blockSize The block size of the cipher.\n * @property {Format} formatter\n *    The default formatting strategy to convert this cipher params object to a string.\n */\nexport class CipherParams extends Base {\n  /**\n   * Initializes a newly created cipher params object.\n   *\n   * @param {Object} cipherParams An object with any of the possible cipher parameters.\n   *\n   * @example\n   *\n   *     var cipherParams = CryptoJS.lib.CipherParams.create({\n   *         ciphertext: ciphertextWordArray,\n   *         key: keyWordArray,\n   *         iv: ivWordArray,\n   *         salt: saltWordArray,\n   *         algorithm: CryptoJS.algo.AES,\n   *         mode: CryptoJS.mode.CBC,\n   *         padding: CryptoJS.pad.PKCS7,\n   *         blockSize: 4,\n   *         formatter: CryptoJS.format.OpenSSL\n   *     });\n   */\n  constructor(cipherParams) {\n    super();\n\n    this.mixIn(cipherParams);\n  }\n\n  /**\n   * Converts this cipher params object to a string.\n   *\n   * @param {Format} formatter (Optional) The formatting strategy to use.\n   *\n   * @return {string} The stringified cipher params.\n   *\n   * @throws Error If neither the formatter nor the default formatter is set.\n   *\n   * @example\n   *\n   *     var string = cipherParams + '';\n   *     var string = cipherParams.toString();\n   *     var string = cipherParams.toString(CryptoJS.format.OpenSSL);\n   */\n  toString(formatter) {\n    return (formatter || this.formatter).stringify(this);\n  }\n}\n\n/**\n * OpenSSL formatting strategy.\n */\nexport const OpenSSLFormatter = {\n  /**\n   * Converts a cipher params object to an OpenSSL-compatible string.\n   *\n   * @param {CipherParams} cipherParams The cipher params object.\n   *\n   * @return {string} The OpenSSL-compatible string.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);\n   */\n  stringify(cipherParams) {\n    let wordArray;\n\n    // Shortcuts\n    const { ciphertext, salt } = cipherParams;\n\n    // Format\n    if (salt) {\n      wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);\n    } else {\n      wordArray = ciphertext;\n    }\n\n    return wordArray.toString(Base64);\n  },\n\n  /**\n   * Converts an OpenSSL-compatible string to a cipher params object.\n   *\n   * @param {string} openSSLStr The OpenSSL-compatible string.\n   *\n   * @return {CipherParams} The cipher params object.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);\n   */\n  parse(openSSLStr) {\n    let salt;\n\n    // Parse base64\n    const ciphertext = Base64.parse(openSSLStr);\n\n    // Shortcut\n    const ciphertextWords = ciphertext.words;\n\n    // Test for salt\n    if (ciphertextWords[0] === 0x53616c74 && ciphertextWords[1] === 0x65645f5f) {\n      // Extract salt\n      salt = WordArray.create(ciphertextWords.slice(2, 4));\n\n      // Remove salt from ciphertext\n      ciphertextWords.splice(0, 4);\n      ciphertext.sigBytes -= 16;\n    }\n\n    return CipherParams.create({ ciphertext, salt });\n  },\n};\n\n/**\n * A cipher wrapper that returns ciphertext as a serializable cipher params object.\n */\nexport class SerializableCipher extends Base {\n  /**\n   * Encrypts a message.\n   *\n   * @param {Cipher} cipher The cipher algorithm to use.\n   * @param {WordArray|string} message The message to encrypt.\n   * @param {WordArray} key The key.\n   * @param {Object} cfg (Optional) The configuration options to use for this operation.\n   *\n   * @return {CipherParams} A cipher params object.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var ciphertextParams = CryptoJS.lib.SerializableCipher\n   *       .encrypt(CryptoJS.algo.AES, message, key);\n   *     var ciphertextParams = CryptoJS.lib.SerializableCipher\n   *       .encrypt(CryptoJS.algo.AES, message, key, { iv: iv });\n   *     var ciphertextParams = CryptoJS.lib.SerializableCipher\n   *       .encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });\n   */\n  static encrypt(cipher, message, key, cfg) {\n    // Apply config defaults\n    const _cfg = Object.assign(new Base(), this.cfg, cfg);\n\n    // Encrypt\n    const encryptor = cipher.createEncryptor(key, _cfg);\n    const ciphertext = encryptor.finalize(message);\n\n    // Shortcut\n    const cipherCfg = encryptor.cfg;\n\n    // Create and return serializable cipher params\n    return CipherParams.create({\n      ciphertext,\n      key,\n      iv: cipherCfg.iv,\n      algorithm: cipher,\n      mode: cipherCfg.mode,\n      padding: cipherCfg.padding,\n      blockSize: encryptor.blockSize,\n      formatter: _cfg.format,\n    });\n  }\n\n  /**\n   * Decrypts serialized ciphertext.\n   *\n   * @param {Cipher} cipher The cipher algorithm to use.\n   * @param {CipherParams|string} ciphertext The ciphertext to decrypt.\n   * @param {WordArray} key The key.\n   * @param {Object} cfg (Optional) The configuration options to use for this operation.\n   *\n   * @return {WordArray} The plaintext.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var plaintext = CryptoJS.lib.SerializableCipher\n   *       .decrypt(CryptoJS.algo.AES, formattedCiphertext, key,\n   *         { iv: iv, format: CryptoJS.format.OpenSSL });\n   *     var plaintext = CryptoJS.lib.SerializableCipher\n   *       .decrypt(CryptoJS.algo.AES, ciphertextParams, key,\n   *         { iv: iv, format: CryptoJS.format.OpenSSL });\n   */\n  static decrypt(cipher, ciphertext, key, cfg) {\n    let _ciphertext = ciphertext;\n\n    // Apply config defaults\n    const _cfg = Object.assign(new Base(), this.cfg, cfg);\n\n    // Convert string to CipherParams\n    _ciphertext = this._parse(_ciphertext, _cfg.format);\n\n    // Decrypt\n    const plaintext = cipher.createDecryptor(key, _cfg).finalize(_ciphertext.ciphertext);\n\n    return plaintext;\n  }\n\n  /**\n   * Converts serialized ciphertext to CipherParams,\n   * else assumed CipherParams already and returns ciphertext unchanged.\n   *\n   * @param {CipherParams|string} ciphertext The ciphertext.\n   * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.\n   *\n   * @return {CipherParams} The unserialized ciphertext.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var ciphertextParams = CryptoJS.lib.SerializableCipher\n   *       ._parse(ciphertextStringOrParams, format);\n   */\n  static _parse(ciphertext, format) {\n    if (typeof ciphertext === 'string') {\n      return format.parse(ciphertext, this);\n    }\n    return ciphertext;\n  }\n}\n/**\n * Configuration options.\n *\n * @property {Formatter} format\n *\n *    The formatting strategy to convert cipher param objects to and from a string.\n *    Default: OpenSSL\n */\nSerializableCipher.cfg = Object.assign(\n  new Base(),\n  { format: OpenSSLFormatter },\n);\n\n/**\n * OpenSSL key derivation function.\n */\nexport const OpenSSLKdf = {\n  /**\n   * Derives a key and IV from a password.\n   *\n   * @param {string} password The password to derive from.\n   * @param {number} keySize The size in words of the key to generate.\n   * @param {number} ivSize The size in words of the IV to generate.\n   * @param {WordArray|string} salt\n   *     (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.\n   *\n   * @return {CipherParams} A cipher params object with the key, IV, and salt.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);\n   *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');\n   */\n  execute(password, keySize, ivSize, salt, hasher) {\n    let _salt = salt;\n\n    // Generate random salt\n    if (!_salt) {\n      _salt = WordArray.random(64 / 8);\n    }\n\n    // Derive key and IV\n    let key;\n    if (!hasher) {\n      key = EvpKDFAlgo.create({ keySize: keySize + ivSize }).compute(password, _salt);\n    } else {\n      key = EvpKDFAlgo.create({ keySize: keySize + ivSize, hasher }).compute(password, _salt);\n    }\n\n    // Separate key and IV\n    const iv = WordArray.create(key.words.slice(keySize), ivSize * 4);\n    key.sigBytes = keySize * 4;\n\n    // Return params\n    return CipherParams.create({ key, iv, salt: _salt });\n  },\n};\n\n/**\n * A serializable cipher wrapper that derives the key from a password,\n * and returns ciphertext as a serializable cipher params object.\n */\nexport class PasswordBasedCipher extends SerializableCipher {\n  /**\n   * Encrypts a message using a password.\n   *\n   * @param {Cipher} cipher The cipher algorithm to use.\n   * @param {WordArray|string} message The message to encrypt.\n   * @param {string} password The password.\n   * @param {Object} cfg (Optional) The configuration options to use for this operation.\n   *\n   * @return {CipherParams} A cipher params object.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher\n   *       .encrypt(CryptoJS.algo.AES, message, 'password');\n   *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher\n   *       .encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });\n   */\n  static encrypt(cipher, message, password, cfg) {\n    // Apply config defaults\n    const _cfg = Object.assign(new Base(), this.cfg, cfg);\n\n    // Derive key and other params\n    const derivedParams = _cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, _cfg.salt, _cfg.hasher);\n\n    // Add IV to config\n    _cfg.iv = derivedParams.iv;\n\n    // Encrypt\n    const ciphertext = SerializableCipher.encrypt\n      .call(this, cipher, message, derivedParams.key, _cfg);\n\n    // Mix in derived params\n    ciphertext.mixIn(derivedParams);\n\n    return ciphertext;\n  }\n\n  /**\n   * Decrypts serialized ciphertext using a password.\n   *\n   * @param {Cipher} cipher The cipher algorithm to use.\n   * @param {CipherParams|string} ciphertext The ciphertext to decrypt.\n   * @param {string} password The password.\n   * @param {Object} cfg (Optional) The configuration options to use for this operation.\n   *\n   * @return {WordArray} The plaintext.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var plaintext = CryptoJS.lib.PasswordBasedCipher\n   *       .decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password',\n   *         { format: CryptoJS.format.OpenSSL });\n   *     var plaintext = CryptoJS.lib.PasswordBasedCipher\n   *       .decrypt(CryptoJS.algo.AES, ciphertextParams, 'password',\n   *         { format: CryptoJS.format.OpenSSL });\n   */\n  static decrypt(cipher, ciphertext, password, cfg) {\n    let _ciphertext = ciphertext;\n\n    // Apply config defaults\n    const _cfg = Object.assign(new Base(), this.cfg, cfg);\n\n    // Convert string to CipherParams\n    _ciphertext = this._parse(_ciphertext, _cfg.format);\n\n    // Derive key and other params\n    const derivedParams = _cfg.kdf\n      .execute(password, cipher.keySize, cipher.ivSize, _ciphertext.salt, _cfg.hasher);\n\n    // Add IV to config\n    _cfg.iv = derivedParams.iv;\n\n    // Decrypt\n    const plaintext = SerializableCipher.decrypt\n      .call(this, cipher, _ciphertext, derivedParams.key, _cfg);\n\n    return plaintext;\n  }\n}\n/**\n * Configuration options.\n *\n * @property {KDF} kdf\n *     The key derivation function to use to generate a key and IV from a password.\n *     Default: OpenSSL\n */\nPasswordBasedCipher.cfg = Object.assign(SerializableCipher.cfg, { kdf: OpenSSLKdf });\n","import {\n  WordArray,\n} from './core.js';\n\nconst swapEndian = word => ((word << 8) & 0xff00ff00) | ((word >>> 8) & 0x00ff00ff);\n\n/**\n * UTF-16 BE encoding strategy.\n */\nexport const Utf16BE = {\n  /**\n   * Converts a word array to a UTF-16 BE string.\n   *\n   * @param {WordArray} wordArray The word array.\n   *\n   * @return {string} The UTF-16 BE string.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const utf16String = CryptoJS.enc.Utf16.stringify(wordArray);\n   */\n  stringify(wordArray) {\n    // Shortcuts\n    const { words, sigBytes } = wordArray;\n\n    // Convert\n    const utf16Chars = [];\n    for (let i = 0; i < sigBytes; i += 2) {\n      const codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff;\n      utf16Chars.push(String.fromCharCode(codePoint));\n    }\n\n    return utf16Chars.join('');\n  },\n\n  /**\n   * Converts a UTF-16 BE string to a word array.\n   *\n   * @param {string} utf16Str The UTF-16 BE string.\n   *\n   * @return {WordArray} The word array.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const wordArray = CryptoJS.enc.Utf16.parse(utf16String);\n   */\n  parse(utf16Str) {\n    // Shortcut\n    const utf16StrLength = utf16Str.length;\n\n    // Convert\n    const words = [];\n    for (let i = 0; i < utf16StrLength; i += 1) {\n      words[i >>> 1] |= utf16Str.charCodeAt(i) << (16 - (i % 2) * 16);\n    }\n\n    return WordArray.create(words, utf16StrLength * 2);\n  },\n};\nexport const Utf16 = Utf16BE;\n\n/**\n * UTF-16 LE encoding strategy.\n */\nexport const Utf16LE = {\n  /**\n   * Converts a word array to a UTF-16 LE string.\n   *\n   * @param {WordArray} wordArray The word array.\n   *\n   * @return {string} The UTF-16 LE string.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray);\n   */\n  stringify(wordArray) {\n    // Shortcuts\n    const { words, sigBytes } = wordArray;\n\n    // Convert\n    const utf16Chars = [];\n    for (let i = 0; i < sigBytes; i += 2) {\n      const codePoint = swapEndian((words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff);\n      utf16Chars.push(String.fromCharCode(codePoint));\n    }\n\n    return utf16Chars.join('');\n  },\n\n  /**\n   * Converts a UTF-16 LE string to a word array.\n   *\n   * @param {string} utf16Str The UTF-16 LE string.\n   *\n   * @return {WordArray} The word array.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str);\n   */\n  parse(utf16Str) {\n    // Shortcut\n    const utf16StrLength = utf16Str.length;\n\n    // Convert\n    const words = [];\n    for (let i = 0; i < utf16StrLength; i += 1) {\n      words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << (16 - (i % 2) * 16));\n    }\n\n    return WordArray.create(words, utf16StrLength * 2);\n  },\n};\n","import {\n  WordArray,\n} from './core.js';\nimport {\n  parseLoop,\n} from './enc-base64.js'\n\n/**\n * Base64url encoding strategy.\n */\nexport const Base64url = {\n  /**\n   * Converts a word array to a Base64url string.\n   *\n   * @param {WordArray} wordArray The word array.\n   * \n   * @param {boolean} urlSafe Whether to use url safe.\n   *\n   * @return {string} The Base64url string.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const base64String = CryptoJS.enc.Base64.stringify(wordArray);\n   */\n  stringify(wordArray, urlSafe = true) {\n    // Shortcuts\n    const { words, sigBytes } = wordArray;\n    const map = urlSafe ? this._safeMap : this._map;\n\n    // Clamp excess bits\n    wordArray.clamp();\n\n    // Convert\n    const base64Chars = [];\n    for (let i = 0; i < sigBytes; i += 3) {\n      const byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;\n      const byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;\n      const byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;\n\n      const triplet = (byte1 << 16) | (byte2 << 8) | byte3;\n\n      for (let j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j += 1) {\n        base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));\n      }\n    }\n\n    // Add padding\n    const paddingChar = map.charAt(64);\n    if (paddingChar) {\n      while (base64Chars.length % 4) {\n        base64Chars.push(paddingChar);\n      }\n    }\n\n    return base64Chars.join('');\n  },\n\n  /**\n   * Converts a Base64url string to a word array.\n   *\n   * @param {string} base64Str The Base64url string.\n   * \n   * @param {boolean} urlSafe Whether to use url safe.\n   *\n   * @return {WordArray} The word array.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     const wordArray = CryptoJS.enc.Base64.parse(base64String);\n   */\n  parse(base64Str, urlSafe = true) {\n    // Shortcuts\n    let base64StrLength = base64Str.length;\n    const map = urlSafe ? this._safeMap : this._map;\n    let reverseMap = this._reverseMap;\n\n    if (!reverseMap) {\n      this._reverseMap = [];\n      reverseMap = this._reverseMap;\n      for (let j = 0; j < map.length; j += 1) {\n        reverseMap[map.charCodeAt(j)] = j;\n      }\n    }\n\n    // Ignore padding\n    const paddingChar = map.charAt(64);\n    if (paddingChar) {\n      const paddingIndex = base64Str.indexOf(paddingChar);\n      if (paddingIndex !== -1) {\n        base64StrLength = paddingIndex;\n      }\n    }\n\n    // Convert\n    return parseLoop(base64Str, base64StrLength, reverseMap);\n  },\n\n  _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',\n\n  _safeMap: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',\n};\n","import {\n  WordArray,\n  Hasher,\n} from './core.js';\n\n// Reusable object\nconst W = [];\n\n/**\n * SHA-1 hash algorithm.\n */\nexport class SHA1Algo extends Hasher {\n  _doReset() {\n    this._hash = new WordArray([\n      0x67452301,\n      0xefcdab89,\n      0x98badcfe,\n      0x10325476,\n      0xc3d2e1f0,\n    ]);\n  }\n\n  _doProcessBlock(M, offset) {\n    // Shortcut\n    const H = this._hash.words;\n\n    // Working variables\n    let a = H[0];\n    let b = H[1];\n    let c = H[2];\n    let d = H[3];\n    let e = H[4];\n\n    // Computation\n    for (let i = 0; i < 80; i += 1) {\n      if (i < 16) {\n        W[i] = M[offset + i] | 0;\n      } else {\n        const n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];\n        W[i] = (n << 1) | (n >>> 31);\n      }\n\n      let t = ((a << 5) | (a >>> 27)) + e + W[i];\n      if (i < 20) {\n        t += ((b & c) | (~b & d)) + 0x5a827999;\n      } else if (i < 40) {\n        t += (b ^ c ^ d) + 0x6ed9eba1;\n      } else if (i < 60) {\n        t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;\n      } else /* if (i < 80) */ {\n        t += (b ^ c ^ d) - 0x359d3e2a;\n      }\n\n      e = d;\n      d = c;\n      c = (b << 30) | (b >>> 2);\n      b = a;\n      a = t;\n    }\n\n    // Intermediate hash value\n    H[0] = (H[0] + a) | 0;\n    H[1] = (H[1] + b) | 0;\n    H[2] = (H[2] + c) | 0;\n    H[3] = (H[3] + d) | 0;\n    H[4] = (H[4] + e) | 0;\n  }\n\n  _doFinalize() {\n    // Shortcuts\n    const data = this._data;\n    const dataWords = data.words;\n\n    const nBitsTotal = this._nDataBytes * 8;\n    const nBitsLeft = data.sigBytes * 8;\n\n    // Add padding\n    dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - (nBitsLeft % 32));\n    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);\n    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;\n    data.sigBytes = dataWords.length * 4;\n\n    // Hash final blocks\n    this._process();\n\n    // Return final computed hash\n    return this._hash;\n  }\n\n  clone() {\n    const clone = super.clone.call(this);\n    clone._hash = this._hash.clone();\n\n    return clone;\n  }\n}\n\n/**\n * Shortcut function to the hasher's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n *\n * @return {WordArray} The hash.\n *\n * @static\n *\n * @example\n *\n *     var hash = CryptoJS.SHA1('message');\n *     var hash = CryptoJS.SHA1(wordArray);\n */\nexport const SHA1 = Hasher._createHelper(SHA1Algo);\n\n/**\n * Shortcut function to the HMAC's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n * @param {WordArray|string} key The secret key.\n *\n * @return {WordArray} The HMAC.\n *\n * @static\n *\n * @example\n *\n *     var hmac = CryptoJS.HmacSHA1(message, key);\n */\nexport const HmacSHA1 = Hasher._createHmacHelper(SHA1Algo);\n","import {\n  WordArray,\n  Hasher,\n} from './core.js';\n\n// Initialization and round constants tables\nconst H = [];\nconst K = [];\n\n// Compute constants\nconst isPrime = (n) => {\n  const sqrtN = Math.sqrt(n);\n  for (let factor = 2; factor <= sqrtN; factor += 1) {\n    if (!(n % factor)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\nconst getFractionalBits = n => ((n - (n | 0)) * 0x100000000) | 0;\n\nlet n = 2;\nlet nPrime = 0;\nwhile (nPrime < 64) {\n  if (isPrime(n)) {\n    if (nPrime < 8) {\n      H[nPrime] = getFractionalBits(n ** (1 / 2));\n    }\n    K[nPrime] = getFractionalBits(n ** (1 / 3));\n\n    nPrime += 1;\n  }\n\n  n += 1;\n}\n\n// Reusable object\nconst W = [];\n\n/**\n * SHA-256 hash algorithm.\n */\nexport class SHA256Algo extends Hasher {\n  _doReset() {\n    this._hash = new WordArray(H.slice(0));\n  }\n\n  _doProcessBlock(M, offset) {\n    // Shortcut\n    const _H = this._hash.words;\n\n    // Working variables\n    let a = _H[0];\n    let b = _H[1];\n    let c = _H[2];\n    let d = _H[3];\n    let e = _H[4];\n    let f = _H[5];\n    let g = _H[6];\n    let h = _H[7];\n\n    // Computation\n    for (let i = 0; i < 64; i += 1) {\n      if (i < 16) {\n        W[i] = M[offset + i] | 0;\n      } else {\n        const gamma0x = W[i - 15];\n        const gamma0 = ((gamma0x << 25) | (gamma0x >>> 7))\n          ^ ((gamma0x << 14) | (gamma0x >>> 18))\n          ^ (gamma0x >>> 3);\n\n        const gamma1x = W[i - 2];\n        const gamma1 = ((gamma1x << 15) | (gamma1x >>> 17))\n          ^ ((gamma1x << 13) | (gamma1x >>> 19))\n          ^ (gamma1x >>> 10);\n\n        W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];\n      }\n\n      const ch = (e & f) ^ (~e & g);\n      const maj = (a & b) ^ (a & c) ^ (b & c);\n\n      const sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));\n      const sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25));\n\n      const t1 = h + sigma1 + ch + K[i] + W[i];\n      const t2 = sigma0 + maj;\n\n      h = g;\n      g = f;\n      f = e;\n      e = (d + t1) | 0;\n      d = c;\n      c = b;\n      b = a;\n      a = (t1 + t2) | 0;\n    }\n\n    // Intermediate hash value\n    _H[0] = (_H[0] + a) | 0;\n    _H[1] = (_H[1] + b) | 0;\n    _H[2] = (_H[2] + c) | 0;\n    _H[3] = (_H[3] + d) | 0;\n    _H[4] = (_H[4] + e) | 0;\n    _H[5] = (_H[5] + f) | 0;\n    _H[6] = (_H[6] + g) | 0;\n    _H[7] = (_H[7] + h) | 0;\n  }\n\n  _doFinalize() {\n    // Shortcuts\n    const data = this._data;\n    const dataWords = data.words;\n\n    const nBitsTotal = this._nDataBytes * 8;\n    const nBitsLeft = data.sigBytes * 8;\n\n    // Add padding\n    dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - (nBitsLeft % 32));\n    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);\n    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;\n    data.sigBytes = dataWords.length * 4;\n\n    // Hash final blocks\n    this._process();\n\n    // Return final computed hash\n    return this._hash;\n  }\n\n  clone() {\n    const clone = super.clone.call(this);\n    clone._hash = this._hash.clone();\n\n    return clone;\n  }\n}\n\n/**\n * Shortcut function to the hasher's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n *\n * @return {WordArray} The hash.\n *\n * @static\n *\n * @example\n *\n *     var hash = CryptoJS.SHA256('message');\n *     var hash = CryptoJS.SHA256(wordArray);\n */\nexport const SHA256 = Hasher._createHelper(SHA256Algo);\n\n/**\n * Shortcut function to the HMAC's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n * @param {WordArray|string} key The secret key.\n *\n * @return {WordArray} The HMAC.\n *\n * @static\n *\n * @example\n *\n *     var hmac = CryptoJS.HmacSHA256(message, key);\n */\nexport const HmacSHA256 = Hasher._createHmacHelper(SHA256Algo);\n","import { WordArray } from './core.js';\nimport { SHA256Algo } from './sha256.js';\n\n/**\n * SHA-224 hash algorithm.\n */\nexport class SHA224Algo extends SHA256Algo {\n  _doReset() {\n    this._hash = new WordArray([\n      0xc1059ed8,\n      0x367cd507,\n      0x3070dd17,\n      0xf70e5939,\n      0xffc00b31,\n      0x68581511,\n      0x64f98fa7,\n      0xbefa4fa4,\n    ]);\n  }\n\n  _doFinalize() {\n    const hash = super._doFinalize.call(this);\n\n    hash.sigBytes -= 4;\n\n    return hash;\n  }\n}\n\n/**\n * Shortcut function to the hasher's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n *\n * @return {WordArray} The hash.\n *\n * @static\n *\n * @example\n *\n *     var hash = CryptoJS.SHA224('message');\n *     var hash = CryptoJS.SHA224(wordArray);\n */\nexport const SHA224 = SHA256Algo._createHelper(SHA224Algo);\n\n/**\n * Shortcut function to the HMAC's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n * @param {WordArray|string} key The secret key.\n *\n * @return {WordArray} The HMAC.\n *\n * @static\n *\n * @example\n *\n *     var hmac = CryptoJS.HmacSHA224(message, key);\n */\nexport const HmacSHA224 = SHA256Algo._createHmacHelper(SHA224Algo);\n","import { Hasher } from './core.js';\nimport {\n  X64Word,\n  X64WordArray,\n} from './x64-core.js';\n\n// Constants\nconst K = [\n  new X64Word(0x428a2f98, 0xd728ae22),\n  new X64Word(0x71374491, 0x23ef65cd),\n  new X64Word(0xb5c0fbcf, 0xec4d3b2f),\n  new X64Word(0xe9b5dba5, 0x8189dbbc),\n  new X64Word(0x3956c25b, 0xf348b538),\n  new X64Word(0x59f111f1, 0xb605d019),\n  new X64Word(0x923f82a4, 0xaf194f9b),\n  new X64Word(0xab1c5ed5, 0xda6d8118),\n  new X64Word(0xd807aa98, 0xa3030242),\n  new X64Word(0x12835b01, 0x45706fbe),\n  new X64Word(0x243185be, 0x4ee4b28c),\n  new X64Word(0x550c7dc3, 0xd5ffb4e2),\n  new X64Word(0x72be5d74, 0xf27b896f),\n  new X64Word(0x80deb1fe, 0x3b1696b1),\n  new X64Word(0x9bdc06a7, 0x25c71235),\n  new X64Word(0xc19bf174, 0xcf692694),\n  new X64Word(0xe49b69c1, 0x9ef14ad2),\n  new X64Word(0xefbe4786, 0x384f25e3),\n  new X64Word(0x0fc19dc6, 0x8b8cd5b5),\n  new X64Word(0x240ca1cc, 0x77ac9c65),\n  new X64Word(0x2de92c6f, 0x592b0275),\n  new X64Word(0x4a7484aa, 0x6ea6e483),\n  new X64Word(0x5cb0a9dc, 0xbd41fbd4),\n  new X64Word(0x76f988da, 0x831153b5),\n  new X64Word(0x983e5152, 0xee66dfab),\n  new X64Word(0xa831c66d, 0x2db43210),\n  new X64Word(0xb00327c8, 0x98fb213f),\n  new X64Word(0xbf597fc7, 0xbeef0ee4),\n  new X64Word(0xc6e00bf3, 0x3da88fc2),\n  new X64Word(0xd5a79147, 0x930aa725),\n  new X64Word(0x06ca6351, 0xe003826f),\n  new X64Word(0x14292967, 0x0a0e6e70),\n  new X64Word(0x27b70a85, 0x46d22ffc),\n  new X64Word(0x2e1b2138, 0x5c26c926),\n  new X64Word(0x4d2c6dfc, 0x5ac42aed),\n  new X64Word(0x53380d13, 0x9d95b3df),\n  new X64Word(0x650a7354, 0x8baf63de),\n  new X64Word(0x766a0abb, 0x3c77b2a8),\n  new X64Word(0x81c2c92e, 0x47edaee6),\n  new X64Word(0x92722c85, 0x1482353b),\n  new X64Word(0xa2bfe8a1, 0x4cf10364),\n  new X64Word(0xa81a664b, 0xbc423001),\n  new X64Word(0xc24b8b70, 0xd0f89791),\n  new X64Word(0xc76c51a3, 0x0654be30),\n  new X64Word(0xd192e819, 0xd6ef5218),\n  new X64Word(0xd6990624, 0x5565a910),\n  new X64Word(0xf40e3585, 0x5771202a),\n  new X64Word(0x106aa070, 0x32bbd1b8),\n  new X64Word(0x19a4c116, 0xb8d2d0c8),\n  new X64Word(0x1e376c08, 0x5141ab53),\n  new X64Word(0x2748774c, 0xdf8eeb99),\n  new X64Word(0x34b0bcb5, 0xe19b48a8),\n  new X64Word(0x391c0cb3, 0xc5c95a63),\n  new X64Word(0x4ed8aa4a, 0xe3418acb),\n  new X64Word(0x5b9cca4f, 0x7763e373),\n  new X64Word(0x682e6ff3, 0xd6b2b8a3),\n  new X64Word(0x748f82ee, 0x5defb2fc),\n  new X64Word(0x78a5636f, 0x43172f60),\n  new X64Word(0x84c87814, 0xa1f0ab72),\n  new X64Word(0x8cc70208, 0x1a6439ec),\n  new X64Word(0x90befffa, 0x23631e28),\n  new X64Word(0xa4506ceb, 0xde82bde9),\n  new X64Word(0xbef9a3f7, 0xb2c67915),\n  new X64Word(0xc67178f2, 0xe372532b),\n  new X64Word(0xca273ece, 0xea26619c),\n  new X64Word(0xd186b8c7, 0x21c0c207),\n  new X64Word(0xeada7dd6, 0xcde0eb1e),\n  new X64Word(0xf57d4f7f, 0xee6ed178),\n  new X64Word(0x06f067aa, 0x72176fba),\n  new X64Word(0x0a637dc5, 0xa2c898a6),\n  new X64Word(0x113f9804, 0xbef90dae),\n  new X64Word(0x1b710b35, 0x131c471b),\n  new X64Word(0x28db77f5, 0x23047d84),\n  new X64Word(0x32caab7b, 0x40c72493),\n  new X64Word(0x3c9ebe0a, 0x15c9bebc),\n  new X64Word(0x431d67c4, 0x9c100d4c),\n  new X64Word(0x4cc5d4be, 0xcb3e42b6),\n  new X64Word(0x597f299c, 0xfc657e2a),\n  new X64Word(0x5fcb6fab, 0x3ad6faec),\n  new X64Word(0x6c44198c, 0x4a475817),\n];\n\n// Reusable objects\nconst W = [];\nfor (let i = 0; i < 80; i += 1) {\n  W[i] = new X64Word();\n}\n\n/**\n * SHA-512 hash algorithm.\n */\nexport class SHA512Algo extends Hasher {\n  constructor() {\n    super();\n\n    this.blockSize = 1024 / 32;\n  }\n\n  _doReset() {\n    this._hash = new X64WordArray([\n      new X64Word(0x6a09e667, 0xf3bcc908),\n      new X64Word(0xbb67ae85, 0x84caa73b),\n      new X64Word(0x3c6ef372, 0xfe94f82b),\n      new X64Word(0xa54ff53a, 0x5f1d36f1),\n      new X64Word(0x510e527f, 0xade682d1),\n      new X64Word(0x9b05688c, 0x2b3e6c1f),\n      new X64Word(0x1f83d9ab, 0xfb41bd6b),\n      new X64Word(0x5be0cd19, 0x137e2179),\n    ]);\n  }\n\n  _doProcessBlock(M, offset) {\n    // Shortcuts\n    const H = this._hash.words;\n\n    const H0 = H[0];\n    const H1 = H[1];\n    const H2 = H[2];\n    const H3 = H[3];\n    const H4 = H[4];\n    const H5 = H[5];\n    const H6 = H[6];\n    const H7 = H[7];\n\n    const H0h = H0.high;\n    let H0l = H0.low;\n    const H1h = H1.high;\n    let H1l = H1.low;\n    const H2h = H2.high;\n    let H2l = H2.low;\n    const H3h = H3.high;\n    let H3l = H3.low;\n    const H4h = H4.high;\n    let H4l = H4.low;\n    const H5h = H5.high;\n    let H5l = H5.low;\n    const H6h = H6.high;\n    let H6l = H6.low;\n    const H7h = H7.high;\n    let H7l = H7.low;\n\n    // Working variables\n    let ah = H0h;\n    let al = H0l;\n    let bh = H1h;\n    let bl = H1l;\n    let ch = H2h;\n    let cl = H2l;\n    let dh = H3h;\n    let dl = H3l;\n    let eh = H4h;\n    let el = H4l;\n    let fh = H5h;\n    let fl = H5l;\n    let gh = H6h;\n    let gl = H6l;\n    let hh = H7h;\n    let hl = H7l;\n\n    // Rounds\n    for (let i = 0; i < 80; i += 1) {\n      let Wil;\n      let Wih;\n\n      // Shortcut\n      const Wi = W[i];\n\n      // Extend message\n      if (i < 16) {\n        Wi.high = M[offset + i * 2] | 0;\n        Wih = Wi.high;\n        Wi.low = M[offset + i * 2 + 1] | 0;\n        Wil = Wi.low;\n      } else {\n        // Gamma0\n        const gamma0x = W[i - 15];\n        const gamma0xh = gamma0x.high;\n        const gamma0xl = gamma0x.low;\n        const gamma0h = ((gamma0xh >>> 1) | (gamma0xl << 31))\n          ^ ((gamma0xh >>> 8) | (gamma0xl << 24))\n          ^ (gamma0xh >>> 7);\n        const gamma0l = ((gamma0xl >>> 1) | (gamma0xh << 31))\n          ^ ((gamma0xl >>> 8) | (gamma0xh << 24))\n          ^ ((gamma0xl >>> 7) | (gamma0xh << 25));\n\n        // Gamma1\n        const gamma1x = W[i - 2];\n        const gamma1xh = gamma1x.high;\n        const gamma1xl = gamma1x.low;\n        const gamma1h = ((gamma1xh >>> 19) | (gamma1xl << 13))\n          ^ ((gamma1xh << 3) | (gamma1xl >>> 29))\n          ^ (gamma1xh >>> 6);\n        const gamma1l = ((gamma1xl >>> 19) | (gamma1xh << 13))\n          ^ ((gamma1xl << 3) | (gamma1xh >>> 29))\n          ^ ((gamma1xl >>> 6) | (gamma1xh << 26));\n\n        // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]\n        const Wi7 = W[i - 7];\n        const Wi7h = Wi7.high;\n        const Wi7l = Wi7.low;\n\n        const Wi16 = W[i - 16];\n        const Wi16h = Wi16.high;\n        const Wi16l = Wi16.low;\n\n        Wil = gamma0l + Wi7l;\n        Wih = gamma0h + Wi7h + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0);\n        Wil += gamma1l;\n        Wih = Wih + gamma1h + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0);\n        Wil += Wi16l;\n        Wih = Wih + Wi16h + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0);\n\n        Wi.high = Wih;\n        Wi.low = Wil;\n      }\n\n      const chh = (eh & fh) ^ (~eh & gh);\n      const chl = (el & fl) ^ (~el & gl);\n      const majh = (ah & bh) ^ (ah & ch) ^ (bh & ch);\n      const majl = (al & bl) ^ (al & cl) ^ (bl & cl);\n\n      const sigma0h = ((ah >>> 28) | (al << 4))\n        ^ ((ah << 30) | (al >>> 2))\n        ^ ((ah << 25) | (al >>> 7));\n      const sigma0l = ((al >>> 28) | (ah << 4))\n        ^ ((al << 30) | (ah >>> 2))\n        ^ ((al << 25) | (ah >>> 7));\n      const sigma1h = ((eh >>> 14) | (el << 18))\n        ^ ((eh >>> 18) | (el << 14))\n        ^ ((eh << 23) | (el >>> 9));\n      const sigma1l = ((el >>> 14) | (eh << 18))\n        ^ ((el >>> 18) | (eh << 14))\n        ^ ((el << 23) | (eh >>> 9));\n\n      // t1 = h + sigma1 + ch + K[i] + W[i]\n      const Ki = K[i];\n      const Kih = Ki.high;\n      const Kil = Ki.low;\n\n      let t1l = hl + sigma1l;\n      let t1h = hh + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0);\n      t1l += chl;\n      t1h = t1h + chh + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0);\n      t1l += Kil;\n      t1h = t1h + Kih + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0);\n      t1l += Wil;\n      t1h = t1h + Wih + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0);\n\n      // t2 = sigma0 + maj\n      const t2l = sigma0l + majl;\n      const t2h = sigma0h + majh + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0);\n\n      // Update working variables\n      hh = gh;\n      hl = gl;\n      gh = fh;\n      gl = fl;\n      fh = eh;\n      fl = el;\n      el = (dl + t1l) | 0;\n      eh = (dh + t1h + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0;\n      dh = ch;\n      dl = cl;\n      ch = bh;\n      cl = bl;\n      bh = ah;\n      bl = al;\n      al = (t1l + t2l) | 0;\n      ah = (t1h + t2h + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0;\n    }\n\n    // Intermediate hash value\n    H0.low = (H0l + al);\n    H0l = H0.low;\n    H0.high = (H0h + ah + ((H0l >>> 0) < (al >>> 0) ? 1 : 0));\n    H1.low = (H1l + bl);\n    H1l = H1.low;\n    H1.high = (H1h + bh + ((H1l >>> 0) < (bl >>> 0) ? 1 : 0));\n    H2.low = (H2l + cl);\n    H2l = H2.low;\n    H2.high = (H2h + ch + ((H2l >>> 0) < (cl >>> 0) ? 1 : 0));\n    H3.low = (H3l + dl);\n    H3l = H3.low;\n    H3.high = (H3h + dh + ((H3l >>> 0) < (dl >>> 0) ? 1 : 0));\n    H4.low = (H4l + el);\n    H4l = H4.low;\n    H4.high = (H4h + eh + ((H4l >>> 0) < (el >>> 0) ? 1 : 0));\n    H5.low = (H5l + fl);\n    H5l = H5.low;\n    H5.high = (H5h + fh + ((H5l >>> 0) < (fl >>> 0) ? 1 : 0));\n    H6.low = (H6l + gl);\n    H6l = H6.low;\n    H6.high = (H6h + gh + ((H6l >>> 0) < (gl >>> 0) ? 1 : 0));\n    H7.low = (H7l + hl);\n    H7l = H7.low;\n    H7.high = (H7h + hh + ((H7l >>> 0) < (hl >>> 0) ? 1 : 0));\n  }\n\n  _doFinalize() {\n    // Shortcuts\n    const data = this._data;\n    const dataWords = data.words;\n\n    const nBitsTotal = this._nDataBytes * 8;\n    const nBitsLeft = data.sigBytes * 8;\n\n    // Add padding\n    dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - (nBitsLeft % 32));\n    dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 30] = Math.floor(nBitsTotal / 0x100000000);\n    dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 31] = nBitsTotal;\n    data.sigBytes = dataWords.length * 4;\n\n    // Hash final blocks\n    this._process();\n\n    // Convert hash to 32-bit word array before returning\n    const hash = this._hash.toX32();\n\n    // Return final computed hash\n    return hash;\n  }\n\n  clone() {\n    const clone = super.clone.call(this);\n    clone._hash = this._hash.clone();\n\n    return clone;\n  }\n}\n\n/**\n * Shortcut function to the hasher's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n *\n * @return {WordArray} The hash.\n *\n * @static\n *\n * @example\n *\n *     var hash = CryptoJS.SHA512('message');\n *     var hash = CryptoJS.SHA512(wordArray);\n */\nexport const SHA512 = Hasher._createHelper(SHA512Algo);\n\n/**\n * Shortcut function to the HMAC's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n * @param {WordArray|string} key The secret key.\n *\n * @return {WordArray} The HMAC.\n *\n * @static\n *\n * @example\n *\n *     var hmac = CryptoJS.HmacSHA512(message, key);\n */\nexport const HmacSHA512 = Hasher._createHmacHelper(SHA512Algo);\n","import {\n  X64Word,\n  X64WordArray,\n} from './x64-core.js';\nimport { SHA512Algo } from './sha512.js';\n\n/**\n * SHA-384 hash algorithm.\n */\nexport class SHA384Algo extends SHA512Algo {\n  _doReset() {\n    this._hash = new X64WordArray([\n      new X64Word(0xcbbb9d5d, 0xc1059ed8),\n      new X64Word(0x629a292a, 0x367cd507),\n      new X64Word(0x9159015a, 0x3070dd17),\n      new X64Word(0x152fecd8, 0xf70e5939),\n      new X64Word(0x67332667, 0xffc00b31),\n      new X64Word(0x8eb44a87, 0x68581511),\n      new X64Word(0xdb0c2e0d, 0x64f98fa7),\n      new X64Word(0x47b5481d, 0xbefa4fa4),\n    ]);\n  }\n\n  _doFinalize() {\n    const hash = super._doFinalize.call(this);\n\n    hash.sigBytes -= 16;\n\n    return hash;\n  }\n}\n\n/**\n * Shortcut function to the hasher's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n *\n * @return {WordArray} The hash.\n *\n * @static\n *\n * @example\n *\n *     var hash = CryptoJS.SHA384('message');\n *     var hash = CryptoJS.SHA384(wordArray);\n */\nexport const SHA384 = SHA512Algo._createHelper(SHA384Algo);\n\n/**\n * Shortcut function to the HMAC's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n * @param {WordArray|string} key The secret key.\n *\n * @return {WordArray} The HMAC.\n *\n * @static\n *\n * @example\n *\n *     var hmac = CryptoJS.HmacSHA384(message, key);\n */\nexport const HmacSHA384 = SHA512Algo._createHmacHelper(SHA384Algo);\n","import {\n  WordArray,\n  Hasher,\n} from './core.js';\nimport { X64Word } from './x64-core.js';\n\n// Constants tables\nconst RHO_OFFSETS = [];\nconst PI_INDEXES = [];\nconst ROUND_CONSTANTS = [];\n\n// Compute Constants\n// Compute rho offset constants\nlet _x = 1;\nlet _y = 0;\nfor (let t = 0; t < 24; t += 1) {\n  RHO_OFFSETS[_x + 5 * _y] = ((t + 1) * (t + 2) / 2) % 64;\n\n  const newX = _y % 5;\n  const newY = (2 * _x + 3 * _y) % 5;\n  _x = newX;\n  _y = newY;\n}\n\n// Compute pi index constants\nfor (let x = 0; x < 5; x += 1) {\n  for (let y = 0; y < 5; y += 1) {\n    PI_INDEXES[x + 5 * y] = y + ((2 * x + 3 * y) % 5) * 5;\n  }\n}\n\n// Compute round constants\nlet LFSR = 0x01;\nfor (let i = 0; i < 24; i += 1) {\n  let roundConstantMsw = 0;\n  let roundConstantLsw = 0;\n\n  for (let j = 0; j < 7; j += 1) {\n    if (LFSR & 0x01) {\n      const bitPosition = (1 << j) - 1;\n      if (bitPosition < 32) {\n        roundConstantLsw ^= 1 << bitPosition;\n      } else /* if (bitPosition >= 32) */ {\n        roundConstantMsw ^= 1 << (bitPosition - 32);\n      }\n    }\n\n    // Compute next LFSR\n    if (LFSR & 0x80) {\n      // Primitive polynomial over GF(2): x^8 + x^6 + x^5 + x^4 + 1\n      LFSR = (LFSR << 1) ^ 0x71;\n    } else {\n      LFSR <<= 1;\n    }\n  }\n\n  ROUND_CONSTANTS[i] = X64Word.create(roundConstantMsw, roundConstantLsw);\n}\n\n// Reusable objects for temporary values\nconst T = [];\nfor (let i = 0; i < 25; i += 1) {\n  T[i] = X64Word.create();\n}\n\n/**\n * SHA-3 hash algorithm.\n */\nexport class SHA3Algo extends Hasher {\n  constructor(cfg) {\n    /**\n     * Configuration options.\n     *\n     * @property {number} outputLength\n     *   The desired number of bits in the output hash.\n     *   Only values permitted are: 224, 256, 384, 512.\n     *   Default: 512\n     */\n    super(Object.assign(\n      { outputLength: 512 },\n      cfg,\n    ));\n  }\n\n  _doReset() {\n    this._state = [];\n    const state = this._state;\n    for (let i = 0; i < 25; i += 1) {\n      state[i] = new X64Word();\n    }\n\n    this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32;\n  }\n\n  _doProcessBlock(M, offset) {\n    // Shortcuts\n    const state = this._state;\n    const nBlockSizeLanes = this.blockSize / 2;\n\n    // Absorb\n    for (let i = 0; i < nBlockSizeLanes; i += 1) {\n      // Shortcuts\n      let M2i = M[offset + 2 * i];\n      let M2i1 = M[offset + 2 * i + 1];\n\n      // Swap endian\n      M2i = (((M2i << 8) | (M2i >>> 24)) & 0x00ff00ff)\n        | (((M2i << 24) | (M2i >>> 8)) & 0xff00ff00);\n      M2i1 = (((M2i1 << 8) | (M2i1 >>> 24)) & 0x00ff00ff)\n        | (((M2i1 << 24) | (M2i1 >>> 8)) & 0xff00ff00);\n\n      // Absorb message into state\n      const lane = state[i];\n      lane.high ^= M2i1;\n      lane.low ^= M2i;\n    }\n\n    // Rounds\n    for (let round = 0; round < 24; round += 1) {\n      // Theta\n      for (let x = 0; x < 5; x += 1) {\n        // Mix column lanes\n        let tMsw = 0;\n        let tLsw = 0;\n        for (let y = 0; y < 5; y += 1) {\n          const lane = state[x + 5 * y];\n          tMsw ^= lane.high;\n          tLsw ^= lane.low;\n        }\n\n        // Temporary values\n        const Tx = T[x];\n        Tx.high = tMsw;\n        Tx.low = tLsw;\n      }\n      for (let x = 0; x < 5; x += 1) {\n        // Shortcuts\n        const Tx4 = T[(x + 4) % 5];\n        const Tx1 = T[(x + 1) % 5];\n        const Tx1Msw = Tx1.high;\n        const Tx1Lsw = Tx1.low;\n\n        // Mix surrounding columns\n        const tMsw = Tx4.high ^ ((Tx1Msw << 1) | (Tx1Lsw >>> 31));\n        const tLsw = Tx4.low ^ ((Tx1Lsw << 1) | (Tx1Msw >>> 31));\n        for (let y = 0; y < 5; y += 1) {\n          const lane = state[x + 5 * y];\n          lane.high ^= tMsw;\n          lane.low ^= tLsw;\n        }\n      }\n\n      // Rho Pi\n      for (let laneIndex = 1; laneIndex < 25; laneIndex += 1) {\n        let tMsw;\n        let tLsw;\n\n        // Shortcuts\n        const lane = state[laneIndex];\n        const laneMsw = lane.high;\n        const laneLsw = lane.low;\n        const rhoOffset = RHO_OFFSETS[laneIndex];\n\n        // Rotate lanes\n        if (rhoOffset < 32) {\n          tMsw = (laneMsw << rhoOffset) | (laneLsw >>> (32 - rhoOffset));\n          tLsw = (laneLsw << rhoOffset) | (laneMsw >>> (32 - rhoOffset));\n        } else /* if (rhoOffset >= 32) */ {\n          tMsw = (laneLsw << (rhoOffset - 32)) | (laneMsw >>> (64 - rhoOffset));\n          tLsw = (laneMsw << (rhoOffset - 32)) | (laneLsw >>> (64 - rhoOffset));\n        }\n\n        // Transpose lanes\n        const TPiLane = T[PI_INDEXES[laneIndex]];\n        TPiLane.high = tMsw;\n        TPiLane.low = tLsw;\n      }\n\n      // Rho pi at x = y = 0\n      const T0 = T[0];\n      const state0 = state[0];\n      T0.high = state0.high;\n      T0.low = state0.low;\n\n      // Chi\n      for (let x = 0; x < 5; x += 1) {\n        for (let y = 0; y < 5; y += 1) {\n          // Shortcuts\n          const laneIndex = x + 5 * y;\n          const lane = state[laneIndex];\n          const TLane = T[laneIndex];\n          const Tx1Lane = T[((x + 1) % 5) + 5 * y];\n          const Tx2Lane = T[((x + 2) % 5) + 5 * y];\n\n          // Mix rows\n          lane.high = TLane.high ^ (~Tx1Lane.high & Tx2Lane.high);\n          lane.low = TLane.low ^ (~Tx1Lane.low & Tx2Lane.low);\n        }\n      }\n\n      // Iota\n      const lane = state[0];\n      const roundConstant = ROUND_CONSTANTS[round];\n      lane.high ^= roundConstant.high;\n      lane.low ^= roundConstant.low;\n    }\n  }\n\n  _doFinalize() {\n    // Shortcuts\n    const data = this._data;\n    const dataWords = data.words;\n    const nBitsLeft = data.sigBytes * 8;\n    const blockSizeBits = this.blockSize * 32;\n\n    // Add padding\n    dataWords[nBitsLeft >>> 5] |= 0x1 << (24 - (nBitsLeft % 32));\n    dataWords[((Math.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits) >>> 5) - 1] |= 0x80;\n    data.sigBytes = dataWords.length * 4;\n\n    // Hash final blocks\n    this._process();\n\n    // Shortcuts\n    const state = this._state;\n    const outputLengthBytes = this.cfg.outputLength / 8;\n    const outputLengthLanes = outputLengthBytes / 8;\n\n    // Squeeze\n    const hashWords = [];\n    for (let i = 0; i < outputLengthLanes; i += 1) {\n      // Shortcuts\n      const lane = state[i];\n      let laneMsw = lane.high;\n      let laneLsw = lane.low;\n\n      // Swap endian\n      laneMsw = (((laneMsw << 8) | (laneMsw >>> 24)) & 0x00ff00ff)\n        | (((laneMsw << 24) | (laneMsw >>> 8)) & 0xff00ff00);\n      laneLsw = (((laneLsw << 8) | (laneLsw >>> 24)) & 0x00ff00ff)\n        | (((laneLsw << 24) | (laneLsw >>> 8)) & 0xff00ff00);\n\n      // Squeeze state to retrieve hash\n      hashWords.push(laneLsw);\n      hashWords.push(laneMsw);\n    }\n\n    // Return final computed hash\n    return new WordArray(hashWords, outputLengthBytes);\n  }\n\n  clone() {\n    const clone = super.clone.call(this);\n\n    clone._state = this._state.slice(0);\n    const state = clone._state;\n    for (let i = 0; i < 25; i += 1) {\n      state[i] = state[i].clone();\n    }\n\n    return clone;\n  }\n}\n\n/**\n * Shortcut function to the hasher's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n *\n * @return {WordArray} The hash.\n *\n * @static\n *\n * @example\n *\n *     var hash = CryptoJS.SHA3('message');\n *     var hash = CryptoJS.SHA3(wordArray);\n */\nexport const SHA3 = Hasher._createHelper(SHA3Algo);\n\n/**\n * Shortcut function to the HMAC's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n * @param {WordArray|string} key The secret key.\n *\n * @return {WordArray} The HMAC.\n *\n * @static\n *\n * @example\n *\n *     var hmac = CryptoJS.HmacSHA3(message, key);\n */\nexport const HmacSHA3 = Hasher._createHmacHelper(SHA3Algo);\n","/** @preserve\n(c) 2012 by Cédric Mesnil. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted\nprovided that the following conditions are met:\n\n    - Redistributions of source code must retain the above copyright notice, this list of\n    conditions and the following disclaimer.\n    - Redistributions in binary form must reproduce the above copyright notice, this list\n    of conditions and the following disclaimer in the documentation and/or other materials\n    provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS\nOR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\nCONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\nWHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY\nWAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\nimport {\n  WordArray,\n  Hasher,\n} from './core.js';\n\n// Constants table\nconst _zl = WordArray.create([\n  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,\n  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,\n  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13]);\nconst _zr = WordArray.create([\n  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,\n  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,\n  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,\n  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,\n  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11]);\nconst _sl = WordArray.create([\n  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,\n  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,\n  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,\n  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,\n  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6]);\nconst _sr = WordArray.create([\n  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,\n  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,\n  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,\n  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,\n  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11]);\n\nconst _hl = WordArray.create([0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]);\nconst _hr = WordArray.create([0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000]);\n\nconst f1 = (x, y, z) => (x) ^ (y) ^ (z);\n\nconst f2 = (x, y, z) => ((x) & (y)) | ((~x) & (z));\n\nconst f3 = (x, y, z) => ((x) | (~(y))) ^ (z);\n\nconst f4 = (x, y, z) => ((x) & (z)) | ((y) & (~(z)));\n\nconst f5 = (x, y, z) => (x) ^ ((y) | (~(z)));\n\nconst rotl = (x, n) => (x << n) | (x >>> (32 - n));\n\n/**\n * RIPEMD160 hash algorithm.\n */\nexport class RIPEMD160Algo extends Hasher {\n  _doReset() {\n    this._hash = WordArray.create([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]);\n  }\n\n  _doProcessBlock(M, offset) {\n    const _M = M;\n\n    // Swap endian\n    for (let i = 0; i < 16; i += 1) {\n      // Shortcuts\n      const offset_i = offset + i;\n      const M_offset_i = _M[offset_i];\n\n      // Swap\n      _M[offset_i] = (\n        (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff)\n          | (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)\n      );\n    }\n    // Shortcut\n    const H = this._hash.words;\n    const hl = _hl.words;\n    const hr = _hr.words;\n    const zl = _zl.words;\n    const zr = _zr.words;\n    const sl = _sl.words;\n    const sr = _sr.words;\n\n    // Working variables\n    let al = H[0];\n    let bl = H[1];\n    let cl = H[2];\n    let dl = H[3];\n    let el = H[4];\n    let ar = H[0];\n    let br = H[1];\n    let cr = H[2];\n    let dr = H[3];\n    let er = H[4];\n\n    // Computation\n    let t;\n    for (let i = 0; i < 80; i += 1) {\n      t = (al + _M[offset + zl[i]]) | 0;\n      if (i < 16) {\n        t += f1(bl, cl, dl) + hl[0];\n      } else if (i < 32) {\n        t += f2(bl, cl, dl) + hl[1];\n      } else if (i < 48) {\n        t += f3(bl, cl, dl) + hl[2];\n      } else if (i < 64) {\n        t += f4(bl, cl, dl) + hl[3];\n      } else { // if (i<80) {\n        t += f5(bl, cl, dl) + hl[4];\n      }\n      t |= 0;\n      t = rotl(t, sl[i]);\n      t = (t + el) | 0;\n      al = el;\n      el = dl;\n      dl = rotl(cl, 10);\n      cl = bl;\n      bl = t;\n\n      t = (ar + _M[offset + zr[i]]) | 0;\n      if (i < 16) {\n        t += f5(br, cr, dr) + hr[0];\n      } else if (i < 32) {\n        t += f4(br, cr, dr) + hr[1];\n      } else if (i < 48) {\n        t += f3(br, cr, dr) + hr[2];\n      } else if (i < 64) {\n        t += f2(br, cr, dr) + hr[3];\n      } else { // if (i<80) {\n        t += f1(br, cr, dr) + hr[4];\n      }\n      t |= 0;\n      t = rotl(t, sr[i]);\n      t = (t + er) | 0;\n      ar = er;\n      er = dr;\n      dr = rotl(cr, 10);\n      cr = br;\n      br = t;\n    }\n    // Intermediate hash value\n    t = (H[1] + cl + dr) | 0;\n    H[1] = (H[2] + dl + er) | 0;\n    H[2] = (H[3] + el + ar) | 0;\n    H[3] = (H[4] + al + br) | 0;\n    H[4] = (H[0] + bl + cr) | 0;\n    H[0] = t;\n  }\n\n  _doFinalize() {\n    // Shortcuts\n    const data = this._data;\n    const dataWords = data.words;\n\n    const nBitsTotal = this._nDataBytes * 8;\n    const nBitsLeft = data.sigBytes * 8;\n\n    // Add padding\n    dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - (nBitsLeft % 32));\n    dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (\n      (((nBitsTotal << 8) | (nBitsTotal >>> 24)) & 0x00ff00ff)\n        | (((nBitsTotal << 24) | (nBitsTotal >>> 8)) & 0xff00ff00)\n    );\n    data.sigBytes = (dataWords.length + 1) * 4;\n\n    // Hash final blocks\n    this._process();\n\n    // Shortcuts\n    const hash = this._hash;\n    const H = hash.words;\n\n    // Swap endian\n    for (let i = 0; i < 5; i += 1) {\n      // Shortcut\n      const H_i = H[i];\n\n      // Swap\n      H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff)\n        | (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);\n    }\n\n    // Return final computed hash\n    return hash;\n  }\n\n  clone() {\n    const clone = super.clone.call(this);\n    clone._hash = this._hash.clone();\n\n    return clone;\n  }\n}\n\n/**\n * Shortcut function to the hasher's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n *\n * @return {WordArray} The hash.\n *\n * @static\n *\n * @example\n *\n *     var hash = CryptoJS.RIPEMD160('message');\n *     var hash = CryptoJS.RIPEMD160(wordArray);\n */\nexport const RIPEMD160 = Hasher._createHelper(RIPEMD160Algo);\n\n/**\n * Shortcut function to the HMAC's object interface.\n *\n * @param {WordArray|string} message The message to hash.\n * @param {WordArray|string} key The secret key.\n *\n * @return {WordArray} The HMAC.\n *\n * @static\n *\n * @example\n *\n *     var hmac = CryptoJS.HmacRIPEMD160(message, key);\n */\nexport const HmacRIPEMD160 = Hasher._createHmacHelper(RIPEMD160Algo);\n","import {\n  Base,\n  WordArray,\n} from './core.js';\nimport { SHA256Algo } from './sha256.js';\nimport { HMAC } from './hmac.js';\n\n/**\n * Password-Based Key Derivation Function 2 algorithm.\n */\nexport class PBKDF2Algo extends Base {\n  /**\n   * Initializes a newly created key derivation function.\n   *\n   * @param {Object} cfg (Optional) The configuration options to use for the derivation.\n   *\n   * @example\n   *\n   *     const kdf = CryptoJS.algo.PBKDF2.create();\n   *     const kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8 });\n   *     const kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8, iterations: 1000 });\n   */\n  constructor(cfg) {\n    super();\n\n    /**\n     * Configuration options.\n     * \n     * The default `hasher` and `interations` is different from CryptoJs to enhance security:\n     * https://github.com/entronad/crypto-es/security/advisories/GHSA-mpj8-q39x-wq5h\n     *\n     * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)\n     * @property {Hasher} hasher The hasher to use. Default: SHA256\n     * @property {number} iterations The number of iterations to perform. Default: 250000\n     */\n    this.cfg = Object.assign(\n      new Base(),\n      {\n        keySize: 128 / 32,\n        hasher: SHA256Algo,\n        iterations: 250000,\n      },\n      cfg,\n    );\n  }\n\n  /**\n   * Computes the Password-Based Key Derivation Function 2.\n   *\n   * @param {WordArray|string} password The password.\n   * @param {WordArray|string} salt A salt.\n   *\n   * @return {WordArray} The derived key.\n   *\n   * @example\n   *\n   *     const key = kdf.compute(password, salt);\n   */\n  compute(password, salt) {\n    // Shortcut\n    const { cfg } = this;\n\n    // Init HMAC\n    const hmac = HMAC.create(cfg.hasher, password);\n\n    // Initial values\n    const derivedKey = WordArray.create();\n    const blockIndex = WordArray.create([0x00000001]);\n\n    // Shortcuts\n    const derivedKeyWords = derivedKey.words;\n    const blockIndexWords = blockIndex.words;\n    const { keySize, iterations } = cfg;\n\n    // Generate key\n    while (derivedKeyWords.length < keySize) {\n      const block = hmac.update(salt).finalize(blockIndex);\n      hmac.reset();\n\n      // Shortcuts\n      const blockWords = block.words;\n      const blockWordsLength = blockWords.length;\n\n      // Iterations\n      let intermediate = block;\n      for (let i = 1; i < iterations; i += 1) {\n        intermediate = hmac.finalize(intermediate);\n        hmac.reset();\n\n        // Shortcut\n        const intermediateWords = intermediate.words;\n\n        // XOR intermediate with block\n        for (let j = 0; j < blockWordsLength; j += 1) {\n          blockWords[j] ^= intermediateWords[j];\n        }\n      }\n\n      derivedKey.concat(block);\n      blockIndexWords[0] += 1;\n    }\n    derivedKey.sigBytes = keySize * 4;\n\n    return derivedKey;\n  }\n}\n\n/**\n * Computes the Password-Based Key Derivation Function 2.\n *\n * @param {WordArray|string} password The password.\n * @param {WordArray|string} salt A salt.\n * @param {Object} cfg (Optional) The configuration options to use for this computation.\n *\n * @return {WordArray} The derived key.\n *\n * @static\n *\n * @example\n *\n *     var key = CryptoJS.PBKDF2(password, salt);\n *     var key = CryptoJS.PBKDF2(password, salt, { keySize: 8 });\n *     var key = CryptoJS.PBKDF2(password, salt, { keySize: 8, iterations: 1000 });\n */\nexport const PBKDF2 = (password, salt, cfg) => PBKDF2Algo.create(cfg).compute(password, salt);\n","import {\n  BlockCipher,\n} from './cipher-core.js';\n\n// Lookup tables\nconst _SBOX = [];\nconst INV_SBOX = [];\nconst _SUB_MIX_0 = [];\nconst _SUB_MIX_1 = [];\nconst _SUB_MIX_2 = [];\nconst _SUB_MIX_3 = [];\nconst INV_SUB_MIX_0 = [];\nconst INV_SUB_MIX_1 = [];\nconst INV_SUB_MIX_2 = [];\nconst INV_SUB_MIX_3 = [];\n\n// Compute lookup tables\n\n// Compute double table\nconst d = [];\nfor (let i = 0; i < 256; i += 1) {\n  if (i < 128) {\n    d[i] = i << 1;\n  } else {\n    d[i] = (i << 1) ^ 0x11b;\n  }\n}\n\n// Walk GF(2^8)\nlet x = 0;\nlet xi = 0;\nfor (let i = 0; i < 256; i += 1) {\n  // Compute sbox\n  let sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);\n  sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;\n  _SBOX[x] = sx;\n  INV_SBOX[sx] = x;\n\n  // Compute multiplication\n  const x2 = d[x];\n  const x4 = d[x2];\n  const x8 = d[x4];\n\n  // Compute sub bytes, mix columns tables\n  let t = (d[sx] * 0x101) ^ (sx * 0x1010100);\n  _SUB_MIX_0[x] = (t << 24) | (t >>> 8);\n  _SUB_MIX_1[x] = (t << 16) | (t >>> 16);\n  _SUB_MIX_2[x] = (t << 8) | (t >>> 24);\n  _SUB_MIX_3[x] = t;\n\n  // Compute inv sub bytes, inv mix columns tables\n  t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);\n  INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);\n  INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);\n  INV_SUB_MIX_2[sx] = (t << 8) | (t >>> 24);\n  INV_SUB_MIX_3[sx] = t;\n\n  // Compute next counter\n  if (!x) {\n    xi = 1;\n    x = xi;\n  } else {\n    x = x2 ^ d[d[d[x8 ^ x2]]];\n    xi ^= d[d[xi]];\n  }\n}\n\n// Precomputed Rcon lookup\nconst RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];\n\n/**\n * AES block cipher algorithm.\n */\nexport class AESAlgo extends BlockCipher {\n  _doReset() {\n    let t;\n\n    // Skip reset of nRounds has been set before and key did not change\n    if (this._nRounds && this._keyPriorReset === this._key) {\n      return;\n    }\n\n    // Shortcuts\n    this._keyPriorReset = this._key;\n    const key = this._keyPriorReset;\n    const keyWords = key.words;\n    const keySize = key.sigBytes / 4;\n\n    // Compute number of rounds\n    this._nRounds = keySize + 6;\n    const nRounds = this._nRounds;\n\n    // Compute number of key schedule rows\n    const ksRows = (nRounds + 1) * 4;\n\n    // Compute key schedule\n    this._keySchedule = [];\n    const keySchedule = this._keySchedule;\n    for (let ksRow = 0; ksRow < ksRows; ksRow += 1) {\n      if (ksRow < keySize) {\n        keySchedule[ksRow] = keyWords[ksRow];\n      } else {\n        t = keySchedule[ksRow - 1];\n\n        if (!(ksRow % keySize)) {\n          // Rot word\n          t = (t << 8) | (t >>> 24);\n\n          // Sub word\n          t = (_SBOX[t >>> 24] << 24)\n            | (_SBOX[(t >>> 16) & 0xff] << 16)\n            | (_SBOX[(t >>> 8) & 0xff] << 8)\n            | _SBOX[t & 0xff];\n\n          // Mix Rcon\n          t ^= RCON[(ksRow / keySize) | 0] << 24;\n        } else if (keySize > 6 && ksRow % keySize === 4) {\n          // Sub word\n          t = (_SBOX[t >>> 24] << 24)\n            | (_SBOX[(t >>> 16) & 0xff] << 16)\n            | (_SBOX[(t >>> 8) & 0xff] << 8)\n            | _SBOX[t & 0xff];\n        }\n\n        keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;\n      }\n    }\n\n    // Compute inv key schedule\n    this._invKeySchedule = [];\n    const invKeySchedule = this._invKeySchedule;\n    for (let invKsRow = 0; invKsRow < ksRows; invKsRow += 1) {\n      const ksRow = ksRows - invKsRow;\n\n      if (invKsRow % 4) {\n        t = keySchedule[ksRow];\n      } else {\n        t = keySchedule[ksRow - 4];\n      }\n\n      if (invKsRow < 4 || ksRow <= 4) {\n        invKeySchedule[invKsRow] = t;\n      } else {\n        invKeySchedule[invKsRow] = INV_SUB_MIX_0[_SBOX[t >>> 24]]\n          ^ INV_SUB_MIX_1[_SBOX[(t >>> 16) & 0xff]]\n          ^ INV_SUB_MIX_2[_SBOX[(t >>> 8) & 0xff]]\n          ^ INV_SUB_MIX_3[_SBOX[t & 0xff]];\n      }\n    }\n  }\n\n  encryptBlock(M, offset) {\n    this._doCryptBlock(\n      M, offset, this._keySchedule, _SUB_MIX_0, _SUB_MIX_1, _SUB_MIX_2, _SUB_MIX_3, _SBOX,\n    );\n  }\n\n  decryptBlock(M, offset) {\n    const _M = M;\n\n    // Swap 2nd and 4th rows\n    let t = _M[offset + 1];\n    _M[offset + 1] = _M[offset + 3];\n    _M[offset + 3] = t;\n\n    this._doCryptBlock(\n      _M,\n      offset,\n      this._invKeySchedule,\n      INV_SUB_MIX_0,\n      INV_SUB_MIX_1,\n      INV_SUB_MIX_2,\n      INV_SUB_MIX_3,\n      INV_SBOX,\n    );\n\n    // Inv swap 2nd and 4th rows\n    t = _M[offset + 1];\n    _M[offset + 1] = _M[offset + 3];\n    _M[offset + 3] = t;\n  }\n\n  _doCryptBlock(M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {\n    const _M = M;\n\n    // Shortcut\n    const nRounds = this._nRounds;\n\n    // Get input, add round key\n    let s0 = _M[offset] ^ keySchedule[0];\n    let s1 = _M[offset + 1] ^ keySchedule[1];\n    let s2 = _M[offset + 2] ^ keySchedule[2];\n    let s3 = _M[offset + 3] ^ keySchedule[3];\n\n    // Key schedule row counter\n    let ksRow = 4;\n\n    // Rounds\n    for (let round = 1; round < nRounds; round += 1) {\n      // Shift rows, sub bytes, mix columns, add round key\n      const t0 = SUB_MIX_0[s0 >>> 24]\n        ^ SUB_MIX_1[(s1 >>> 16) & 0xff]\n        ^ SUB_MIX_2[(s2 >>> 8) & 0xff]\n        ^ SUB_MIX_3[s3 & 0xff]\n        ^ keySchedule[ksRow];\n      ksRow += 1;\n      const t1 = SUB_MIX_0[s1 >>> 24]\n        ^ SUB_MIX_1[(s2 >>> 16) & 0xff]\n        ^ SUB_MIX_2[(s3 >>> 8) & 0xff]\n        ^ SUB_MIX_3[s0 & 0xff]\n        ^ keySchedule[ksRow];\n      ksRow += 1;\n      const t2 = SUB_MIX_0[s2 >>> 24]\n        ^ SUB_MIX_1[(s3 >>> 16) & 0xff]\n        ^ SUB_MIX_2[(s0 >>> 8) & 0xff]\n        ^ SUB_MIX_3[s1 & 0xff]\n        ^ keySchedule[ksRow];\n      ksRow += 1;\n      const t3 = SUB_MIX_0[s3 >>> 24]\n        ^ SUB_MIX_1[(s0 >>> 16) & 0xff]\n        ^ SUB_MIX_2[(s1 >>> 8) & 0xff]\n        ^ SUB_MIX_3[s2 & 0xff]\n        ^ keySchedule[ksRow];\n      ksRow += 1;\n\n      // Update state\n      s0 = t0;\n      s1 = t1;\n      s2 = t2;\n      s3 = t3;\n    }\n\n    // Shift rows, sub bytes, add round key\n    const t0 = (\n      (SBOX[s0 >>> 24] << 24)\n        | (SBOX[(s1 >>> 16) & 0xff] << 16)\n        | (SBOX[(s2 >>> 8) & 0xff] << 8)\n        | SBOX[s3 & 0xff]\n    ) ^ keySchedule[ksRow];\n    ksRow += 1;\n    const t1 = (\n      (SBOX[s1 >>> 24] << 24)\n        | (SBOX[(s2 >>> 16) & 0xff] << 16)\n        | (SBOX[(s3 >>> 8) & 0xff] << 8)\n        | SBOX[s0 & 0xff]\n    ) ^ keySchedule[ksRow];\n    ksRow += 1;\n    const t2 = (\n      (SBOX[s2 >>> 24] << 24)\n        | (SBOX[(s3 >>> 16) & 0xff] << 16)\n        | (SBOX[(s0 >>> 8) & 0xff] << 8)\n        | SBOX[s1 & 0xff]\n    ) ^ keySchedule[ksRow];\n    ksRow += 1;\n    const t3 = (\n      (SBOX[s3 >>> 24] << 24)\n        | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]\n    ) ^ keySchedule[ksRow];\n    ksRow += 1;\n\n    // Set output\n    _M[offset] = t0;\n    _M[offset + 1] = t1;\n    _M[offset + 2] = t2;\n    _M[offset + 3] = t3;\n  }\n}\nAESAlgo.keySize = 256 / 32;\n\n/**\n * Shortcut functions to the cipher's object interface.\n *\n * @example\n *\n *     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);\n *     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);\n */\nexport const AES = BlockCipher._createHelper(AESAlgo);\n","import {\n  WordArray,\n} from './core.js';\nimport {\n  BlockCipher,\n} from './cipher-core.js';\n\n// Permuted Choice 1 constants\nconst PC1 = [\n  57, 49, 41, 33, 25, 17, 9, 1,\n  58, 50, 42, 34, 26, 18, 10, 2,\n  59, 51, 43, 35, 27, 19, 11, 3,\n  60, 52, 44, 36, 63, 55, 47, 39,\n  31, 23, 15, 7, 62, 54, 46, 38,\n  30, 22, 14, 6, 61, 53, 45, 37,\n  29, 21, 13, 5, 28, 20, 12, 4,\n];\n\n// Permuted Choice 2 constants\nconst PC2 = [\n  14, 17, 11, 24, 1, 5,\n  3, 28, 15, 6, 21, 10,\n  23, 19, 12, 4, 26, 8,\n  16, 7, 27, 20, 13, 2,\n  41, 52, 31, 37, 47, 55,\n  30, 40, 51, 45, 33, 48,\n  44, 49, 39, 56, 34, 53,\n  46, 42, 50, 36, 29, 32,\n];\n\n// Cumulative bit shift constants\nconst BIT_SHIFTS = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28];\n\n// SBOXes and round permutation constants\nconst SBOX_P = [\n  {\n    0x0: 0x808200,\n    0x10000000: 0x8000,\n    0x20000000: 0x808002,\n    0x30000000: 0x2,\n    0x40000000: 0x200,\n    0x50000000: 0x808202,\n    0x60000000: 0x800202,\n    0x70000000: 0x800000,\n    0x80000000: 0x202,\n    0x90000000: 0x800200,\n    0xa0000000: 0x8200,\n    0xb0000000: 0x808000,\n    0xc0000000: 0x8002,\n    0xd0000000: 0x800002,\n    0xe0000000: 0x0,\n    0xf0000000: 0x8202,\n    0x8000000: 0x0,\n    0x18000000: 0x808202,\n    0x28000000: 0x8202,\n    0x38000000: 0x8000,\n    0x48000000: 0x808200,\n    0x58000000: 0x200,\n    0x68000000: 0x808002,\n    0x78000000: 0x2,\n    0x88000000: 0x800200,\n    0x98000000: 0x8200,\n    0xa8000000: 0x808000,\n    0xb8000000: 0x800202,\n    0xc8000000: 0x800002,\n    0xd8000000: 0x8002,\n    0xe8000000: 0x202,\n    0xf8000000: 0x800000,\n    0x1: 0x8000,\n    0x10000001: 0x2,\n    0x20000001: 0x808200,\n    0x30000001: 0x800000,\n    0x40000001: 0x808002,\n    0x50000001: 0x8200,\n    0x60000001: 0x200,\n    0x70000001: 0x800202,\n    0x80000001: 0x808202,\n    0x90000001: 0x808000,\n    0xa0000001: 0x800002,\n    0xb0000001: 0x8202,\n    0xc0000001: 0x202,\n    0xd0000001: 0x800200,\n    0xe0000001: 0x8002,\n    0xf0000001: 0x0,\n    0x8000001: 0x808202,\n    0x18000001: 0x808000,\n    0x28000001: 0x800000,\n    0x38000001: 0x200,\n    0x48000001: 0x8000,\n    0x58000001: 0x800002,\n    0x68000001: 0x2,\n    0x78000001: 0x8202,\n    0x88000001: 0x8002,\n    0x98000001: 0x800202,\n    0xa8000001: 0x202,\n    0xb8000001: 0x808200,\n    0xc8000001: 0x800200,\n    0xd8000001: 0x0,\n    0xe8000001: 0x8200,\n    0xf8000001: 0x808002,\n  },\n  {\n    0x0: 0x40084010,\n    0x1000000: 0x4000,\n    0x2000000: 0x80000,\n    0x3000000: 0x40080010,\n    0x4000000: 0x40000010,\n    0x5000000: 0x40084000,\n    0x6000000: 0x40004000,\n    0x7000000: 0x10,\n    0x8000000: 0x84000,\n    0x9000000: 0x40004010,\n    0xa000000: 0x40000000,\n    0xb000000: 0x84010,\n    0xc000000: 0x80010,\n    0xd000000: 0x0,\n    0xe000000: 0x4010,\n    0xf000000: 0x40080000,\n    0x800000: 0x40004000,\n    0x1800000: 0x84010,\n    0x2800000: 0x10,\n    0x3800000: 0x40004010,\n    0x4800000: 0x40084010,\n    0x5800000: 0x40000000,\n    0x6800000: 0x80000,\n    0x7800000: 0x40080010,\n    0x8800000: 0x80010,\n    0x9800000: 0x0,\n    0xa800000: 0x4000,\n    0xb800000: 0x40080000,\n    0xc800000: 0x40000010,\n    0xd800000: 0x84000,\n    0xe800000: 0x40084000,\n    0xf800000: 0x4010,\n    0x10000000: 0x0,\n    0x11000000: 0x40080010,\n    0x12000000: 0x40004010,\n    0x13000000: 0x40084000,\n    0x14000000: 0x40080000,\n    0x15000000: 0x10,\n    0x16000000: 0x84010,\n    0x17000000: 0x4000,\n    0x18000000: 0x4010,\n    0x19000000: 0x80000,\n    0x1a000000: 0x80010,\n    0x1b000000: 0x40000010,\n    0x1c000000: 0x84000,\n    0x1d000000: 0x40004000,\n    0x1e000000: 0x40000000,\n    0x1f000000: 0x40084010,\n    0x10800000: 0x84010,\n    0x11800000: 0x80000,\n    0x12800000: 0x40080000,\n    0x13800000: 0x4000,\n    0x14800000: 0x40004000,\n    0x15800000: 0x40084010,\n    0x16800000: 0x10,\n    0x17800000: 0x40000000,\n    0x18800000: 0x40084000,\n    0x19800000: 0x40000010,\n    0x1a800000: 0x40004010,\n    0x1b800000: 0x80010,\n    0x1c800000: 0x0,\n    0x1d800000: 0x4010,\n    0x1e800000: 0x40080010,\n    0x1f800000: 0x84000,\n  },\n  {\n    0x0: 0x104,\n    0x100000: 0x0,\n    0x200000: 0x4000100,\n    0x300000: 0x10104,\n    0x400000: 0x10004,\n    0x500000: 0x4000004,\n    0x600000: 0x4010104,\n    0x700000: 0x4010000,\n    0x800000: 0x4000000,\n    0x900000: 0x4010100,\n    0xa00000: 0x10100,\n    0xb00000: 0x4010004,\n    0xc00000: 0x4000104,\n    0xd00000: 0x10000,\n    0xe00000: 0x4,\n    0xf00000: 0x100,\n    0x80000: 0x4010100,\n    0x180000: 0x4010004,\n    0x280000: 0x0,\n    0x380000: 0x4000100,\n    0x480000: 0x4000004,\n    0x580000: 0x10000,\n    0x680000: 0x10004,\n    0x780000: 0x104,\n    0x880000: 0x4,\n    0x980000: 0x100,\n    0xa80000: 0x4010000,\n    0xb80000: 0x10104,\n    0xc80000: 0x10100,\n    0xd80000: 0x4000104,\n    0xe80000: 0x4010104,\n    0xf80000: 0x4000000,\n    0x1000000: 0x4010100,\n    0x1100000: 0x10004,\n    0x1200000: 0x10000,\n    0x1300000: 0x4000100,\n    0x1400000: 0x100,\n    0x1500000: 0x4010104,\n    0x1600000: 0x4000004,\n    0x1700000: 0x0,\n    0x1800000: 0x4000104,\n    0x1900000: 0x4000000,\n    0x1a00000: 0x4,\n    0x1b00000: 0x10100,\n    0x1c00000: 0x4010000,\n    0x1d00000: 0x104,\n    0x1e00000: 0x10104,\n    0x1f00000: 0x4010004,\n    0x1080000: 0x4000000,\n    0x1180000: 0x104,\n    0x1280000: 0x4010100,\n    0x1380000: 0x0,\n    0x1480000: 0x10004,\n    0x1580000: 0x4000100,\n    0x1680000: 0x100,\n    0x1780000: 0x4010004,\n    0x1880000: 0x10000,\n    0x1980000: 0x4010104,\n    0x1a80000: 0x10104,\n    0x1b80000: 0x4000004,\n    0x1c80000: 0x4000104,\n    0x1d80000: 0x4010000,\n    0x1e80000: 0x4,\n    0x1f80000: 0x10100,\n  },\n  {\n    0x0: 0x80401000,\n    0x10000: 0x80001040,\n    0x20000: 0x401040,\n    0x30000: 0x80400000,\n    0x40000: 0x0,\n    0x50000: 0x401000,\n    0x60000: 0x80000040,\n    0x70000: 0x400040,\n    0x80000: 0x80000000,\n    0x90000: 0x400000,\n    0xa0000: 0x40,\n    0xb0000: 0x80001000,\n    0xc0000: 0x80400040,\n    0xd0000: 0x1040,\n    0xe0000: 0x1000,\n    0xf0000: 0x80401040,\n    0x8000: 0x80001040,\n    0x18000: 0x40,\n    0x28000: 0x80400040,\n    0x38000: 0x80001000,\n    0x48000: 0x401000,\n    0x58000: 0x80401040,\n    0x68000: 0x0,\n    0x78000: 0x80400000,\n    0x88000: 0x1000,\n    0x98000: 0x80401000,\n    0xa8000: 0x400000,\n    0xb8000: 0x1040,\n    0xc8000: 0x80000000,\n    0xd8000: 0x400040,\n    0xe8000: 0x401040,\n    0xf8000: 0x80000040,\n    0x100000: 0x400040,\n    0x110000: 0x401000,\n    0x120000: 0x80000040,\n    0x130000: 0x0,\n    0x140000: 0x1040,\n    0x150000: 0x80400040,\n    0x160000: 0x80401000,\n    0x170000: 0x80001040,\n    0x180000: 0x80401040,\n    0x190000: 0x80000000,\n    0x1a0000: 0x80400000,\n    0x1b0000: 0x401040,\n    0x1c0000: 0x80001000,\n    0x1d0000: 0x400000,\n    0x1e0000: 0x40,\n    0x1f0000: 0x1000,\n    0x108000: 0x80400000,\n    0x118000: 0x80401040,\n    0x128000: 0x0,\n    0x138000: 0x401000,\n    0x148000: 0x400040,\n    0x158000: 0x80000000,\n    0x168000: 0x80001040,\n    0x178000: 0x40,\n    0x188000: 0x80000040,\n    0x198000: 0x1000,\n    0x1a8000: 0x80001000,\n    0x1b8000: 0x80400040,\n    0x1c8000: 0x1040,\n    0x1d8000: 0x80401000,\n    0x1e8000: 0x400000,\n    0x1f8000: 0x401040,\n  },\n  {\n    0x0: 0x80,\n    0x1000: 0x1040000,\n    0x2000: 0x40000,\n    0x3000: 0x20000000,\n    0x4000: 0x20040080,\n    0x5000: 0x1000080,\n    0x6000: 0x21000080,\n    0x7000: 0x40080,\n    0x8000: 0x1000000,\n    0x9000: 0x20040000,\n    0xa000: 0x20000080,\n    0xb000: 0x21040080,\n    0xc000: 0x21040000,\n    0xd000: 0x0,\n    0xe000: 0x1040080,\n    0xf000: 0x21000000,\n    0x800: 0x1040080,\n    0x1800: 0x21000080,\n    0x2800: 0x80,\n    0x3800: 0x1040000,\n    0x4800: 0x40000,\n    0x5800: 0x20040080,\n    0x6800: 0x21040000,\n    0x7800: 0x20000000,\n    0x8800: 0x20040000,\n    0x9800: 0x0,\n    0xa800: 0x21040080,\n    0xb800: 0x1000080,\n    0xc800: 0x20000080,\n    0xd800: 0x21000000,\n    0xe800: 0x1000000,\n    0xf800: 0x40080,\n    0x10000: 0x40000,\n    0x11000: 0x80,\n    0x12000: 0x20000000,\n    0x13000: 0x21000080,\n    0x14000: 0x1000080,\n    0x15000: 0x21040000,\n    0x16000: 0x20040080,\n    0x17000: 0x1000000,\n    0x18000: 0x21040080,\n    0x19000: 0x21000000,\n    0x1a000: 0x1040000,\n    0x1b000: 0x20040000,\n    0x1c000: 0x40080,\n    0x1d000: 0x20000080,\n    0x1e000: 0x0,\n    0x1f000: 0x1040080,\n    0x10800: 0x21000080,\n    0x11800: 0x1000000,\n    0x12800: 0x1040000,\n    0x13800: 0x20040080,\n    0x14800: 0x20000000,\n    0x15800: 0x1040080,\n    0x16800: 0x80,\n    0x17800: 0x21040000,\n    0x18800: 0x40080,\n    0x19800: 0x21040080,\n    0x1a800: 0x0,\n    0x1b800: 0x21000000,\n    0x1c800: 0x1000080,\n    0x1d800: 0x40000,\n    0x1e800: 0x20040000,\n    0x1f800: 0x20000080,\n  },\n  {\n    0x0: 0x10000008,\n    0x100: 0x2000,\n    0x200: 0x10200000,\n    0x300: 0x10202008,\n    0x400: 0x10002000,\n    0x500: 0x200000,\n    0x600: 0x200008,\n    0x700: 0x10000000,\n    0x800: 0x0,\n    0x900: 0x10002008,\n    0xa00: 0x202000,\n    0xb00: 0x8,\n    0xc00: 0x10200008,\n    0xd00: 0x202008,\n    0xe00: 0x2008,\n    0xf00: 0x10202000,\n    0x80: 0x10200000,\n    0x180: 0x10202008,\n    0x280: 0x8,\n    0x380: 0x200000,\n    0x480: 0x202008,\n    0x580: 0x10000008,\n    0x680: 0x10002000,\n    0x780: 0x2008,\n    0x880: 0x200008,\n    0x980: 0x2000,\n    0xa80: 0x10002008,\n    0xb80: 0x10200008,\n    0xc80: 0x0,\n    0xd80: 0x10202000,\n    0xe80: 0x202000,\n    0xf80: 0x10000000,\n    0x1000: 0x10002000,\n    0x1100: 0x10200008,\n    0x1200: 0x10202008,\n    0x1300: 0x2008,\n    0x1400: 0x200000,\n    0x1500: 0x10000000,\n    0x1600: 0x10000008,\n    0x1700: 0x202000,\n    0x1800: 0x202008,\n    0x1900: 0x0,\n    0x1a00: 0x8,\n    0x1b00: 0x10200000,\n    0x1c00: 0x2000,\n    0x1d00: 0x10002008,\n    0x1e00: 0x10202000,\n    0x1f00: 0x200008,\n    0x1080: 0x8,\n    0x1180: 0x202000,\n    0x1280: 0x200000,\n    0x1380: 0x10000008,\n    0x1480: 0x10002000,\n    0x1580: 0x2008,\n    0x1680: 0x10202008,\n    0x1780: 0x10200000,\n    0x1880: 0x10202000,\n    0x1980: 0x10200008,\n    0x1a80: 0x2000,\n    0x1b80: 0x202008,\n    0x1c80: 0x200008,\n    0x1d80: 0x0,\n    0x1e80: 0x10000000,\n    0x1f80: 0x10002008,\n  },\n  {\n    0x0: 0x100000,\n    0x10: 0x2000401,\n    0x20: 0x400,\n    0x30: 0x100401,\n    0x40: 0x2100401,\n    0x50: 0x0,\n    0x60: 0x1,\n    0x70: 0x2100001,\n    0x80: 0x2000400,\n    0x90: 0x100001,\n    0xa0: 0x2000001,\n    0xb0: 0x2100400,\n    0xc0: 0x2100000,\n    0xd0: 0x401,\n    0xe0: 0x100400,\n    0xf0: 0x2000000,\n    0x8: 0x2100001,\n    0x18: 0x0,\n    0x28: 0x2000401,\n    0x38: 0x2100400,\n    0x48: 0x100000,\n    0x58: 0x2000001,\n    0x68: 0x2000000,\n    0x78: 0x401,\n    0x88: 0x100401,\n    0x98: 0x2000400,\n    0xa8: 0x2100000,\n    0xb8: 0x100001,\n    0xc8: 0x400,\n    0xd8: 0x2100401,\n    0xe8: 0x1,\n    0xf8: 0x100400,\n    0x100: 0x2000000,\n    0x110: 0x100000,\n    0x120: 0x2000401,\n    0x130: 0x2100001,\n    0x140: 0x100001,\n    0x150: 0x2000400,\n    0x160: 0x2100400,\n    0x170: 0x100401,\n    0x180: 0x401,\n    0x190: 0x2100401,\n    0x1a0: 0x100400,\n    0x1b0: 0x1,\n    0x1c0: 0x0,\n    0x1d0: 0x2100000,\n    0x1e0: 0x2000001,\n    0x1f0: 0x400,\n    0x108: 0x100400,\n    0x118: 0x2000401,\n    0x128: 0x2100001,\n    0x138: 0x1,\n    0x148: 0x2000000,\n    0x158: 0x100000,\n    0x168: 0x401,\n    0x178: 0x2100400,\n    0x188: 0x2000001,\n    0x198: 0x2100000,\n    0x1a8: 0x0,\n    0x1b8: 0x2100401,\n    0x1c8: 0x100401,\n    0x1d8: 0x400,\n    0x1e8: 0x2000400,\n    0x1f8: 0x100001,\n  },\n  {\n    0x0: 0x8000820,\n    0x1: 0x20000,\n    0x2: 0x8000000,\n    0x3: 0x20,\n    0x4: 0x20020,\n    0x5: 0x8020820,\n    0x6: 0x8020800,\n    0x7: 0x800,\n    0x8: 0x8020000,\n    0x9: 0x8000800,\n    0xa: 0x20800,\n    0xb: 0x8020020,\n    0xc: 0x820,\n    0xd: 0x0,\n    0xe: 0x8000020,\n    0xf: 0x20820,\n    0x80000000: 0x800,\n    0x80000001: 0x8020820,\n    0x80000002: 0x8000820,\n    0x80000003: 0x8000000,\n    0x80000004: 0x8020000,\n    0x80000005: 0x20800,\n    0x80000006: 0x20820,\n    0x80000007: 0x20,\n    0x80000008: 0x8000020,\n    0x80000009: 0x820,\n    0x8000000a: 0x20020,\n    0x8000000b: 0x8020800,\n    0x8000000c: 0x0,\n    0x8000000d: 0x8020020,\n    0x8000000e: 0x8000800,\n    0x8000000f: 0x20000,\n    0x10: 0x20820,\n    0x11: 0x8020800,\n    0x12: 0x20,\n    0x13: 0x800,\n    0x14: 0x8000800,\n    0x15: 0x8000020,\n    0x16: 0x8020020,\n    0x17: 0x20000,\n    0x18: 0x0,\n    0x19: 0x20020,\n    0x1a: 0x8020000,\n    0x1b: 0x8000820,\n    0x1c: 0x8020820,\n    0x1d: 0x20800,\n    0x1e: 0x820,\n    0x1f: 0x8000000,\n    0x80000010: 0x20000,\n    0x80000011: 0x800,\n    0x80000012: 0x8020020,\n    0x80000013: 0x20820,\n    0x80000014: 0x20,\n    0x80000015: 0x8020000,\n    0x80000016: 0x8000000,\n    0x80000017: 0x8000820,\n    0x80000018: 0x8020820,\n    0x80000019: 0x8000020,\n    0x8000001a: 0x8000800,\n    0x8000001b: 0x0,\n    0x8000001c: 0x20800,\n    0x8000001d: 0x820,\n    0x8000001e: 0x20020,\n    0x8000001f: 0x8020800,\n  },\n];\n\n// Masks that select the SBOX input\nconst SBOX_MASK = [\n  0xf8000001, 0x1f800000, 0x01f80000, 0x001f8000,\n  0x0001f800, 0x00001f80, 0x000001f8, 0x8000001f,\n];\n\n// Swap bits across the left and right words\nfunction exchangeLR(offset, mask) {\n  const t = ((this._lBlock >>> offset) ^ this._rBlock) & mask;\n  this._rBlock ^= t;\n  this._lBlock ^= t << offset;\n}\n\nfunction exchangeRL(offset, mask) {\n  const t = ((this._rBlock >>> offset) ^ this._lBlock) & mask;\n  this._lBlock ^= t;\n  this._rBlock ^= t << offset;\n}\n\n/**\n * DES block cipher algorithm.\n */\nexport class DESAlgo extends BlockCipher {\n  constructor(xformMode, key, cfg) {\n    super(xformMode, key, cfg);\n\n    // blickSize is an instance field and should set in constructor.\n    // Both DESAlgo and TripleDESAlgo.\n    this.blockSize = 64 / 32;\n  }\n\n  _doReset() {\n    // Shortcuts\n    const key = this._key;\n    const keyWords = key.words;\n\n    // Select 56 bits according to PC1\n    const keyBits = [];\n    for (let i = 0; i < 56; i += 1) {\n      const keyBitPos = PC1[i] - 1;\n      keyBits[i] = (keyWords[keyBitPos >>> 5] >>> (31 - (keyBitPos % 32))) & 1;\n    }\n\n    // Assemble 16 subkeys\n    this._subKeys = [];\n    const subKeys = this._subKeys;\n    for (let nSubKey = 0; nSubKey < 16; nSubKey += 1) {\n      // Create subkey\n      subKeys[nSubKey] = [];\n      const subKey = subKeys[nSubKey];\n\n      // Shortcut\n      const bitShift = BIT_SHIFTS[nSubKey];\n\n      // Select 48 bits according to PC2\n      for (let i = 0; i < 24; i += 1) {\n        // Select from the left 28 key bits\n        subKey[(i / 6) | 0] |= keyBits[((PC2[i] - 1) + bitShift) % 28] << (31 - (i % 6));\n\n        // Select from the right 28 key bits\n        subKey[4 + ((i / 6) | 0)]\n          |= keyBits[28 + (((PC2[i + 24] - 1) + bitShift) % 28)]\n          << (31 - (i % 6));\n      }\n\n      // Since each subkey is applied to an expanded 32-bit input,\n      // the subkey can be broken into 8 values scaled to 32-bits,\n      // which allows the key to be used without expansion\n      subKey[0] = (subKey[0] << 1) | (subKey[0] >>> 31);\n      for (let i = 1; i < 7; i += 1) {\n        subKey[i] >>>= ((i - 1) * 4 + 3);\n      }\n      subKey[7] = (subKey[7] << 5) | (subKey[7] >>> 27);\n    }\n\n    // Compute inverse subkeys\n    this._invSubKeys = [];\n    const invSubKeys = this._invSubKeys;\n    for (let i = 0; i < 16; i += 1) {\n      invSubKeys[i] = subKeys[15 - i];\n    }\n  }\n\n  encryptBlock(M, offset) {\n    this._doCryptBlock(M, offset, this._subKeys);\n  }\n\n  decryptBlock(M, offset) {\n    this._doCryptBlock(M, offset, this._invSubKeys);\n  }\n\n  _doCryptBlock(M, offset, subKeys) {\n    const _M = M;\n\n    // Get input\n    this._lBlock = M[offset];\n    this._rBlock = M[offset + 1];\n\n    // Initial permutation\n    exchangeLR.call(this, 4, 0x0f0f0f0f);\n    exchangeLR.call(this, 16, 0x0000ffff);\n    exchangeRL.call(this, 2, 0x33333333);\n    exchangeRL.call(this, 8, 0x00ff00ff);\n    exchangeLR.call(this, 1, 0x55555555);\n\n    // Rounds\n    for (let round = 0; round < 16; round += 1) {\n      // Shortcuts\n      const subKey = subKeys[round];\n      const lBlock = this._lBlock;\n      const rBlock = this._rBlock;\n\n      // Feistel function\n      let f = 0;\n      for (let i = 0; i < 8; i += 1) {\n        f |= SBOX_P[i][((rBlock ^ subKey[i]) & SBOX_MASK[i]) >>> 0];\n      }\n      this._lBlock = rBlock;\n      this._rBlock = lBlock ^ f;\n    }\n\n    // Undo swap from last round\n    const t = this._lBlock;\n    this._lBlock = this._rBlock;\n    this._rBlock = t;\n\n    // Final permutation\n    exchangeLR.call(this, 1, 0x55555555);\n    exchangeRL.call(this, 8, 0x00ff00ff);\n    exchangeRL.call(this, 2, 0x33333333);\n    exchangeLR.call(this, 16, 0x0000ffff);\n    exchangeLR.call(this, 4, 0x0f0f0f0f);\n\n    // Set output\n    _M[offset] = this._lBlock;\n    _M[offset + 1] = this._rBlock;\n  }\n}\nDESAlgo.keySize = 64 / 32;\nDESAlgo.ivSize = 64 / 32;\n// blickSize is an instance field and should set in constructor.\n\n/**\n * Shortcut functions to the cipher's object interface.\n *\n * @example\n *\n *     var ciphertext = CryptoJS.DES.encrypt(message, key, cfg);\n *     var plaintext  = CryptoJS.DES.decrypt(ciphertext, key, cfg);\n */\nexport const DES = BlockCipher._createHelper(DESAlgo);\n\n/**\n * Triple-DES block cipher algorithm.\n */\nexport class TripleDESAlgo extends BlockCipher {\n  _doReset() {\n    // Shortcuts\n    const key = this._key;\n    const keyWords = key.words;\n    // Make sure the key length is valid (64, 128 or >= 192 bit)\n    if (keyWords.length !== 2 && keyWords.length !== 4 && keyWords.length < 6) {\n      throw new Error('Invalid key length - 3DES requires the key length to be 64, 128, 192 or >192.');\n    }\n\n    // Extend the key according to the keying options defined in 3DES standard\n    const key1 = keyWords.slice(0, 2);\n    const key2 = keyWords.length < 4 ? keyWords.slice(0, 2) : keyWords.slice(2, 4);\n    const key3 = keyWords.length < 6 ? keyWords.slice(0, 2) : keyWords.slice(4, 6);\n\n    // Create DES instances\n    this._des1 = DESAlgo.createEncryptor(WordArray.create(key1));\n    this._des2 = DESAlgo.createEncryptor(WordArray.create(key2));\n    this._des3 = DESAlgo.createEncryptor(WordArray.create(key3));\n  }\n\n  encryptBlock(M, offset) {\n    this._des1.encryptBlock(M, offset);\n    this._des2.decryptBlock(M, offset);\n    this._des3.encryptBlock(M, offset);\n  }\n\n  decryptBlock(M, offset) {\n    this._des3.decryptBlock(M, offset);\n    this._des2.encryptBlock(M, offset);\n    this._des1.decryptBlock(M, offset);\n  }\n}\nTripleDESAlgo.keySize = 192 / 32;\nTripleDESAlgo.ivSize = 64 / 32;\n// blickSize is an instance field and should set in constructor.\n\n/**\n * Shortcut functions to the cipher's object interface.\n *\n * @example\n *\n *     var ciphertext = CryptoJS.TripleDES.encrypt(message, key, cfg);\n *     var plaintext  = CryptoJS.TripleDES.decrypt(ciphertext, key, cfg);\n */\nexport const TripleDES = BlockCipher._createHelper(TripleDESAlgo);\n","import {\n  StreamCipher,\n} from './cipher-core.js';\n\n// Reusable objects\nconst S = [];\nconst C_ = [];\nconst G = [];\n\nfunction nextState() {\n  // Shortcuts\n  const X = this._X;\n  const C = this._C;\n\n  // Save old counter values\n  for (let i = 0; i < 8; i += 1) {\n    C_[i] = C[i];\n  }\n\n  // Calculate new counter values\n  C[0] = (C[0] + 0x4d34d34d + this._b) | 0;\n  C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;\n  C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;\n  C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;\n  C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;\n  C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;\n  C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;\n  C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;\n  this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;\n\n  // Calculate the g-values\n  for (let i = 0; i < 8; i += 1) {\n    const gx = X[i] + C[i];\n\n    // Construct high and low argument for squaring\n    const ga = gx & 0xffff;\n    const gb = gx >>> 16;\n\n    // Calculate high and low result of squaring\n    const gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;\n    const gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);\n\n    // High XOR low\n    G[i] = gh ^ gl;\n  }\n\n  // Calculate new state values\n  X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;\n  X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0;\n  X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;\n  X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0;\n  X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;\n  X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0;\n  X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;\n  X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0;\n}\n\n/**\n * Rabbit stream cipher algorithm\n */\nexport class RabbitAlgo extends StreamCipher {\n  constructor(...args) {\n    super(...args);\n\n    this.blockSize = 128 / 32;\n    this.ivSize = 64 / 32;\n  }\n\n  _doReset() {\n    // Shortcuts\n    const K = this._key.words;\n    const { iv } = this.cfg;\n\n    // Swap endian\n    for (let i = 0; i < 4; i += 1) {\n      K[i] = (((K[i] << 8) | (K[i] >>> 24)) & 0x00ff00ff)\n        | (((K[i] << 24) | (K[i] >>> 8)) & 0xff00ff00);\n    }\n\n    // Generate initial state values\n    this._X = [\n      K[0], (K[3] << 16) | (K[2] >>> 16),\n      K[1], (K[0] << 16) | (K[3] >>> 16),\n      K[2], (K[1] << 16) | (K[0] >>> 16),\n      K[3], (K[2] << 16) | (K[1] >>> 16),\n    ];\n    const X = this._X;\n\n    // Generate initial counter values\n    this._C = [\n      (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),\n      (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),\n      (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),\n      (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff),\n    ];\n    const C = this._C;\n\n    // Carry bit\n    this._b = 0;\n\n    // Iterate the system four times\n    for (let i = 0; i < 4; i += 1) {\n      nextState.call(this);\n    }\n\n    // Modify the counters\n    for (let i = 0; i < 8; i += 1) {\n      C[i] ^= X[(i + 4) & 7];\n    }\n\n    // IV setup\n    if (iv) {\n      // Shortcuts\n      const IV = iv.words;\n      const IV_0 = IV[0];\n      const IV_1 = IV[1];\n\n      // Generate four subvectors\n      const i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff)\n        | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);\n      const i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff)\n        | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);\n      const i1 = (i0 >>> 16) | (i2 & 0xffff0000);\n      const i3 = (i2 << 16) | (i0 & 0x0000ffff);\n\n      // Modify counter values\n      C[0] ^= i0;\n      C[1] ^= i1;\n      C[2] ^= i2;\n      C[3] ^= i3;\n      C[4] ^= i0;\n      C[5] ^= i1;\n      C[6] ^= i2;\n      C[7] ^= i3;\n\n      // Iterate the system four times\n      for (let i = 0; i < 4; i += 1) {\n        nextState.call(this);\n      }\n    }\n  }\n\n  _doProcessBlock(M, offset) {\n    const _M = M;\n\n    // Shortcut\n    const X = this._X;\n\n    // Iterate the system\n    nextState.call(this);\n\n    // Generate four keystream words\n    S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);\n    S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);\n    S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);\n    S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);\n\n    for (let i = 0; i < 4; i += 1) {\n      // Swap endian\n      S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff)\n        | (((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00);\n\n      // Encrypt\n      _M[offset + i] ^= S[i];\n    }\n  }\n}\n\n/**\n * Shortcut functions to the cipher's object interface.\n *\n * @example\n *\n *     var ciphertext = CryptoJS.Rabbit.encrypt(message, key, cfg);\n *     var plaintext  = CryptoJS.Rabbit.decrypt(ciphertext, key, cfg);\n */\nexport const Rabbit = StreamCipher._createHelper(RabbitAlgo);\n","import {\n  StreamCipher,\n} from './cipher-core.js';\n\n// Reusable objects\nconst S = [];\nconst C_ = [];\nconst G = [];\n\nfunction nextState() {\n  // Shortcuts\n  const X = this._X;\n  const C = this._C;\n\n  // Save old counter values\n  for (let i = 0; i < 8; i += 1) {\n    C_[i] = C[i];\n  }\n\n  // Calculate new counter values\n  C[0] = (C[0] + 0x4d34d34d + this._b) | 0;\n  C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;\n  C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;\n  C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;\n  C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;\n  C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;\n  C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;\n  C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;\n  this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;\n\n  // Calculate the g-values\n  for (let i = 0; i < 8; i += 1) {\n    const gx = X[i] + C[i];\n\n    // Construct high and low argument for squaring\n    const ga = gx & 0xffff;\n    const gb = gx >>> 16;\n\n    // Calculate high and low result of squaring\n    const gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;\n    const gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);\n\n    // High XOR low\n    G[i] = gh ^ gl;\n  }\n\n  // Calculate new state values\n  X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;\n  X[1] = (G[1] + ((G[0] << 8) | (G[0] >>> 24)) + G[7]) | 0;\n  X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;\n  X[3] = (G[3] + ((G[2] << 8) | (G[2] >>> 24)) + G[1]) | 0;\n  X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;\n  X[5] = (G[5] + ((G[4] << 8) | (G[4] >>> 24)) + G[3]) | 0;\n  X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;\n  X[7] = (G[7] + ((G[6] << 8) | (G[6] >>> 24)) + G[5]) | 0;\n}\n\n/**\n * Rabbit stream cipher algorithm.\n *\n * This is a legacy version that neglected to convert the key to little-endian.\n * This error doesn't affect the cipher's security,\n * but it does affect its compatibility with other implementations.\n */\nexport class RabbitLegacyAlgo extends StreamCipher {\n  constructor(...args) {\n    super(...args);\n\n    this.blockSize = 128 / 32;\n    this.ivSize = 64 / 32;\n  }\n\n  _doReset() {\n    // Shortcuts\n    const K = this._key.words;\n    const { iv } = this.cfg;\n\n    // Generate initial state values\n    this._X = [\n      K[0], (K[3] << 16) | (K[2] >>> 16),\n      K[1], (K[0] << 16) | (K[3] >>> 16),\n      K[2], (K[1] << 16) | (K[0] >>> 16),\n      K[3], (K[2] << 16) | (K[1] >>> 16),\n    ];\n    const X = this._X;\n\n    // Generate initial counter values\n    this._C = [\n      (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),\n      (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),\n      (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),\n      (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff),\n    ];\n    const C = this._C;\n\n    // Carry bit\n    this._b = 0;\n\n    // Iterate the system four times\n    for (let i = 0; i < 4; i += 1) {\n      nextState.call(this);\n    }\n\n    // Modify the counters\n    for (let i = 0; i < 8; i += 1) {\n      C[i] ^= X[(i + 4) & 7];\n    }\n\n    // IV setup\n    if (iv) {\n      // Shortcuts\n      const IV = iv.words;\n      const IV_0 = IV[0];\n      const IV_1 = IV[1];\n\n      // Generate four subvectors\n      const i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff)\n        | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);\n      const i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff)\n        | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);\n      const i1 = (i0 >>> 16) | (i2 & 0xffff0000);\n      const i3 = (i2 << 16) | (i0 & 0x0000ffff);\n\n      // Modify counter values\n      C[0] ^= i0;\n      C[1] ^= i1;\n      C[2] ^= i2;\n      C[3] ^= i3;\n      C[4] ^= i0;\n      C[5] ^= i1;\n      C[6] ^= i2;\n      C[7] ^= i3;\n\n      // Iterate the system four times\n      for (let i = 0; i < 4; i += 1) {\n        nextState.call(this);\n      }\n    }\n  }\n\n  _doProcessBlock(M, offset) {\n    const _M = M;\n\n    // Shortcut\n    const X = this._X;\n\n    // Iterate the system\n    nextState.call(this);\n\n    // Generate four keystream words\n    S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);\n    S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);\n    S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);\n    S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);\n\n    for (let i = 0; i < 4; i += 1) {\n      // Swap endian\n      S[i] = (((S[i] << 8) | (S[i] >>> 24)) & 0x00ff00ff)\n        | (((S[i] << 24) | (S[i] >>> 8)) & 0xff00ff00);\n\n      // Encrypt\n      _M[offset + i] ^= S[i];\n    }\n  }\n}\n\n/**\n * Shortcut functions to the cipher's object interface.\n *\n * @example\n *\n *     var ciphertext = CryptoJS.RabbitLegacy.encrypt(message, key, cfg);\n *     var plaintext  = CryptoJS.RabbitLegacy.decrypt(ciphertext, key, cfg);\n */\nexport const RabbitLegacy = StreamCipher._createHelper(RabbitLegacyAlgo);\n","import {\n  StreamCipher,\n} from './cipher-core.js';\n\nfunction generateKeystreamWord() {\n  // Shortcuts\n  const S = this._S;\n  let i = this._i;\n  let j = this._j;\n\n  // Generate keystream word\n  let keystreamWord = 0;\n  for (let n = 0; n < 4; n += 1) {\n    i = (i + 1) % 256;\n    j = (j + S[i]) % 256;\n\n    // Swap\n    const t = S[i];\n    S[i] = S[j];\n    S[j] = t;\n\n    keystreamWord |= S[(S[i] + S[j]) % 256] << (24 - n * 8);\n  }\n\n  // Update counters\n  this._i = i;\n  this._j = j;\n\n  return keystreamWord;\n}\n\n/**\n * RC4 stream cipher algorithm.\n */\nexport class RC4Algo extends StreamCipher {\n  _doReset() {\n    // Shortcuts\n    const key = this._key;\n    const keyWords = key.words;\n    const keySigBytes = key.sigBytes;\n\n    // Init sbox\n    this._S = [];\n    const S = this._S;\n    for (let i = 0; i < 256; i += 1) {\n      S[i] = i;\n    }\n\n    // Key setup\n    for (let i = 0, j = 0; i < 256; i += 1) {\n      const keyByteIndex = i % keySigBytes;\n      const keyByte = (keyWords[keyByteIndex >>> 2] >>> (24 - (keyByteIndex % 4) * 8)) & 0xff;\n\n      j = (j + S[i] + keyByte) % 256;\n\n      // Swap\n      const t = S[i];\n      S[i] = S[j];\n      S[j] = t;\n    }\n\n    // Counters\n    this._j = 0;\n    this._i = this._j;\n  }\n\n  _doProcessBlock(M, offset) {\n    const _M = M;\n\n    _M[offset] ^= generateKeystreamWord.call(this);\n  }\n}\nRC4Algo.keySize = 256 / 32;\nRC4Algo.ivSize = 0;\n\n/**\n * Shortcut functions to the cipher's object interface.\n *\n * @example\n *\n *     var ciphertext = CryptoJS.RC4.encrypt(message, key, cfg);\n *     var plaintext  = CryptoJS.RC4.decrypt(ciphertext, key, cfg);\n */\nexport const RC4 = StreamCipher._createHelper(RC4Algo);\n\n/**\n * Modified RC4 stream cipher algorithm.\n */\nexport class RC4DropAlgo extends RC4Algo {\n  constructor(...args) {\n    super(...args);\n\n    /**\n     * Configuration options.\n     *\n     * @property {number} drop The number of keystream words to drop. Default 192\n     */\n    Object.assign(this.cfg, { drop: 192 });\n  }\n\n  _doReset() {\n    super._doReset.call(this);\n\n    // Drop\n    for (let i = this.cfg.drop; i > 0; i -= 1) {\n      generateKeystreamWord.call(this);\n    }\n  }\n}\n\n/**\n * Shortcut functions to the cipher's object interface.\n *\n * @example\n *\n *     var ciphertext = CryptoJS.RC4Drop.encrypt(message, key, cfg);\n *     var plaintext  = CryptoJS.RC4Drop.decrypt(ciphertext, key, cfg);\n */\nexport const RC4Drop = StreamCipher._createHelper(RC4DropAlgo);\n","import {\n  WordArray,\n} from './core.js';\nimport {\n  BlockCipher,\n} from './cipher-core.js';\n\nconst N = 16;\n    \n//Origin pbox and sbox, derived from PI\nconst ORIG_P = [\n  0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344,\n  0xA4093822, 0x299F31D0, 0x082EFA98, 0xEC4E6C89,\n  0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C,\n  0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917,\n  0x9216D5D9, 0x8979FB1B,\n];\n\nconst ORIG_S = [\n  [0xD1310BA6, 0x98DFB5AC, 0x2FFD72DB, 0xD01ADFB7,\n  0xB8E1AFED, 0x6A267E96, 0xBA7C9045, 0xF12C7F99,\n  0x24A19947, 0xB3916CF7, 0x0801F2E2, 0x858EFC16,\n  0x636920D8, 0x71574E69, 0xA458FEA3, 0xF4933D7E,\n  0x0D95748F, 0x728EB658, 0x718BCD58, 0x82154AEE,\n  0x7B54A41D, 0xC25A59B5, 0x9C30D539, 0x2AF26013,\n  0xC5D1B023, 0x286085F0, 0xCA417918, 0xB8DB38EF,\n  0x8E79DCB0, 0x603A180E, 0x6C9E0E8B, 0xB01E8A3E,\n  0xD71577C1, 0xBD314B27, 0x78AF2FDA, 0x55605C60,\n  0xE65525F3, 0xAA55AB94, 0x57489862, 0x63E81440,\n  0x55CA396A, 0x2AAB10B6, 0xB4CC5C34, 0x1141E8CE,\n  0xA15486AF, 0x7C72E993, 0xB3EE1411, 0x636FBC2A,\n  0x2BA9C55D, 0x741831F6, 0xCE5C3E16, 0x9B87931E,\n  0xAFD6BA33, 0x6C24CF5C, 0x7A325381, 0x28958677,\n  0x3B8F4898, 0x6B4BB9AF, 0xC4BFE81B, 0x66282193,\n  0x61D809CC, 0xFB21A991, 0x487CAC60, 0x5DEC8032,\n  0xEF845D5D, 0xE98575B1, 0xDC262302, 0xEB651B88,\n  0x23893E81, 0xD396ACC5, 0x0F6D6FF3, 0x83F44239,\n  0x2E0B4482, 0xA4842004, 0x69C8F04A, 0x9E1F9B5E,\n  0x21C66842, 0xF6E96C9A, 0x670C9C61, 0xABD388F0,\n  0x6A51A0D2, 0xD8542F68, 0x960FA728, 0xAB5133A3,\n  0x6EEF0B6C, 0x137A3BE4, 0xBA3BF050, 0x7EFB2A98,\n  0xA1F1651D, 0x39AF0176, 0x66CA593E, 0x82430E88,\n  0x8CEE8619, 0x456F9FB4, 0x7D84A5C3, 0x3B8B5EBE,\n  0xE06F75D8, 0x85C12073, 0x401A449F, 0x56C16AA6,\n  0x4ED3AA62, 0x363F7706, 0x1BFEDF72, 0x429B023D,\n  0x37D0D724, 0xD00A1248, 0xDB0FEAD3, 0x49F1C09B,\n  0x075372C9, 0x80991B7B, 0x25D479D8, 0xF6E8DEF7,\n  0xE3FE501A, 0xB6794C3B, 0x976CE0BD, 0x04C006BA,\n  0xC1A94FB6, 0x409F60C4, 0x5E5C9EC2, 0x196A2463,\n  0x68FB6FAF, 0x3E6C53B5, 0x1339B2EB, 0x3B52EC6F,\n  0x6DFC511F, 0x9B30952C, 0xCC814544, 0xAF5EBD09,\n  0xBEE3D004, 0xDE334AFD, 0x660F2807, 0x192E4BB3,\n  0xC0CBA857, 0x45C8740F, 0xD20B5F39, 0xB9D3FBDB,\n  0x5579C0BD, 0x1A60320A, 0xD6A100C6, 0x402C7279,\n  0x679F25FE, 0xFB1FA3CC, 0x8EA5E9F8, 0xDB3222F8,\n  0x3C7516DF, 0xFD616B15, 0x2F501EC8, 0xAD0552AB,\n  0x323DB5FA, 0xFD238760, 0x53317B48, 0x3E00DF82,\n  0x9E5C57BB, 0xCA6F8CA0, 0x1A87562E, 0xDF1769DB,\n  0xD542A8F6, 0x287EFFC3, 0xAC6732C6, 0x8C4F5573,\n  0x695B27B0, 0xBBCA58C8, 0xE1FFA35D, 0xB8F011A0,\n  0x10FA3D98, 0xFD2183B8, 0x4AFCB56C, 0x2DD1D35B,\n  0x9A53E479, 0xB6F84565, 0xD28E49BC, 0x4BFB9790,\n  0xE1DDF2DA, 0xA4CB7E33, 0x62FB1341, 0xCEE4C6E8,\n  0xEF20CADA, 0x36774C01, 0xD07E9EFE, 0x2BF11FB4,\n  0x95DBDA4D, 0xAE909198, 0xEAAD8E71, 0x6B93D5A0,\n  0xD08ED1D0, 0xAFC725E0, 0x8E3C5B2F, 0x8E7594B7,\n  0x8FF6E2FB, 0xF2122B64, 0x8888B812, 0x900DF01C,\n  0x4FAD5EA0, 0x688FC31C, 0xD1CFF191, 0xB3A8C1AD,\n  0x2F2F2218, 0xBE0E1777, 0xEA752DFE, 0x8B021FA1,\n  0xE5A0CC0F, 0xB56F74E8, 0x18ACF3D6, 0xCE89E299,\n  0xB4A84FE0, 0xFD13E0B7, 0x7CC43B81, 0xD2ADA8D9,\n  0x165FA266, 0x80957705, 0x93CC7314, 0x211A1477,\n  0xE6AD2065, 0x77B5FA86, 0xC75442F5, 0xFB9D35CF,\n  0xEBCDAF0C, 0x7B3E89A0, 0xD6411BD3, 0xAE1E7E49,\n  0x00250E2D, 0x2071B35E, 0x226800BB, 0x57B8E0AF,\n  0x2464369B, 0xF009B91E, 0x5563911D, 0x59DFA6AA,\n  0x78C14389, 0xD95A537F, 0x207D5BA2, 0x02E5B9C5,\n  0x83260376, 0x6295CFA9, 0x11C81968, 0x4E734A41,\n  0xB3472DCA, 0x7B14A94A, 0x1B510052, 0x9A532915,\n  0xD60F573F, 0xBC9BC6E4, 0x2B60A476, 0x81E67400,\n  0x08BA6FB5, 0x571BE91F, 0xF296EC6B, 0x2A0DD915,\n  0xB6636521, 0xE7B9F9B6, 0xFF34052E, 0xC5855664,\n  0x53B02D5D, 0xA99F8FA1, 0x08BA4799, 0x6E85076A,],\n  [0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623,\n  0xAD6EA6B0, 0x49A7DF7D, 0x9CEE60B8, 0x8FEDB266,\n  0xECAA8C71, 0x699A17FF, 0x5664526C, 0xC2B19EE1,\n  0x193602A5, 0x75094C29, 0xA0591340, 0xE4183A3E,\n  0x3F54989A, 0x5B429D65, 0x6B8FE4D6, 0x99F73FD6,\n  0xA1D29C07, 0xEFE830F5, 0x4D2D38E6, 0xF0255DC1,\n  0x4CDD2086, 0x8470EB26, 0x6382E9C6, 0x021ECC5E,\n  0x09686B3F, 0x3EBAEFC9, 0x3C971814, 0x6B6A70A1,\n  0x687F3584, 0x52A0E286, 0xB79C5305, 0xAA500737,\n  0x3E07841C, 0x7FDEAE5C, 0x8E7D44EC, 0x5716F2B8,\n  0xB03ADA37, 0xF0500C0D, 0xF01C1F04, 0x0200B3FF,\n  0xAE0CF51A, 0x3CB574B2, 0x25837A58, 0xDC0921BD,\n  0xD19113F9, 0x7CA92FF6, 0x94324773, 0x22F54701,\n  0x3AE5E581, 0x37C2DADC, 0xC8B57634, 0x9AF3DDA7,\n  0xA9446146, 0x0FD0030E, 0xECC8C73E, 0xA4751E41,\n  0xE238CD99, 0x3BEA0E2F, 0x3280BBA1, 0x183EB331,\n  0x4E548B38, 0x4F6DB908, 0x6F420D03, 0xF60A04BF,\n  0x2CB81290, 0x24977C79, 0x5679B072, 0xBCAF89AF,\n  0xDE9A771F, 0xD9930810, 0xB38BAE12, 0xDCCF3F2E,\n  0x5512721F, 0x2E6B7124, 0x501ADDE6, 0x9F84CD87,\n  0x7A584718, 0x7408DA17, 0xBC9F9ABC, 0xE94B7D8C,\n  0xEC7AEC3A, 0xDB851DFA, 0x63094366, 0xC464C3D2,\n  0xEF1C1847, 0x3215D908, 0xDD433B37, 0x24C2BA16,\n  0x12A14D43, 0x2A65C451, 0x50940002, 0x133AE4DD,\n  0x71DFF89E, 0x10314E55, 0x81AC77D6, 0x5F11199B,\n  0x043556F1, 0xD7A3C76B, 0x3C11183B, 0x5924A509,\n  0xF28FE6ED, 0x97F1FBFA, 0x9EBABF2C, 0x1E153C6E,\n  0x86E34570, 0xEAE96FB1, 0x860E5E0A, 0x5A3E2AB3,\n  0x771FE71C, 0x4E3D06FA, 0x2965DCB9, 0x99E71D0F,\n  0x803E89D6, 0x5266C825, 0x2E4CC978, 0x9C10B36A,\n  0xC6150EBA, 0x94E2EA78, 0xA5FC3C53, 0x1E0A2DF4,\n  0xF2F74EA7, 0x361D2B3D, 0x1939260F, 0x19C27960,\n  0x5223A708, 0xF71312B6, 0xEBADFE6E, 0xEAC31F66,\n  0xE3BC4595, 0xA67BC883, 0xB17F37D1, 0x018CFF28,\n  0xC332DDEF, 0xBE6C5AA5, 0x65582185, 0x68AB9802,\n  0xEECEA50F, 0xDB2F953B, 0x2AEF7DAD, 0x5B6E2F84,\n  0x1521B628, 0x29076170, 0xECDD4775, 0x619F1510,\n  0x13CCA830, 0xEB61BD96, 0x0334FE1E, 0xAA0363CF,\n  0xB5735C90, 0x4C70A239, 0xD59E9E0B, 0xCBAADE14,\n  0xEECC86BC, 0x60622CA7, 0x9CAB5CAB, 0xB2F3846E,\n  0x648B1EAF, 0x19BDF0CA, 0xA02369B9, 0x655ABB50,\n  0x40685A32, 0x3C2AB4B3, 0x319EE9D5, 0xC021B8F7,\n  0x9B540B19, 0x875FA099, 0x95F7997E, 0x623D7DA8,\n  0xF837889A, 0x97E32D77, 0x11ED935F, 0x16681281,\n  0x0E358829, 0xC7E61FD6, 0x96DEDFA1, 0x7858BA99,\n  0x57F584A5, 0x1B227263, 0x9B83C3FF, 0x1AC24696,\n  0xCDB30AEB, 0x532E3054, 0x8FD948E4, 0x6DBC3128,\n  0x58EBF2EF, 0x34C6FFEA, 0xFE28ED61, 0xEE7C3C73,\n  0x5D4A14D9, 0xE864B7E3, 0x42105D14, 0x203E13E0,\n  0x45EEE2B6, 0xA3AAABEA, 0xDB6C4F15, 0xFACB4FD0,\n  0xC742F442, 0xEF6ABBB5, 0x654F3B1D, 0x41CD2105,\n  0xD81E799E, 0x86854DC7, 0xE44B476A, 0x3D816250,\n  0xCF62A1F2, 0x5B8D2646, 0xFC8883A0, 0xC1C7B6A3,\n  0x7F1524C3, 0x69CB7492, 0x47848A0B, 0x5692B285,\n  0x095BBF00, 0xAD19489D, 0x1462B174, 0x23820E00,\n  0x58428D2A, 0x0C55F5EA, 0x1DADF43E, 0x233F7061,\n  0x3372F092, 0x8D937E41, 0xD65FECF1, 0x6C223BDB,\n  0x7CDE3759, 0xCBEE7460, 0x4085F2A7, 0xCE77326E,\n  0xA6078084, 0x19F8509E, 0xE8EFD855, 0x61D99735,\n  0xA969A7AA, 0xC50C06C2, 0x5A04ABFC, 0x800BCADC,\n  0x9E447A2E, 0xC3453484, 0xFDD56705, 0x0E1E9EC9,\n  0xDB73DBD3, 0x105588CD, 0x675FDA79, 0xE3674340,\n  0xC5C43465, 0x713E38D8, 0x3D28F89E, 0xF16DFF20,\n  0x153E21E7, 0x8FB03D4A, 0xE6E39F2B, 0xDB83ADF7,],\n  [0xE93D5A68, 0x948140F7, 0xF64C261C, 0x94692934,\n  0x411520F7, 0x7602D4F7, 0xBCF46B2E, 0xD4A20068,\n  0xD4082471, 0x3320F46A, 0x43B7D4B7, 0x500061AF,\n  0x1E39F62E, 0x97244546, 0x14214F74, 0xBF8B8840,\n  0x4D95FC1D, 0x96B591AF, 0x70F4DDD3, 0x66A02F45,\n  0xBFBC09EC, 0x03BD9785, 0x7FAC6DD0, 0x31CB8504,\n  0x96EB27B3, 0x55FD3941, 0xDA2547E6, 0xABCA0A9A,\n  0x28507825, 0x530429F4, 0x0A2C86DA, 0xE9B66DFB,\n  0x68DC1462, 0xD7486900, 0x680EC0A4, 0x27A18DEE,\n  0x4F3FFEA2, 0xE887AD8C, 0xB58CE006, 0x7AF4D6B6,\n  0xAACE1E7C, 0xD3375FEC, 0xCE78A399, 0x406B2A42,\n  0x20FE9E35, 0xD9F385B9, 0xEE39D7AB, 0x3B124E8B,\n  0x1DC9FAF7, 0x4B6D1856, 0x26A36631, 0xEAE397B2,\n  0x3A6EFA74, 0xDD5B4332, 0x6841E7F7, 0xCA7820FB,\n  0xFB0AF54E, 0xD8FEB397, 0x454056AC, 0xBA489527,\n  0x55533A3A, 0x20838D87, 0xFE6BA9B7, 0xD096954B,\n  0x55A867BC, 0xA1159A58, 0xCCA92963, 0x99E1DB33,\n  0xA62A4A56, 0x3F3125F9, 0x5EF47E1C, 0x9029317C,\n  0xFDF8E802, 0x04272F70, 0x80BB155C, 0x05282CE3,\n  0x95C11548, 0xE4C66D22, 0x48C1133F, 0xC70F86DC,\n  0x07F9C9EE, 0x41041F0F, 0x404779A4, 0x5D886E17,\n  0x325F51EB, 0xD59BC0D1, 0xF2BCC18F, 0x41113564,\n  0x257B7834, 0x602A9C60, 0xDFF8E8A3, 0x1F636C1B,\n  0x0E12B4C2, 0x02E1329E, 0xAF664FD1, 0xCAD18115,\n  0x6B2395E0, 0x333E92E1, 0x3B240B62, 0xEEBEB922,\n  0x85B2A20E, 0xE6BA0D99, 0xDE720C8C, 0x2DA2F728,\n  0xD0127845, 0x95B794FD, 0x647D0862, 0xE7CCF5F0,\n  0x5449A36F, 0x877D48FA, 0xC39DFD27, 0xF33E8D1E,\n  0x0A476341, 0x992EFF74, 0x3A6F6EAB, 0xF4F8FD37,\n  0xA812DC60, 0xA1EBDDF8, 0x991BE14C, 0xDB6E6B0D,\n  0xC67B5510, 0x6D672C37, 0x2765D43B, 0xDCD0E804,\n  0xF1290DC7, 0xCC00FFA3, 0xB5390F92, 0x690FED0B,\n  0x667B9FFB, 0xCEDB7D9C, 0xA091CF0B, 0xD9155EA3,\n  0xBB132F88, 0x515BAD24, 0x7B9479BF, 0x763BD6EB,\n  0x37392EB3, 0xCC115979, 0x8026E297, 0xF42E312D,\n  0x6842ADA7, 0xC66A2B3B, 0x12754CCC, 0x782EF11C,\n  0x6A124237, 0xB79251E7, 0x06A1BBE6, 0x4BFB6350,\n  0x1A6B1018, 0x11CAEDFA, 0x3D25BDD8, 0xE2E1C3C9,\n  0x44421659, 0x0A121386, 0xD90CEC6E, 0xD5ABEA2A,\n  0x64AF674E, 0xDA86A85F, 0xBEBFE988, 0x64E4C3FE,\n  0x9DBC8057, 0xF0F7C086, 0x60787BF8, 0x6003604D,\n  0xD1FD8346, 0xF6381FB0, 0x7745AE04, 0xD736FCCC,\n  0x83426B33, 0xF01EAB71, 0xB0804187, 0x3C005E5F,\n  0x77A057BE, 0xBDE8AE24, 0x55464299, 0xBF582E61,\n  0x4E58F48F, 0xF2DDFDA2, 0xF474EF38, 0x8789BDC2,\n  0x5366F9C3, 0xC8B38E74, 0xB475F255, 0x46FCD9B9,\n  0x7AEB2661, 0x8B1DDF84, 0x846A0E79, 0x915F95E2,\n  0x466E598E, 0x20B45770, 0x8CD55591, 0xC902DE4C,\n  0xB90BACE1, 0xBB8205D0, 0x11A86248, 0x7574A99E,\n  0xB77F19B6, 0xE0A9DC09, 0x662D09A1, 0xC4324633,\n  0xE85A1F02, 0x09F0BE8C, 0x4A99A025, 0x1D6EFE10,\n  0x1AB93D1D, 0x0BA5A4DF, 0xA186F20F, 0x2868F169,\n  0xDCB7DA83, 0x573906FE, 0xA1E2CE9B, 0x4FCD7F52,\n  0x50115E01, 0xA70683FA, 0xA002B5C4, 0x0DE6D027,\n  0x9AF88C27, 0x773F8641, 0xC3604C06, 0x61A806B5,\n  0xF0177A28, 0xC0F586E0, 0x006058AA, 0x30DC7D62,\n  0x11E69ED7, 0x2338EA63, 0x53C2DD94, 0xC2C21634,\n  0xBBCBEE56, 0x90BCB6DE, 0xEBFC7DA1, 0xCE591D76,\n  0x6F05E409, 0x4B7C0188, 0x39720A3D, 0x7C927C24,\n  0x86E3725F, 0x724D9DB9, 0x1AC15BB4, 0xD39EB8FC,\n  0xED545578, 0x08FCA5B5, 0xD83D7CD3, 0x4DAD0FC4,\n  0x1E50EF5E, 0xB161E6F8, 0xA28514D9, 0x6C51133C,\n  0x6FD5C7E7, 0x56E14EC4, 0x362ABFCE, 0xDDC6C837,\n  0xD79A3234, 0x92638212, 0x670EFA8E, 0x406000E0,],\n  [0x3A39CE37, 0xD3FAF5CF, 0xABC27737, 0x5AC52D1B,\n  0x5CB0679E, 0x4FA33742, 0xD3822740, 0x99BC9BBE,\n  0xD5118E9D, 0xBF0F7315, 0xD62D1C7E, 0xC700C47B,\n  0xB78C1B6B, 0x21A19045, 0xB26EB1BE, 0x6A366EB4,\n  0x5748AB2F, 0xBC946E79, 0xC6A376D2, 0x6549C2C8,\n  0x530FF8EE, 0x468DDE7D, 0xD5730A1D, 0x4CD04DC6,\n  0x2939BBDB, 0xA9BA4650, 0xAC9526E8, 0xBE5EE304,\n  0xA1FAD5F0, 0x6A2D519A, 0x63EF8CE2, 0x9A86EE22,\n  0xC089C2B8, 0x43242EF6, 0xA51E03AA, 0x9CF2D0A4,\n  0x83C061BA, 0x9BE96A4D, 0x8FE51550, 0xBA645BD6,\n  0x2826A2F9, 0xA73A3AE1, 0x4BA99586, 0xEF5562E9,\n  0xC72FEFD3, 0xF752F7DA, 0x3F046F69, 0x77FA0A59,\n  0x80E4A915, 0x87B08601, 0x9B09E6AD, 0x3B3EE593,\n  0xE990FD5A, 0x9E34D797, 0x2CF0B7D9, 0x022B8B51,\n  0x96D5AC3A, 0x017DA67D, 0xD1CF3ED6, 0x7C7D2D28,\n  0x1F9F25CF, 0xADF2B89B, 0x5AD6B472, 0x5A88F54C,\n  0xE029AC71, 0xE019A5E6, 0x47B0ACFD, 0xED93FA9B,\n  0xE8D3C48D, 0x283B57CC, 0xF8D56629, 0x79132E28,\n  0x785F0191, 0xED756055, 0xF7960E44, 0xE3D35E8C,\n  0x15056DD4, 0x88F46DBA, 0x03A16125, 0x0564F0BD,\n  0xC3EB9E15, 0x3C9057A2, 0x97271AEC, 0xA93A072A,\n  0x1B3F6D9B, 0x1E6321F5, 0xF59C66FB, 0x26DCF319,\n  0x7533D928, 0xB155FDF5, 0x03563482, 0x8ABA3CBB,\n  0x28517711, 0xC20AD9F8, 0xABCC5167, 0xCCAD925F,\n  0x4DE81751, 0x3830DC8E, 0x379D5862, 0x9320F991,\n  0xEA7A90C2, 0xFB3E7BCE, 0x5121CE64, 0x774FBE32,\n  0xA8B6E37E, 0xC3293D46, 0x48DE5369, 0x6413E680,\n  0xA2AE0810, 0xDD6DB224, 0x69852DFD, 0x09072166,\n  0xB39A460A, 0x6445C0DD, 0x586CDECF, 0x1C20C8AE,\n  0x5BBEF7DD, 0x1B588D40, 0xCCD2017F, 0x6BB4E3BB,\n  0xDDA26A7E, 0x3A59FF45, 0x3E350A44, 0xBCB4CDD5,\n  0x72EACEA8, 0xFA6484BB, 0x8D6612AE, 0xBF3C6F47,\n  0xD29BE463, 0x542F5D9E, 0xAEC2771B, 0xF64E6370,\n  0x740E0D8D, 0xE75B1357, 0xF8721671, 0xAF537D5D,\n  0x4040CB08, 0x4EB4E2CC, 0x34D2466A, 0x0115AF84,\n  0xE1B00428, 0x95983A1D, 0x06B89FB4, 0xCE6EA048,\n  0x6F3F3B82, 0x3520AB82, 0x011A1D4B, 0x277227F8,\n  0x611560B1, 0xE7933FDC, 0xBB3A792B, 0x344525BD,\n  0xA08839E1, 0x51CE794B, 0x2F32C9B7, 0xA01FBAC9,\n  0xE01CC87E, 0xBCC7D1F6, 0xCF0111C3, 0xA1E8AAC7,\n  0x1A908749, 0xD44FBD9A, 0xD0DADECB, 0xD50ADA38,\n  0x0339C32A, 0xC6913667, 0x8DF9317C, 0xE0B12B4F,\n  0xF79E59B7, 0x43F5BB3A, 0xF2D519FF, 0x27D9459C,\n  0xBF97222C, 0x15E6FC2A, 0x0F91FC71, 0x9B941525,\n  0xFAE59361, 0xCEB69CEB, 0xC2A86459, 0x12BAA8D1,\n  0xB6C1075E, 0xE3056A0C, 0x10D25065, 0xCB03A442,\n  0xE0EC6E0E, 0x1698DB3B, 0x4C98A0BE, 0x3278E964,\n  0x9F1F9532, 0xE0D392DF, 0xD3A0342B, 0x8971F21E,\n  0x1B0A7441, 0x4BA3348C, 0xC5BE7120, 0xC37632D8,\n  0xDF359F8D, 0x9B992F2E, 0xE60B6F47, 0x0FE3F11D,\n  0xE54CDA54, 0x1EDAD891, 0xCE6279CF, 0xCD3E7E6F,\n  0x1618B166, 0xFD2C1D05, 0x848FD2C5, 0xF6FB2299,\n  0xF523F357, 0xA6327623, 0x93A83531, 0x56CCCD02,\n  0xACF08162, 0x5A75EBB5, 0x6E163697, 0x88D273CC,\n  0xDE966292, 0x81B949D0, 0x4C50901B, 0x71C65614,\n  0xE6C6C7BD, 0x327A140A, 0x45E1D006, 0xC3F27B9A,\n  0xC9AA53FD, 0x62A80F00, 0xBB25BFE2, 0x35BDD2F6,\n  0x71126905, 0xB2040222, 0xB6CBCF7C, 0xCD769C2B,\n  0x53113EC0, 0x1640E3D3, 0x38ABBD60, 0x2547ADF0,\n  0xBA38209C, 0xF746CE76, 0x77AFA1C5, 0x20756060,\n  0x85CBFE4E, 0x8AE88DD8, 0x7AAAF9B0, 0x4CF9AA7E,\n  0x1948C25C, 0x02FB8A8C, 0x01C36AE4, 0xD6EBE1F9,\n  0x90D4F869, 0xA65CDEA0, 0x3F09252D, 0xC208E69F,\n  0xB74E6132, 0xCE77E25B, 0x578FDFE3, 0x3AC372E6,],\n];\n\nconst blowfishCtx = {\n  pbox: [],\n  sbox: [],\n};\n\nfunction f(ctx, x) {\n  const a = (x >> 24) & 0xFF;\n  const b = (x >> 16) & 0xFF;\n  const c = (x >> 8) & 0xFF;\n  const d = x & 0xFF;\n\n  let y = ctx.sbox[0][a] + ctx.sbox[1][b];\n  y = y ^ ctx.sbox[2][c];\n  y = y + ctx.sbox[3][d];\n\n  return y;\n}\n\nfunction blowfishEncrypt(ctx, left, right) {\n  let Xl = left;\n  let Xr = right;\n  let temp;\n\n  for(let i = 0; i < N; ++i){\n      Xl = Xl ^ ctx.pbox[i];\n      Xr = f(ctx, Xl) ^ Xr;\n\n      temp = Xl;\n      Xl = Xr;\n      Xr = temp;\n  }\n\n  temp = Xl;\n  Xl = Xr;\n  Xr = temp;\n\n  Xr = Xr ^ ctx.pbox[N];\n  Xl = Xl ^ ctx.pbox[N + 1];\n\n  return {left: Xl, right: Xr};\n}\n\nfunction blowfishDecrypt(ctx, left, right) {\n  let Xl = left;\n  let Xr = right;\n  let temp;\n\n  for(let i = N + 1; i > 1; --i){\n      Xl = Xl ^ ctx.pbox[i];\n      Xr = f(ctx, Xl) ^ Xr;\n\n      temp = Xl;\n      Xl = Xr;\n      Xr = temp;\n  }\n\n  temp = Xl;\n  Xl = Xr;\n  Xr = temp;\n\n  Xr = Xr ^ ctx.pbox[1];\n  Xl = Xl ^ ctx.pbox[0];\n\n  return {left: Xl, right: Xr};\n}\n\n/**\n* Initialization ctx's pbox and sbox.\n*\n* @param {Object} ctx The object has pbox and sbox.\n* @param {Array} key An array of 32-bit words.\n* @param {int} keysize The length of the key.\n*\n* @example\n*\n*     blowfishInit(BLOWFISH_CTX, key, 128/32);\n*/\nfunction blowfishInit(ctx, key, keysize) {\n  for (let Row = 0; Row < 4; Row++) {\n    ctx.sbox[Row] = [];\n    for (let Col = 0; Col < 256; Col++) {\n      ctx.sbox[Row][Col] = ORIG_S[Row][Col];\n    }\n  }\n\n  let keyIndex = 0;\n  for (let index = 0; index < N + 2; index++) {\n    ctx.pbox[index] = ORIG_P[index] ^ key[keyIndex];\n    keyIndex++;\n    if (keyIndex >= keysize) {\n      keyIndex = 0;\n    }\n  }\n\n  let data1 = 0;\n  let data2 = 0;\n  let res = 0;\n  for (let i = 0; i < N + 2; i += 2) {\n    res = blowfishEncrypt(ctx, data1, data2);\n    data1 = res.left;\n    data2 = res.right;\n    ctx.pbox[i] = data1;\n    ctx.pbox[i + 1] = data2;\n  }\n  \n  for (let i = 0; i < 4; i++) {\n    for (let j = 0; j < 256; j += 2) {\n      res = blowfishEncrypt(ctx, data1, data2);\n      data1 = res.left;\n      data2 = res.right;\n      ctx.sbox[i][j] = data1;\n      ctx.sbox[i][j + 1] = data2;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Blowfish block cipher algorithm.\n */\nexport class BlowfishAlgo extends BlockCipher {\n  constructor(xformMode, key, cfg) {\n    super(xformMode, key, cfg);\n\n    // blickSize is an instance field and should set in constructor.\n    this.blockSize = 64 / 32;\n  }\n\n  _doReset() {\n    // Skip reset of nRounds has been set before and key did not change\n    if (this._keyPriorReset === this._key) {\n      return;\n    }\n\n    // Shortcuts\n    const key = this._keyPriorReset = this._key;\n    const keyWords = key.words;\n    const keySize = key.sigBytes / 4;\n\n    //Initialization pbox and sbox\n    blowfishInit(blowfishCtx, keyWords, keySize);\n  }\n\n  encryptBlock(M, offset) {\n    const res = blowfishEncrypt(blowfishCtx, M[offset], M[offset + 1]);\n    M[offset] = res.left;\n    M[offset + 1] = res.right;\n  }\n\n  decryptBlock(M, offset) {\n    const res = blowfishDecrypt(blowfishCtx, M[offset], M[offset + 1]);\n    M[offset] = res.left;\n    M[offset + 1] = res.right;\n  }\n}\nBlowfishAlgo.keySize = 128 / 32;\nBlowfishAlgo.ivSize = 64 / 32;\n// blickSize is an instance field and should set in constructor.\n\n/**\n * Shortcut functions to the cipher's object interface.\n *\n * @example\n *\n *     var ciphertext = CryptoJS.Blowfish.encrypt(message, key, cfg);\n *     var plaintext  = CryptoJS.Blowfish.decrypt(ciphertext, key, cfg);\n */\nexport const Blowfish = BlockCipher._createHelper(BlowfishAlgo);\n","import {\n  BlockCipherMode,\n} from './cipher-core.js';\n\nfunction generateKeystreamAndEncrypt(words, offset, blockSize, cipher) {\n  const _words = words;\n  let keystream;\n\n  // Shortcut\n  const iv = this._iv;\n\n  // Generate keystream\n  if (iv) {\n    keystream = iv.slice(0);\n\n    // Remove IV for subsequent blocks\n    this._iv = undefined;\n  } else {\n    keystream = this._prevBlock;\n  }\n  cipher.encryptBlock(keystream, 0);\n\n  // Encrypt\n  for (let i = 0; i < blockSize; i += 1) {\n    _words[offset + i] ^= keystream[i];\n  }\n}\n\n/**\n * Cipher Feedback block mode.\n */\nexport class CFB extends BlockCipherMode {\n}\nCFB.Encryptor = class extends CFB {\n  processBlock(words, offset) {\n    // Shortcuts\n    const cipher = this._cipher;\n    const { blockSize } = cipher;\n\n    generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);\n\n    // Remember this block to use with next block\n    this._prevBlock = words.slice(offset, offset + blockSize);\n  }\n};\nCFB.Decryptor = class extends CFB {\n  processBlock(words, offset) {\n    // Shortcuts\n    const cipher = this._cipher;\n    const { blockSize } = cipher;\n\n    // Remember this block to use with next block\n    const thisBlock = words.slice(offset, offset + blockSize);\n\n    generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);\n\n    // This block becomes the previous block\n    this._prevBlock = thisBlock;\n  }\n};\n","import {\n  BlockCipherMode,\n} from './cipher-core.js';\n\n/**\n * Counter block mode.\n */\nexport class CTR extends BlockCipherMode {\n}\nCTR.Encryptor = class extends CTR {\n  processBlock(words, offset) {\n    const _words = words;\n\n    // Shortcuts\n    const cipher = this._cipher;\n    const { blockSize } = cipher;\n    const iv = this._iv;\n    let counter = this._counter;\n\n    // Generate keystream\n    if (iv) {\n      this._counter = iv.slice(0);\n      counter = this._counter;\n\n      // Remove IV for subsequent blocks\n      this._iv = undefined;\n    }\n    const keystream = counter.slice(0);\n    cipher.encryptBlock(keystream, 0);\n\n    // Increment counter\n    counter[blockSize - 1] = (counter[blockSize - 1] + 1) | 0;\n\n    // Encrypt\n    for (let i = 0; i < blockSize; i += 1) {\n      _words[offset + i] ^= keystream[i];\n    }\n  }\n};\nCTR.Decryptor = CTR.Encryptor;\n","import {\n  BlockCipherMode,\n} from './cipher-core.js';\n\nconst incWord = (word) => {\n  let _word = word;\n\n  if (((word >> 24) & 0xff) === 0xff) { // overflow\n    let b1 = (word >> 16) & 0xff;\n    let b2 = (word >> 8) & 0xff;\n    let b3 = word & 0xff;\n\n    if (b1 === 0xff) { // overflow b1\n      b1 = 0;\n      if (b2 === 0xff) {\n        b2 = 0;\n        if (b3 === 0xff) {\n          b3 = 0;\n        } else {\n          b3 += 1;\n        }\n      } else {\n        b2 += 1;\n      }\n    } else {\n      b1 += 1;\n    }\n\n    _word = 0;\n    _word += (b1 << 16);\n    _word += (b2 << 8);\n    _word += b3;\n  } else {\n    _word += (0x01 << 24);\n  }\n  return _word;\n};\n\nconst incCounter = (counter) => {\n  const _counter = counter;\n  _counter[0] = incWord(_counter[0]);\n\n  if (_counter[0] === 0) {\n    // encr_data in fileenc.c from  Dr Brian Gladman's counts only with DWORD j < 8\n    _counter[1] = incWord(_counter[1]);\n  }\n  return _counter;\n};\n\n/** @preserve\n * Counter block mode compatible with  Dr Brian Gladman fileenc.c\n * derived from CryptoJS.mode.CTR\n * Jan Hruby jhruby.web@gmail.com\n */\nexport class CTRGladman extends BlockCipherMode {\n}\nCTRGladman.Encryptor = class extends CTRGladman {\n  processBlock(words, offset) {\n    const _words = words;\n\n    // Shortcuts\n    const cipher = this._cipher;\n    const { blockSize } = cipher;\n    const iv = this._iv;\n    let counter = this._counter;\n\n    // Generate keystream\n    if (iv) {\n      this._counter = iv.slice(0);\n      counter = this._counter;\n\n      // Remove IV for subsequent blocks\n      this._iv = undefined;\n    }\n\n    incCounter(counter);\n\n    const keystream = counter.slice(0);\n    cipher.encryptBlock(keystream, 0);\n\n    // Encrypt\n    for (let i = 0; i < blockSize; i += 1) {\n      _words[offset + i] ^= keystream[i];\n    }\n  }\n};\nCTRGladman.Decryptor = CTRGladman.Encryptor;\n","import {\n  BlockCipherMode,\n} from './cipher-core.js';\n\n/**\n * Electronic Codebook block mode.\n */\nexport class ECB extends BlockCipherMode {\n}\nECB.Encryptor = class extends ECB {\n  processBlock(words, offset) {\n    this._cipher.encryptBlock(words, offset);\n  }\n};\nECB.Decryptor = class extends ECB {\n  processBlock(words, offset) {\n    this._cipher.decryptBlock(words, offset);\n  }\n};\n","import {\n  BlockCipherMode,\n} from './cipher-core.js';\n\n/**\n * Output Feedback block mode.\n */\nexport class OFB extends BlockCipherMode {\n}\nOFB.Encryptor = class extends OFB {\n  processBlock(words, offset) {\n    const _words = words;\n\n    // Shortcuts\n    const cipher = this._cipher;\n    const { blockSize } = cipher;\n    const iv = this._iv;\n    let keystream = this._keystream;\n\n    // Generate keystream\n    if (iv) {\n      this._keystream = iv.slice(0);\n      keystream = this._keystream;\n\n      // Remove IV for subsequent blocks\n      this._iv = undefined;\n    }\n    cipher.encryptBlock(keystream, 0);\n\n    // Encrypt\n    for (let i = 0; i < blockSize; i += 1) {\n      _words[offset + i] ^= keystream[i];\n    }\n  }\n};\nOFB.Decryptor = OFB.Encryptor;\n","/**\n * ANSI X.923 padding strategy.\n */\nexport const AnsiX923 = {\n  pad(data, blockSize) {\n    const _data = data;\n\n    // Shortcuts\n    const dataSigBytes = _data.sigBytes;\n    const blockSizeBytes = blockSize * 4;\n\n    // Count padding bytes\n    const nPaddingBytes = blockSizeBytes - (dataSigBytes % blockSizeBytes);\n\n    // Compute last byte position\n    const lastBytePos = dataSigBytes + nPaddingBytes - 1;\n\n    // Pad\n    _data.clamp();\n    _data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8);\n    _data.sigBytes += nPaddingBytes;\n  },\n\n  unpad(data) {\n    const _data = data;\n\n    // Get number of padding bytes from last byte\n    const nPaddingBytes = _data.words[(_data.sigBytes - 1) >>> 2] & 0xff;\n\n    // Remove padding\n    _data.sigBytes -= nPaddingBytes;\n  },\n};\n","import {\n  WordArray,\n} from './core.js';\n\n/**\n * ISO 10126 padding strategy.\n */\nexport const Iso10126 = {\n  pad(data, blockSize) {\n    // Shortcut\n    const blockSizeBytes = blockSize * 4;\n\n    // Count padding bytes\n    const nPaddingBytes = blockSizeBytes - (data.sigBytes % blockSizeBytes);\n\n    // Pad\n    data\n      .concat(WordArray.random(nPaddingBytes - 1))\n      .concat(WordArray.create([nPaddingBytes << 24], 1));\n  },\n\n  unpad(data) {\n    const _data = data;\n    // Get number of padding bytes from last byte\n    const nPaddingBytes = _data.words[(_data.sigBytes - 1) >>> 2] & 0xff;\n\n    // Remove padding\n    _data.sigBytes -= nPaddingBytes;\n  },\n};\n","/**\n * Zero padding strategy.\n */\nexport const ZeroPadding = {\n  pad(data, blockSize) {\n    const _data = data;\n\n    // Shortcut\n    const blockSizeBytes = blockSize * 4;\n\n    // Pad\n    _data.clamp();\n    _data.sigBytes += blockSizeBytes - ((data.sigBytes % blockSizeBytes) || blockSizeBytes);\n  },\n\n  unpad(data) {\n    const _data = data;\n\n    // Shortcut\n    const dataWords = _data.words;\n\n    // Unpad\n    for (let i = _data.sigBytes - 1; i >= 0; i -= 1) {\n      if (((dataWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)) {\n        _data.sigBytes = i + 1;\n        break;\n      }\n    }\n  },\n};\n","import {\n  WordArray,\n} from './core.js';\nimport {\n  ZeroPadding,\n} from './pad-zeropadding.js';\n\n/**\n * ISO/IEC 9797-1 Padding Method 2.\n */\nexport const Iso97971 = {\n  pad(data, blockSize) {\n    // Add 0x80 byte\n    data.concat(WordArray.create([0x80000000], 1));\n\n    // Zero pad the rest\n    ZeroPadding.pad(data, blockSize);\n  },\n\n  unpad(data) {\n    const _data = data;\n\n    // Remove zero padding\n    ZeroPadding.unpad(_data);\n\n    // Remove one more byte -- the 0x80 byte\n    _data.sigBytes -= 1;\n  },\n};\n","/**\n * A noop padding strategy.\n */\nexport const NoPadding = {\n  pad() {\n  },\n\n  unpad() {\n  },\n};\n","import {\n  CipherParams,\n} from './cipher-core.js';\nimport {\n  Hex,\n} from './core.js';\n\nexport const HexFormatter = {\n  /**\n   * Converts the ciphertext of a cipher params object to a hexadecimally encoded string.\n   *\n   * @param {CipherParams} cipherParams The cipher params object.\n   *\n   * @return {string} The hexadecimally encoded string.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var hexString = CryptoJS.format.Hex.stringify(cipherParams);\n   */\n  stringify(cipherParams) {\n    return cipherParams.ciphertext.toString(Hex);\n  },\n\n  /**\n   * Converts a hexadecimally encoded ciphertext string to a cipher params object.\n   *\n   * @param {string} input The hexadecimally encoded string.\n   *\n   * @return {CipherParams} The cipher params object.\n   *\n   * @static\n   *\n   * @example\n   *\n   *     var cipherParams = CryptoJS.format.Hex.parse(hexString);\n   */\n  parse(input) {\n    const ciphertext = Hex.parse(input);\n    return CipherParams.create({ ciphertext });\n  },\n};\n","import {\n  Base,\n  WordArray,\n  Hex,\n  Latin1,\n  Utf8,\n  BufferedBlockAlgorithm,\n  Hasher,\n} from './core.js';\nimport {\n  X64Word,\n  X64WordArray,\n} from './x64-core.js';\nimport {\n  Cipher,\n  StreamCipher,\n  BlockCipherMode,\n  CBC,\n  Pkcs7,\n  BlockCipher,\n  CipherParams,\n  OpenSSLFormatter,\n  SerializableCipher,\n  OpenSSLKdf,\n  PasswordBasedCipher,\n} from './cipher-core.js';\n\nimport { Utf16, Utf16BE, Utf16LE } from './enc-utf16.js';\nimport { Base64 } from './enc-base64.js';\nimport { Base64url } from './enc-base64url.js';\nimport { HMAC } from './hmac.js';\nimport { MD5Algo, MD5, HmacMD5 } from './md5.js';\nimport { SHA1Algo, SHA1, HmacSHA1 } from './sha1.js';\nimport { SHA224Algo, SHA224, HmacSHA224 } from './sha224.js';\nimport { SHA256Algo, SHA256, HmacSHA256 } from './sha256.js';\nimport { SHA384Algo, SHA384, HmacSHA384 } from './sha384.js';\nimport { SHA512Algo, SHA512, HmacSHA512 } from './sha512.js';\nimport { SHA3Algo, SHA3, HmacSHA3 } from './sha3.js';\nimport { RIPEMD160Algo, RIPEMD160, HmacRIPEMD160 } from './ripemd160.js';\nimport { PBKDF2Algo, PBKDF2 } from './pbkdf2.js';\nimport { EvpKDFAlgo, EvpKDF } from './evpkdf.js';\nimport { AESAlgo, AES } from './aes.js';\nimport {\n  DESAlgo,\n  DES,\n  TripleDESAlgo,\n  TripleDES,\n} from './tripledes.js';\nimport { RabbitAlgo, Rabbit } from './rabbit.js';\nimport { RabbitLegacyAlgo, RabbitLegacy } from './rabbit-legacy.js';\nimport {\n  RC4Algo,\n  RC4,\n  RC4DropAlgo,\n  RC4Drop,\n} from './rc4.js';\nimport { BlowfishAlgo, Blowfish } from './blowfish.js';\nimport { CFB } from './mode-cfb.js';\nimport { CTR } from './mode-ctr.js';\nimport { CTRGladman } from './mode-ctr-gladman.js';\nimport { ECB } from './mode-ecb.js';\nimport { OFB } from './mode-ofb.js';\nimport { AnsiX923 } from './pad-ansix923.js';\nimport { Iso10126 } from './pad-iso10126.js';\nimport { Iso97971 } from './pad-iso97971.js';\nimport { NoPadding } from './pad-nopadding.js';\nimport { ZeroPadding } from './pad-zeropadding.js';\nimport { HexFormatter } from './format-hex.js';\n\nexport default {\n  lib: {\n    Base,\n    WordArray,\n    BufferedBlockAlgorithm,\n    Hasher,\n    Cipher,\n    StreamCipher,\n    BlockCipherMode,\n    BlockCipher,\n    CipherParams,\n    SerializableCipher,\n    PasswordBasedCipher,\n  },\n\n  x64: {\n    Word: X64Word,\n    WordArray: X64WordArray,\n  },\n\n  enc: {\n    Hex,\n    Latin1,\n    Utf8,\n    Utf16,\n    Utf16BE,\n    Utf16LE,\n    Base64,\n    Base64url,\n  },\n\n  algo: {\n    HMAC,\n    MD5: MD5Algo,\n    SHA1: SHA1Algo,\n    SHA224: SHA224Algo,\n    SHA256: SHA256Algo,\n    SHA384: SHA384Algo,\n    SHA512: SHA512Algo,\n    SHA3: SHA3Algo,\n    RIPEMD160: RIPEMD160Algo,\n\n    PBKDF2: PBKDF2Algo,\n    EvpKDF: EvpKDFAlgo,\n\n    AES: AESAlgo,\n    DES: DESAlgo,\n    TripleDES: TripleDESAlgo,\n    Rabbit: RabbitAlgo,\n    RabbitLegacy: RabbitLegacyAlgo,\n    RC4: RC4Algo,\n    RC4Drop: RC4DropAlgo,\n    Blowfish: BlowfishAlgo,\n  },\n\n  mode: {\n    CBC,\n    CFB,\n    CTR,\n    CTRGladman,\n    ECB,\n    OFB,\n  },\n\n  pad: {\n    Pkcs7,\n    AnsiX923,\n    Iso10126,\n    Iso97971,\n    NoPadding,\n    ZeroPadding,\n  },\n\n  format: {\n    OpenSSL: OpenSSLFormatter,\n    Hex: HexFormatter,\n  },\n\n  kdf: {\n    OpenSSL: OpenSSLKdf,\n  },\n\n  MD5,\n  HmacMD5,\n  SHA1,\n  HmacSHA1,\n  SHA224,\n  HmacSHA224,\n  SHA256,\n  HmacSHA256,\n  SHA384,\n  HmacSHA384,\n  SHA512,\n  HmacSHA512,\n  SHA3,\n  HmacSHA3,\n  RIPEMD160,\n  HmacRIPEMD160,\n\n  PBKDF2,\n  EvpKDF,\n\n  AES,\n  DES,\n  TripleDES,\n  Rabbit,\n  RabbitLegacy,\n  RC4,\n  RC4Drop,\n  Blowfish,\n};\n","import crypto from 'crypto-es';\nexport function isObject(obj) {\n    return obj != null && Object.getPrototypeOf(obj).isPrototypeOf(Object) && typeof obj === 'object';\n}\nexport const isValidSHA256String = (value) => typeof value === 'string' && /^[a-f0-9]{64}$/gi.test(value);\nexport function digestMessage(message) {\n    const inputArray = crypto.enc.Utf8.parse(message); // encode as UTF-8\n    // eslint-disable-next-line new-cap\n    const digestArray = crypto.SHA256(inputArray); // hash the message\n    return crypto.enc.Hex.stringify(digestArray); // convert digest to string\n}\n","import { ADDRESS as AID } from './types/address.js';\nimport { isObject, digestMessage, isValidSHA256String } from './modules/utils.js';\nexport const RULES = {\n    [AID.state]: [\n        {\n            value: 'ceska republika',\n            reg: /^(cz|cr|czechia|czech|czech republic|cesko)$/,\n        },\n        {\n            value: 'slovenska republika',\n            reg: /^(sk|sr|slovakia|slovak|slovak republic|slovensko)$/,\n        },\n    ],\n    [AID.city]: [\n        { value: 'hradec kralove', reg: /h\\.?\\s?kralove$/ },\n        { value: 'karlovy vary', reg: /k\\.?\\s?vary$/ },\n        { value: 'm.$1', reg: /(?:m\\.?|mor\\.|morav.*)\\s?(beroun|budejovice|trebova|krumlov)$/ },\n        {\n            value: '$1 nad labem',\n            reg: /(usti|brandys|dvur kralove|roudnice|lysa|kostelec|tynec) (n\\.?|nad)\\s?(labem|l\\.?)/,\n        },\n        { value: '$1 nad nisou', reg: /(jablonec|hradek|lucany) (n\\.?|nad)\\s?(nisou|n\\.?)/ },\n        { value: '$1 nad sazavou', reg: /(zdar|svetla|tynec|ledec|zruc|lipnice) (n\\.?|nad)\\s?(sazavou|s\\.?)/ },\n        {\n            value: '$1 nad vltavou',\n            reg: /(kralupy|tyn|hluboka|libcice|krasna hora|rozmberk) (n\\.?|nad)\\s?(vltavou|vl\\.?|v\\.?)/,\n        },\n        { value: '$1 pod radhostem', reg: /(roznov|frenstat) (p\\.?|pod)\\s?(radhostem|r\\.?)/ },\n        { value: '$1 nad ohri', reg: /(klasterec|kynsperk|bohusovice|budyne) (n\\.?|nad)\\s?(ohri|o\\.?)/ },\n        { value: '$1 nad orlici', reg: /(usti|tyniste|kostelec|jablonne|brandys) (n\\.?|nad)\\s?(orlici|o\\.?)/ },\n        { value: '$1 nad metuji', reg: /(nove mesto|police|teplice) (n\\.?|nad)\\s?(metuji|m\\.?)/ },\n        { value: '$1 nad jizerou', reg: /(benatky|bakov|rokytnice|jablonec|vysoke) (n\\.?|nad)\\s?(jizerou|j\\.?)/ },\n        { value: '$1 nad luznici', reg: /(veseli|plana|suchdol|lomnice) (n\\.?|nad)\\s?(luznici|l\\.?)/ },\n        { value: 'rychnov nad kneznou', reg: /rychnov (n\\.?|nad)\\s?(kneznou|k\\.?)/ },\n        { value: 'veseli nad moravou', reg: /veseli (n\\.?|nad)\\s?(moravou|m\\.?)/ },\n        { value: 'nove mesto na morave', reg: /nove mesto (n\\.?|na)\\s?(morave|m\\.?)/ },\n        { value: 'frydlant nad ostravici', reg: /frydlant (n\\.?|nad)\\s?(ostravici|o\\.?)/ },\n        { value: 'bystrice pod hostynem', reg: /bystrice (p\\.?|pod)\\s?(hostynem|h\\.?)/ },\n        { value: 'lipnik nad becvou', reg: /lipnik (n\\.?|nad)\\s?(becvou|b\\.?)/ },\n        { value: 'bystrice nad pernstejnem', reg: /bystrice (n\\.?|nad)\\s?(pernstejnem|p\\.?)/ },\n        { value: 'mnisek pod brdy', reg: /mnisek (p\\.?|pod)\\s?(brdy|b\\.?)/ },\n        { value: 'trebechovice pod orebem', reg: /trebechovice (p\\.?|pod)\\s?(orebem|o\\.?)/ },\n        { value: 'chlumec nad cidlinou', reg: /chlumec (n\\.?|nad)\\s?(cidlinou|c\\.?)/ },\n        { value: 'lomnice nad popelkou', reg: /lomnice (n\\.?|nad)\\s?(popelkou|p\\.?)/ },\n        { value: 'hradec nad moravici', reg: /hradec (n\\.?|nad)\\s?(moravici|m\\.?)/ },\n        { value: 'bela pod bezdezem', reg: /bela (p\\.?|pod)\\s?(bezdezem|b\\.?)/ },\n        { value: 'namest nad oslavou', reg: /namest (n\\.?|nad)\\s?(oslavou|o\\.?)/ },\n        { value: 'vrbno pod pradedem', reg: /vrbno (p\\.?|pod)\\s?(pradedem|p\\.?)/ },\n        { value: 'rozmital pod tremsinem', reg: /rozmital (p\\.?|pod)\\s?(tremsinem|t\\.?)/ },\n        { value: 'jaromerice nad rokytnou', reg: /jaromerice (n\\.?|nad)\\s?(rokytnou|r\\.?)/ },\n        { value: 'kostelec nad cernymi lesy', reg: /kostelec (n\\.?|nad)\\s?(cernymi|c\\.?)\\s?(lesy|l\\.?)/ },\n        { value: 'straz pod ralskem', reg: /straz (p\\.?|pod)\\s?(ralskem|r\\.?)/ },\n        { value: 'nove mesto pod smrkem', reg: /nove mesto (p\\.?|pod)\\s?(smrkem|s\\.?)/ },\n        { value: 'kamenice nad lipou', reg: /kamenice (n\\.?|nad)\\s?(lipou|l\\.?)/ },\n        { value: 'benesov nad ploucnici', reg: /benesov (n\\.?|nad)\\s?(ploucnici|p\\.?)/ },\n        { value: 'hrusovany nad jevisovkou', reg: /hrusovany (n\\.?|nad)\\s?(jevisovkou|j\\.?)/ },\n        { value: 'hodkovice nad mohelkou', reg: /hodkovice (n\\.?|nad)\\s?(mohelkou|m\\.?)/ },\n        { value: 'rychnov u jablonce nad nisou', reg: /rychnov u (j\\.?|jablonce)\\s?(n\\.?|nad)\\s?(nisou|n\\.?)/ },\n        { value: 'budisov nad budisovkou', reg: /budisov (n\\.?|nad)\\s?(budisovkou|b\\.?)/ },\n        { value: 'janovice nad uhlavou', reg: /janovice (n\\.?|nad)\\s?(uhlavou|u\\.?)/ },\n        { value: 'svoboda nad upou', reg: /svoboda (n\\.?|nad)\\s?(upou|u\\.?)/ },\n        { value: 'nemcice nad hanou', reg: /nemcice (n\\.?|nad)\\s?(hanou|h\\.?)/ },\n        { value: 'ronov nad doubravou', reg: /ronov (n\\.?|nad)\\s?(doubravou|d\\.?)/ },\n        { value: 'bela nad radbuzou', reg: /bela (n\\.?|nad)\\s?(radbuzou|r\\.?)/ },\n        { value: 'brezova nad svitavou', reg: /brezova (n\\.?|nad)\\s?(svitavou|s\\.?)/ },\n        { value: 'becov nad teplou', reg: /becov (n\\.?|nad)\\s?(teplou|t\\.?)/ },\n        { value: 'straz nad nezarkou', reg: /straz (n\\.?|nad)\\s?(nezarkou|n\\.?)/ },\n        { value: 'praha', reg: /praha.*/ },\n        { value: 'praha', reg: /pha(\\s.?|\\d+)?.*/ },\n        { value: 'n.', reg: /\\sn(\\.?|a|ad)\\s/ },\n        { value: 'p.', reg: /\\sp(\\.?|od)\\s/ },\n        { value: 'c.', reg: /(^cesk[aey]\\s|^c\\s)/ },\n        { value: 'sv.$2', reg: /(svat[aey]|sv\\s)(.+)/ },\n        { value: '$1m.', reg: /(nove|stare|horni|dolni)\\smesto($|(\\s|\\-).*)/ },\n        { value: '', reg: /[\\-–,\\/\\(\\s]+(sever|jih|vychod|zapad|mesto|stred)($|\\))/ },\n    ],\n    [AID.street]: [\n        { value: '$1|$2', reg: /^([a-z\\-\\.\\' ]*[0-9]{0,}[a-z\\-\\.\\' ]+)([0-9]{1,}.*)?$/ },\n        { value: '$1', reg: /^(.*)\\|$/ },\n    ],\n    [AID.houseNumber]: [],\n    [AID.postalCode]: [],\n};\nconst CHAR_MAP = {\n    À: 'A',\n    Á: 'A',\n    Â: 'A',\n    Ã: 'A',\n    Ä: 'A',\n    Å: 'A',\n    Æ: 'AE',\n    Ç: 'C',\n    È: 'E',\n    É: 'E',\n    Ê: 'E',\n    Ë: 'E',\n    Ì: 'I',\n    Í: 'I',\n    Î: 'I',\n    Ï: 'I',\n    Ð: 'D',\n    Ñ: 'N',\n    Ò: 'O',\n    Ó: 'O',\n    Ô: 'O',\n    Õ: 'O',\n    Ö: 'O',\n    Ù: 'U',\n    Ú: 'U',\n    Û: 'U',\n    Ü: 'U',\n    Ý: 'Y',\n    ß: 'ss',\n    à: 'a',\n    á: 'a',\n    â: 'a',\n    ã: 'a',\n    ä: 'a',\n    å: 'a',\n    æ: 'ae',\n    ç: 'c',\n    è: 'e',\n    é: 'e',\n    ê: 'e',\n    ë: 'e',\n    ì: 'i',\n    í: 'i',\n    î: 'i',\n    ï: 'i',\n    ð: 'd',\n    ñ: 'n',\n    ò: 'o',\n    ó: 'o',\n    ô: 'o',\n    õ: 'o',\n    ö: 'o',\n    ø: 'o',\n    ù: 'u',\n    ú: 'u',\n    û: 'u',\n    ü: 'u',\n    ý: 'y',\n    ÿ: 'y',\n    Ā: 'A',\n    ā: 'a',\n    Ă: 'A',\n    ă: 'a',\n    Ą: 'A',\n    ą: 'a',\n    Ć: 'C',\n    ć: 'c',\n    Ĉ: 'C',\n    ĉ: 'c',\n    Ċ: 'C',\n    ċ: 'c',\n    Č: 'C',\n    č: 'c',\n    Ď: 'D',\n    ď: 'd',\n    Đ: 'D',\n    đ: 'd',\n    Ē: 'E',\n    ē: 'e',\n    Ĕ: 'E',\n    ĕ: 'e',\n    Ė: 'E',\n    ė: 'e',\n    Ę: 'E',\n    ę: 'e',\n    Ě: 'E',\n    ě: 'e',\n    Ĝ: 'G',\n    ĝ: 'g',\n    Ğ: 'G',\n    ğ: 'g',\n    Ġ: 'G',\n    ġ: 'g',\n    Ģ: 'G',\n    ģ: 'g',\n    Ĥ: 'H',\n    ĥ: 'h',\n    Ħ: 'H',\n    ħ: 'h',\n    Ĩ: 'I',\n    ĩ: 'i',\n    Ī: 'I',\n    ī: 'i',\n    Ĭ: 'I',\n    ĭ: 'i',\n    Į: 'I',\n    į: 'i',\n    İ: 'I',\n    Ĵ: 'J',\n    ĵ: 'j',\n    Ķ: 'K',\n    ķ: 'k',\n    ĸ: 'k',\n    Ĺ: 'L',\n    ĺ: 'l',\n    Ļ: 'L',\n    ļ: 'l',\n    Ľ: 'L',\n    ľ: 'l',\n    Ń: 'N',\n    ń: 'n',\n    Ņ: 'N',\n    ņ: 'n',\n    Ň: 'N',\n    ň: 'n',\n    ʼn: 'n',\n    Ō: 'O',\n    ō: 'o',\n    Ŏ: 'O',\n    ŏ: 'o',\n    Ő: 'O',\n    ő: 'o',\n    Ŕ: 'R',\n    ŕ: 'r',\n    Ŗ: 'R',\n    ŗ: 'r',\n    Ř: 'R',\n    ř: 'r',\n    Ś: 'S',\n    ś: 's',\n    Ŝ: 'S',\n    ŝ: 's',\n    Ş: 'S',\n    ş: 's',\n    Š: 'S',\n    š: 's',\n    Ţ: 'T',\n    ţ: 't',\n    Ť: 'T',\n    ť: 't',\n    Ŧ: 'T',\n    ŧ: 't',\n    Ũ: 'U',\n    ũ: 'u',\n    Ū: 'U',\n    ū: 'u',\n    Ŭ: 'U',\n    ŭ: 'u',\n    Ů: 'U',\n    ů: 'u',\n    Ű: 'U',\n    ű: 'u',\n    Ų: 'U',\n    ų: 'u',\n    Ŵ: 'W',\n    ŵ: 'w',\n    Ŷ: 'Y',\n    ŷ: 'y',\n    Ÿ: 'Y',\n    Ź: 'Z',\n    ź: 'z',\n    Ż: 'Z',\n    ż: 'z',\n    Ž: 'Z',\n    ž: 'z',\n};\nconst CHAR_PATTERN = new RegExp(Object.keys(CHAR_MAP).join('|'), 'g');\n/**\n * Replaces special chars with classical chars from alphabet\n */\nexport const _replaceSpecialChars = (strWithSpecialChars) => {\n    return strWithSpecialChars.replace(CHAR_PATTERN, (match) => {\n        return CHAR_MAP[match] ?? match;\n    });\n};\n/**\n * Converts value to string, removes accents and transforms to lower case and applies custom regex rules\n */\nexport const _normalize = (value, addressKey) => {\n    if (isObject(value) || Array.isArray(value)) {\n        return null;\n    }\n    // normalize value\n    let normalizedValue = _replaceSpecialChars(String(value).trim())\n        .replace(/[\\u0300-\\u036f]/g, '')\n        .replace(/\\s+/, ' ')\n        .replace(/[^a-zA-Z0-9\\-\\. ']/g, '')\n        .toLowerCase();\n    const addressKeyRules = RULES[addressKey] ?? [];\n    // apply custom rules for address part\n    if (addressKey && addressKeyRules.length > 0) {\n        for (const { value: val, reg } of addressKeyRules) {\n            if (reg.test(normalizedValue)) {\n                normalizedValue = normalizedValue.replace(reg, val);\n            }\n        }\n    }\n    // remove all whitespaces and dashes\n    normalizedValue = normalizedValue.replace(/[\\s-]/g, '');\n    return normalizedValue;\n};\n/**\n * Creates object that contains hashes of address parts\n */\nexport const createAddressObject = (address, digest = true) => {\n    if (!isObject(address)) {\n        return {};\n    }\n    const normalizedObject = Object.entries(address).reduce((hashedAddressObj, [key, val]) => {\n        if (isValidSHA256String(val)) {\n            hashedAddressObj[key] = val;\n            return hashedAddressObj;\n        }\n        // normalize value\n        const normalizedAddressPart = _normalize(val, key);\n        // hash normalized value when exists\n        if (normalizedAddressPart) {\n            // street part includes house number\n            if (key === AID.street && normalizedAddressPart.includes('|')) {\n                const [street, houseNumber] = normalizedAddressPart.split('|');\n                if (street) {\n                    hashedAddressObj[AID.street] = street;\n                }\n                // when original houseNumber field is empty, fill it\n                if (houseNumber != null && !address[AID.houseNumber]) {\n                    hashedAddressObj[AID.houseNumber] = houseNumber;\n                }\n            }\n            else {\n                hashedAddressObj[key] = normalizedAddressPart;\n            }\n        }\n        return hashedAddressObj;\n    }, {});\n    if (digest) {\n        const hashedObject = Object.entries(normalizedObject).map(([key, val]) => {\n            if (isValidSHA256String(val)) {\n                return [key, val];\n            }\n            else {\n                return [key, digestMessage(val)];\n            }\n        });\n        return Object.fromEntries(hashedObject);\n    }\n    else {\n        return normalizedObject;\n    }\n};\n","import { isObject, digestMessage, isValidSHA256String } from './modules/utils.js';\nconst AREA_CODES = [\n    '420',\n    '421',\n    '49',\n    '43',\n    '36',\n    '48',\n    '39',\n    '33',\n    '44',\n    '34',\n    '385',\n    '213',\n    '376',\n    '244',\n    '1264',\n    '1268',\n    '54',\n    '374',\n    '297',\n    '61',\n    '994',\n    '1242',\n    '973',\n    '880',\n    '1246',\n    '375',\n    '32',\n    '501',\n    '229',\n    '1441',\n    '975',\n    '591',\n    '387',\n    '267',\n    '55',\n    '673',\n    '359',\n    '226',\n    '257',\n    '855',\n    '237',\n    '1',\n    '238',\n    '1345',\n    '236',\n    '56',\n    '86',\n    '57',\n    '269',\n    '242',\n    '682',\n    '506',\n    '53',\n    '90392',\n    '357',\n    '45',\n    '253',\n    '1809',\n    '1809',\n    '593',\n    '20',\n    '503',\n    '240',\n    '291',\n    '372',\n    '251',\n    '500',\n    '298',\n    '679',\n    '358',\n    '594',\n    '689',\n    '241',\n    '220',\n    '7880',\n    '233',\n    '350',\n    '30',\n    '299',\n    '1473',\n    '590',\n    '671',\n    '502',\n    '224',\n    '245',\n    '592',\n    '509',\n    '504',\n    '852',\n    '354',\n    '91',\n    '62',\n    '98',\n    '964',\n    '353',\n    '972',\n    '1876',\n    '81',\n    '962',\n    '7',\n    '254',\n    '686',\n    '850',\n    '82',\n    '965',\n    '996',\n    '856',\n    '371',\n    '961',\n    '266',\n    '231',\n    '218',\n    '417',\n    '370',\n    '352',\n    '853',\n    '389',\n    '261',\n    '265',\n    '60',\n    '960',\n    '223',\n    '356',\n    '692',\n    '596',\n    '222',\n    '269',\n    '52',\n    '691',\n    '373',\n    '377',\n    '976',\n    '1664',\n    '212',\n    '258',\n    '95',\n    '264',\n    '674',\n    '977',\n    '31',\n    '687',\n    '64',\n    '505',\n    '227',\n    '234',\n    '683',\n    '672',\n    '670',\n    '47',\n    '968',\n    '680',\n    '507',\n    '675',\n    '595',\n    '51',\n    '63',\n    '351',\n    '1787',\n    '974',\n    '262',\n    '40',\n    '7',\n    '250',\n    '378',\n    '239',\n    '966',\n    '221',\n    '381',\n    '248',\n    '232',\n    '65',\n    '386',\n    '677',\n    '252',\n    '27',\n    '94',\n    '290',\n    '1869',\n    '1758',\n    '249',\n    '597',\n    '268',\n    '46',\n    '41',\n    '963',\n    '886',\n    '7',\n    '66',\n    '228',\n    '676',\n    '1868',\n    '216',\n    '90',\n    '7',\n    '993',\n    '1649',\n    '688',\n    '256',\n    '380',\n    '971',\n    '598',\n    '1',\n    '7',\n    '678',\n    '379',\n    '58',\n    '84',\n    '84',\n    '84',\n    '681',\n    '969',\n    '967',\n    '260',\n    '263',\n];\n/**\n * Unifies area code format and removes all non-digit characters\n */\nexport const _normalize = (phoneNumber) => {\n    if (isObject(phoneNumber) || Array.isArray(phoneNumber)) {\n        return null;\n    }\n    return String(phoneNumber)\n        .trim()\n        .replace(/^(0{1,2}|\\+)/, '00')\n        .replace(/\\D/g, '');\n};\n/**\n * Checks if normalized number contains area code\n */\nexport const _includesAreaCode = (normalizedPhoneNumber) => normalizedPhoneNumber.substring(0, 2) === '00';\n/**\n * Converts phone number into object where number and area code are separated\n */\nexport const _parse = (normalizedPhoneNumber) => {\n    const parsed = {\n        t1: '',\n        t2: normalizedPhoneNumber,\n    };\n    if (_includesAreaCode(parsed.t2)) {\n        for (const code of AREA_CODES) {\n            const areaCode = `00${code}`;\n            if (parsed.t2.startsWith(areaCode)) {\n                parsed.t1 = code;\n                parsed.t2 = parsed.t2.replace(new RegExp(`^${areaCode}`), '');\n                break;\n            }\n        }\n    }\n    return parsed;\n};\n/**\n * Checks if value is valid hashed TID object\n */\nexport const isValidHashedTidObject = (phoneNumber) => {\n    return (isObject(phoneNumber) &&\n        typeof phoneNumber.t1 === 'string' &&\n        (phoneNumber.t1 === '' || AREA_CODES.includes(phoneNumber.t1)) &&\n        isValidSHA256String(phoneNumber.t2));\n};\n/**\n * Creates object that contains area code and hashed phone number\n */\nexport const createPhoneObject = (phoneNumber, digest = true) => {\n    const normalizedValue = _normalize(phoneNumber);\n    if (!normalizedValue) {\n        return {};\n    }\n    // Convert to object where phone number and area code are separated\n    const phoneObj = _parse(normalizedValue);\n    // too short phone number - not valid\n    if (phoneObj.t2.length < 4) {\n        return {};\n    }\n    if (digest) {\n        // hash phone number\n        phoneObj.t2 = digestMessage(phoneObj.t2);\n    }\n    return phoneObj;\n};\n","import sha256 from 'crypto-js/sha256';\n/**\n * Creates hash of the value\n */\nexport const createHash = (value) => sha256(encodeURI(value.replace(/\\s/g, ''))).toString();\n","const invalidUpdates = [];\nexport const storeInvalidUpdates = (newInvalidUpdates) => invalidUpdates.push(newInvalidUpdates);\nexport const getInvalidUpdatesForBe = () => {\n    var _a, _b, _c;\n    const currentPvid = ((_a = window.sssp) === null || _a === void 0 ? void 0 : _a.isStub) ? undefined : (_c = (_b = window.sssp) === null || _b === void 0 ? void 0 : _b.getPageViewId) === null || _c === void 0 ? void 0 : _c.call(_b);\n    const invalidUpdatesForBe = invalidUpdates.reduce((acc, { identity, value, type, pvid }) => {\n        if (pvid !== currentPvid) {\n            return acc;\n        }\n        if (['aid', 'eid', 'tid'].includes(identity)) {\n            acc = Object.assign(Object.assign({}, acc), { [identity]: value });\n        }\n        if (identity === 'login' && type === 'timeout') {\n            acc.loginTimeout = true;\n        }\n        return acc;\n    }, {});\n    return Object.keys(invalidUpdatesForBe).length ? invalidUpdatesForBe : null;\n};\nexport const getInvalidUpdates = () => invalidUpdates;\n","import { ADDRESS, TELEPHONE } from '@iva/utils';\nimport { IDENTITIES_KEYS, IDENTITIES_VALUES_TYPES, IDENTITY_STATE, VALUES_TYPES, } from '../types';\nimport { createEmailHash } from './externals/eid';\nimport { createHash } from './hash';\nimport { storeInvalidUpdates } from './invalidUpdates';\nimport { castBoolean, isObject, isValidSHA256String, isValidUUID } from './utils';\nimport { debug, sendToConfessor } from './debug';\n// type guard IDENTITY_OBJECT vs IDENTITY_VALUE\nexport const isIdentityObject = (data) => {\n    try {\n        return (data.value !== undefined &&\n            data.created !== undefined &&\n            data.updated !== undefined &&\n            data.state !== undefined &&\n            data.settled !== undefined);\n    }\n    catch (_a) {\n        return false;\n    }\n};\n/**\n * Do we have valid object with at least one identitity set?\n */\nexport const identitiesNotEmpty = (identities) => {\n    return !!(isObject(identities) && Object.keys(identities).length);\n};\n/**\n * Extract just values for each identity\n */\nexport const getIdentitiesValues = (identities) => {\n    const output = {};\n    for (const key in identities) {\n        const identityKey = key;\n        const identityItem = identities[identityKey];\n        if (isIdentityObject(identityItem)) {\n            output[identityKey] = identityItem.value;\n        }\n        else {\n            output[identityKey] = identityItem;\n        }\n    }\n    return output;\n};\n/**\n * Is identificator valid? (Is it out of scope of this lib?).\n */\nexport const validateIdentificator = (identificator) => {\n    if (typeof identificator !== 'string') {\n        return false;\n    }\n    const identificatorSplit = identificator.split('.');\n    return identificatorSplit[0] in IDENTITIES_KEYS;\n};\n/**\n * Helpers for value validation\n */\n// return OK + value\nconst handleOkValue = (value) => ({ ok: true, value });\n// return NOK + store to \"_invalidIdentities\"\nconst handleInvalidValue = (identificator, value) => {\n    var _a;\n    storeInvalidUpdates({\n        identity: identificator,\n        value,\n        type: 'invalid',\n        timestamp: Date.now(),\n        pvid: (_a = window.sssp) === null || _a === void 0 ? void 0 : _a.getPageViewId(),\n    });\n    debug({ type: 'warn', message: `Submitted value \"${value}\" for identity \"${identificator}\" is invalid.` });\n    return { ok: false };\n};\n// check casted values equality\nconst handleCastedValue = (value, castedValue, identificator) => {\n    try {\n        // eslint-disable-next-line eqeqeq\n        if (value == castedValue) {\n            return handleOkValue(castedValue);\n        }\n    }\n    catch (_a) {\n        // no-op\n    }\n    return handleInvalidValue(identificator, value);\n};\n/**\n * Is value type valid? If it is \"translatable\" (\"1234\" to 1234) -> do it\n */\nexport const validateValueType = (identificator, value) => {\n    const expectedType = IDENTITIES_VALUES_TYPES[identificator];\n    // clearing -> allow NULL value\n    if (value === null) {\n        return handleOkValue(value);\n    }\n    // STRING vs INT\n    if (expectedType === VALUES_TYPES.integer && typeof value === VALUES_TYPES.string) {\n        return handleCastedValue(value, parseInt(value, 10), identificator);\n    }\n    // INT / STRING vs BOOLEAN\n    if (expectedType === VALUES_TYPES.boolean && typeof value !== VALUES_TYPES.boolean) {\n        const casted = castBoolean(value);\n        return handleCastedValue(casted !== null && casted !== void 0 ? casted : value, casted, identificator);\n    }\n    try {\n        // address\n        if (expectedType === VALUES_TYPES.addressObject) {\n            const validatedAddress = ADDRESS.createAddressObject(value);\n            return Object.keys(validatedAddress).length > 0\n                ? handleOkValue(validatedAddress)\n                : handleInvalidValue(identificator, value);\n        }\n        // phone number\n        if (expectedType === VALUES_TYPES.phone) {\n            const validatedPhone = TELEPHONE.isValidHashedTidObject(value) ? value : TELEPHONE.createPhoneObject(value);\n            return Object.keys(validatedPhone).length > 0\n                ? handleOkValue(validatedPhone)\n                : handleInvalidValue(identificator, value);\n        }\n        // email -> handle hash or plaintext\n        if (expectedType === VALUES_TYPES.email) {\n            const validatedEmail = isValidSHA256String(value) && !isHashBlacklisted(value) ? value : createEmailHash(value);\n            return validatedEmail ? handleOkValue(validatedEmail) : handleInvalidValue(identificator, value);\n        }\n    }\n    catch (e) {\n        debug('error', e);\n        if (e instanceof Error) {\n            const { message, stack } = e;\n            sendToConfessor(message, 'error', stack);\n        }\n        return handleInvalidValue(identificator, value);\n    }\n    // secid -> handle uuid\n    if (expectedType === VALUES_TYPES.secid) {\n        return isValidUUID(value) ? handleOkValue(value) : handleInvalidValue(identificator, value);\n    }\n    // non valid -> ignored\n    if ((expectedType === VALUES_TYPES.string && typeof value !== VALUES_TYPES.string) ||\n        (expectedType === VALUES_TYPES.array && !Array.isArray(value)) ||\n        (expectedType === VALUES_TYPES.object && (typeof value !== VALUES_TYPES.object || Array.isArray(value))) ||\n        (expectedType === VALUES_TYPES.hashString && !isValidSHA256String(value))) {\n        return handleInvalidValue(identificator, value);\n    }\n    return handleOkValue(value);\n};\n/**\n * Generate value object (add timestamps, ...)\n */\nexport const createIdentityObject = (storageItem, value, state = IDENTITY_STATE.fresh, settled = false) => {\n    return {\n        value,\n        created: (storageItem === null || storageItem === void 0 ? void 0 : storageItem.created) || Date.now(),\n        updated: (settled && (storageItem === null || storageItem === void 0 ? void 0 : storageItem.state) === IDENTITY_STATE.fresh) || !(storageItem === null || storageItem === void 0 ? void 0 : storageItem.updated)\n            ? Date.now()\n            : storageItem.updated,\n        state,\n        settled,\n    };\n};\n/**\n * Identity helpers\n */\n// value extractor\nexport const identityOutput = (identity, rich = false) => (rich ? identity : identity.value);\n// state validator\nexport const isStateValid = (identity, cacheEnough = false) => (identity === null || identity === void 0 ? void 0 : identity.state) === IDENTITY_STATE.fresh || cacheEnough;\n// \"get\" rules validator\nexport const isOK = (identity, cacheEnough = false, justSettled = true) => identity && (!justSettled || (identity === null || identity === void 0 ? void 0 : identity.settled)) && isStateValid(identity, cacheEnough);\n// blacklisted \"no meaning\" hashes\nexport const isHashBlacklisted = (hash) => [createHash('@'), createHash('undefined'), createHash(''), createHash('null'), createHash('unknown')].includes(hash);\n","import { createHash } from '../hash';\n/**\n * Check for valid email format\n * @param value email\n */\nexport const _isValidPlaintextEmail = (value) => {\n    if (typeof value !== 'string') {\n        return false;\n    }\n    // simple email format\n    const format = /^.+@.+\\..+$/;\n    return !!value.match(format);\n};\n/**\n * Creates hash from plaintext email. If email format is invalid, returns empty string\n * @param value\n */\nexport const createEmailHash = (value) => _isValidPlaintextEmail(value) ? createHash(value.toLowerCase()) : '';\n","import { getGlobalConfig } from '../config';\nimport { CONSENT } from '@sklik/cmp2-common';\nimport { DOT_CONFIG_PROPERTIES, IDENTITIES_KEYS, IDENTITY_STATE, } from '../../types';\nimport { TIMEOUT } from '../consts';\nimport { createIdentityObject } from '../identities';\nimport { storeInvalidUpdates } from '../invalidUpdates';\nimport { isObject } from '../utils';\nimport { debug } from '../debug';\n/**\n * Get consent string / consent object from login identity (if any)\n */\nconst _parseLoginConsent = (loginIdentity) => {\n    const consentString = loginIdentity ? getLoginConsentString(loginIdentity) : null;\n    const consentResult = loginIdentity ? getLoginConsentFormatedResult(consentString) : null;\n    return { consentResult, consentString };\n};\n/**\n * Get LOGIN (window.login.current -> storage -> null)\n */\nexport const getLoginByPriority = (loginIdentity) => getExtendedLoginFromWindowObject() || loginIdentity || null;\n/**\n * Get a shallow copy of `window.login.current` and `window.login.current.others`\n * if at least one parameter in `keys` is truthy\n */\nexport const getLoginObject = () => {\n    var _a, _b, _c;\n    const keys = ['advert_uid', 'uid'];\n    const hasLoginId = keys.some((key) => { var _a, _b; return (_b = (_a = window.login) === null || _a === void 0 ? void 0 : _a.current) === null || _b === void 0 ? void 0 : _b[key]; });\n    const isLoginForgotten = ((_b = (_a = window.login) === null || _a === void 0 ? void 0 : _a.current) === null || _b === void 0 ? void 0 : _b.state) === 'forget';\n    if (!((_c = window.login) === null || _c === void 0 ? void 0 : _c.current) || (!hasLoginId && !isLoginForgotten)) {\n        return undefined;\n    }\n    const loginCopy = Object.assign({}, window.login.current);\n    if (window.login.current.others) {\n        loginCopy.others = [...window.login.current.others];\n    }\n    return loginCopy;\n};\nexport const getBadgeFromDot = () => { var _a; return !!((_a = window.DOT) === null || _a === void 0 ? void 0 : _a.getCfgValue(DOT_CONFIG_PROPERTIES.badge)); };\n/**\n * Get consent value from window.login object (copy \"advert_uid\" to \"said\", parse \"consentString\" from \"euconsent\")\n */\nexport const getExtendedLoginFromWindowObject = () => {\n    const loginCurrent = getLoginObject();\n    if (!loginCurrent) {\n        return;\n    }\n    const output = loginCurrent;\n    if (output.advert_uid) {\n        output.said = output.advert_uid;\n    }\n    if (output.euconsent) {\n        try {\n            const parsedConsentString = getLoginConsentString(output);\n            if (parsedConsentString) {\n                output.consentString = parsedConsentString;\n            }\n        }\n        catch (_a) {\n            // no-op\n        }\n    }\n    if (Array.isArray(output.others)) {\n        output.others = output.others.map((o) => {\n            return isObject(o) && o.advert_uid ? Object.assign(Object.assign({}, o), { said: o.advert_uid }) : o;\n        });\n    }\n    return output;\n};\n/**\n * Add LOGIN (/CONSENT) to identitites object (if any)\n */\nexport const getLogin = (identities) => {\n    const login = getExtendedLoginFromWindowObject();\n    const getIdentityObject = (key, value) => {\n        return createIdentityObject(identities[key], value, IDENTITY_STATE.fresh, true);\n    };\n    if (login) {\n        identities[IDENTITIES_KEYS.login] = getIdentityObject(IDENTITIES_KEYS.login, login);\n        const { consentResult } = _parseLoginConsent(login);\n        if (consentResult) {\n            debug({ message: 'LOGIN (sync): Setting CONSENT identity from LOGIN.euconsent', consentResult });\n            identities[IDENTITIES_KEYS.consent] = getIdentityObject(IDENTITIES_KEYS.consent, consentResult);\n        }\n        else if ((login === null || login === void 0 ? void 0 : login.state) && login.state !== 'forget') {\n            debug({ message: 'LOGIN (sync): Removing CONSENT identity because global LOGIN.euconsent missing' });\n            identities[IDENTITIES_KEYS.consent] = getIdentityObject(IDENTITIES_KEYS.consent, null);\n        }\n    }\n};\n/**\n * Listen to events emited by BADGE\n */\nexport const listenToBadge = (updater, getter) => {\n    var _a, _b;\n    const handler = ({ loginTimeoutExceeded } = {}) => {\n        var _a, _b;\n        const existsInStorage = getter(IDENTITIES_KEYS.login);\n        const login = getExtendedLoginFromWindowObject();\n        // \"login\" (Badge) might be undefined because Badge is not used on every external service\n        //  we need to check first if \"window.login\" created by Badge is present\n        if (window.login && !login && loginTimeoutExceeded) {\n            storeInvalidUpdates({\n                identity: IDENTITIES_KEYS.login,\n                type: 'timeout',\n                timestamp: Date.now(),\n                pvid: (_a = window.sssp) === null || _a === void 0 ? void 0 : _a.getPageViewId(),\n            });\n        }\n        if (login || existsInStorage) {\n            const value = (login || existsInStorage.value);\n            const state = login ? IDENTITY_STATE.fresh : existsInStorage.state;\n            const updated = { login: { value, state } };\n            const newUid = login === null || login === void 0 ? void 0 : login.advert_uid;\n            const oldUid = (_b = existsInStorage === null || existsInStorage === void 0 ? void 0 : existsInStorage.value) === null || _b === void 0 ? void 0 : _b.advert_uid;\n            // \"rusId\" changed?  wipe out CONSENT by default | wipe out ID5 if newUid present\n            if (newUid && newUid !== oldUid) {\n                debug({ message: 'LOGIN: Removing CONSENT identity because LOGIN.uid changed' });\n                updated.consent = { value: null, state: IDENTITY_STATE.fresh };\n                updated.id5 = { value: null, state: IDENTITY_STATE.fresh };\n            }\n            const { consentResult } = _parseLoginConsent(login);\n            // LOGIN with CONSENT present -> write CONSENT\n            if (consentResult) {\n                debug({\n                    message: 'LOGIN (async): Setting CONSENT identity from window.login.current.euconsent',\n                    consentResult,\n                });\n                updated.consent = {\n                    value: consentResult,\n                    state: IDENTITY_STATE.fresh,\n                };\n            }\n            else if ((login === null || login === void 0 ? void 0 : login.state) && login.state !== 'forget') {\n                debug({ message: 'LOGIN: Removing CONSENT identity because global LOGIN.consent missing' });\n                updated.consent = { value: null, state: IDENTITY_STATE.fresh };\n            }\n            updater(updated);\n        }\n    };\n    const loginTimer = window.setTimeout(() => {\n        handler({ loginTimeoutExceeded: true });\n    }, ((_b = (_a = getGlobalConfig()) === null || _a === void 0 ? void 0 : _a.timeouts) === null || _b === void 0 ? void 0 : _b[IDENTITIES_KEYS.login]) || TIMEOUT);\n    const done = () => {\n        window.clearTimeout(loginTimer);\n        handler();\n    };\n    window.addEventListener('badge', done);\n    window.addEventListener('login', done);\n    window.addEventListener('logout', done);\n    window.addEventListener('forget', done);\n};\n/**\n * Get parsed euconsent object from login identity\n */\nexport const getLoginConsentString = (loginIdentity) => {\n    var _a, _b;\n    let loginConsent = null;\n    if (loginIdentity) {\n        try {\n            loginConsent = (_b = (_a = JSON.parse(loginIdentity.euconsent)) === null || _a === void 0 ? void 0 : _a.v2) === null || _b === void 0 ? void 0 : _b.encodedCookie;\n        }\n        catch (_c) {\n            // no-op\n        }\n    }\n    return loginConsent;\n};\n/**\n * Gets ConsentResult object from \"login\" identity (mirroring format from \"cmp2-common\")\n */\nexport const getLoginConsentFormatedResult = (loginConsentString) => {\n    if (!loginConsentString) {\n        return null;\n    }\n    return {\n        version: 'v2',\n        name: `euconsent-v2`,\n        consentString: loginConsentString,\n        purposeOne: CONSENT.hasPurposeOne(loginConsentString),\n    };\n};\n","import { CONSENT } from '@sklik/cmp2-common';\nimport { getGlobalConfig } from '../config';\nimport { IDENTITIES_KEYS, IDENTITY_STATE, } from '../../types';\nimport { TIMEOUT } from '../consts';\nimport { createIdentityObject } from '../identities';\nimport { getLoginByPriority, getLoginConsentString } from './login';\nimport { debug } from '../debug';\n/**\n * Get consent value from cookie/s\n */\nconst _getConsentFromCookieOrTcfApi = (cb) => {\n    try {\n        return CONSENT.getConsentFromCookieList(cb);\n    }\n    catch (_a) {\n        return null;\n    }\n};\n/**\n * Add CONSENT to identitites object (if any -> cookie / tcf)\n * If LOGIN is present (window or storage) and has euconsent -> terminate\n */\nexport const getConsent = (identities) => {\n    var _a;\n    const loginObject = getLoginByPriority((_a = identities[IDENTITIES_KEYS.login]) === null || _a === void 0 ? void 0 : _a.value);\n    if (getLoginConsentString(loginObject) || ((loginObject === null || loginObject === void 0 ? void 0 : loginObject.state) && loginObject.state !== 'forget')) {\n        debug({\n            message: 'CONSENT (sync): Exiting CONSENT identity read because LOGIN.euconsent found',\n        });\n        return;\n    }\n    const consent = _getConsentFromCookieOrTcfApi();\n    if (consent) {\n        debug({\n            message: 'CONSENT (sync): Storing CONSENT identity because LOGIN (window / storage) not found',\n            consent,\n        });\n        identities[IDENTITIES_KEYS.consent] = createIdentityObject(identities[IDENTITIES_KEYS.consent], consent, IDENTITY_STATE.fresh, true);\n    }\n};\n/**\n * Listen to events emited by CMP dialog (close / submit)\n */\nexport const listenToCmpDialogEvents = (updater, getter) => {\n    var _a, _b;\n    const handler = (consentResult) => {\n        var _a, _b;\n        const existsInStorage = getter(IDENTITIES_KEYS.consent);\n        const consent = consentResult || _getConsentFromCookieOrTcfApi();\n        if (consent || existsInStorage) {\n            const value = consent || existsInStorage.value;\n            const state = consent ? IDENTITY_STATE.fresh : existsInStorage.state;\n            const updated = {};\n            // let's try to update \"consent\" -> but first check if \"login\" not present\n            if (!getLoginConsentString(getLoginByPriority((_a = getter(IDENTITIES_KEYS.login)) === null || _a === void 0 ? void 0 : _a.value))) {\n                debug({\n                    message: 'CONSENT (async): Storing CONSENT identity because LOGIN (window / storage) not found',\n                    consent: { value, state },\n                });\n                updated.consent = { value, state };\n            }\n            // \"purposeOne\" not given -> wipe out ID5\n            if (updated.consent && !((_b = updated.consent.value) === null || _b === void 0 ? void 0 : _b.purposeOne)) {\n                updated.id5 = { value: null, state: IDENTITY_STATE.fresh };\n            }\n            updater(updated);\n        }\n    };\n    let tcfApiHooked = false;\n    let consentTimer = null;\n    let tfcInterval = null;\n    // timeout for settling -> terminated by succesfull \"_getConsentFromCookieOrTcfApi\" data\n    consentTimer = window.setTimeout(() => {\n        window.clearInterval(tfcInterval);\n        handler();\n    }, ((_b = (_a = getGlobalConfig()) === null || _a === void 0 ? void 0 : _a.timeouts) === null || _b === void 0 ? void 0 : _b[IDENTITIES_KEYS.consent]) || TIMEOUT);\n    // when window.__tcfapi ready -> call _getConsentFromCookieOrTcfApi with callback\n    const hookTFC = () => {\n        if (typeof window.__tcfapi === 'function') {\n            tcfApiHooked = true;\n            window.clearInterval(tfcInterval);\n            const sendToHandler = (consentResult) => {\n                if (consentResult) {\n                    window.clearTimeout(consentTimer);\n                    handler(consentResult);\n                }\n            };\n            const consentSyncCheck = _getConsentFromCookieOrTcfApi((consentResult) => {\n                sendToHandler(consentResult);\n            });\n            sendToHandler(consentSyncCheck);\n        }\n    };\n    // first tcf hook try\n    hookTFC();\n    // if TCF not already hooked -> start checking loop (terminated by \"consentTimeout\" or succesfull \"_getConsentFromCookieOrTcfApi\" data)\n    if (!tcfApiHooked) {\n        tfcInterval = window.setInterval(() => {\n            hookTFC();\n        }, 500);\n    }\n    // after scmp redirect (consent cookie set)\n    const done = () => {\n        window.clearTimeout(consentTimer);\n        window.clearInterval(tfcInterval);\n        handler();\n    };\n    window.addEventListener('scmp_redirect_done', done);\n    window.addEventListener('scmp_ready', done);\n    window.addEventListener('scmp_agreed', done);\n    window.addEventListener('scmp_consent_set', done);\n};\n","import { validateCookieString } from './modules/validation.js';\n/**\n * Method 'setCookie' sets cookie with the given value.\n * @param {String} name - Name of the cookie\n * @param {String} value - Value to be saved into the cookie\n * @param {Object} [configuration = {}] - additional configuration of the cookie\n * Example configuration = {path: '/', domain: 'domain.com', secure: true, ..}\n * Default configuration = {path: '/'}\n */\nexport const setCookie = (name, value, configuration = {}) => {\n    const options = {\n        path: '/',\n        ...configuration,\n    };\n    if (options.expires instanceof Date) {\n        options.expires = options.expires.toUTCString();\n    }\n    let updatedCookie = validateCookieString(`${name}=${value}`);\n    for (const optionKey in options) {\n        const optionValue = options[optionKey];\n        if (!optionValue) {\n            continue;\n        }\n        updatedCookie += '; ' + optionKey + (optionValue === true ? '' : '=' + optionValue);\n    }\n    document.cookie = updatedCookie;\n};\n/**\n * Method 'getCookie' gets cookie with provided name.\n * @param {String} name - Name of the cookie\n * @return {null | String } - description of each case:\n * null there is not cookie\n * string with value of cookie\n * string[] array of value of cookies (several cookies of the same name were found)\n */\nexport const getCookie = (name) => {\n    const { [1]: match } = document.cookie.match(new RegExp('(?:^|; )' + name.replace(/([\\.$?*|{}\\(\\)\\[\\]\\\\\\/\\+^])/g, '\\\\$1') + '=([^;]*)')) ??\n        [];\n    return match ? decodeURIComponent(match) : null;\n};\n/**\n * Method 'removeCookie' deletes cookie with provided name.\n * @param {String} name - Name of the cookie\n * @param {Object} [configuration = {}] - additional configuration of the cookie\n * Example configuration = {path: '/', domain: 'domain.com', secure: true, ..}\n */\nexport const removeCookie = (name, configuration = {}) => {\n    configuration['max-age'] = -1;\n    setCookie(name, '', configuration);\n};\n","/**\n * According to original cookie spec https://curl.se/rfc/cookie_spec.html:\n * \"NAME=VALUE This string is a sequence of characters excluding semi-colon, comma and white space.\"\n * So any \";\", \",\" and \" \" will be ommited.\n * @param str Key=Value pair potentially with forbidden characters.\n */\nexport const validateCookieString = (str) => str.replace(/[\\s\\,\\;]/gi, '');\n","import { getGlobalConfig } from '../config';\nimport { IDENTITIES_KEYS, IDENTITY_STATE, } from '../../types';\nimport { COOKIE } from '@iva/utils';\nimport { TIMEOUT } from '../consts';\nimport { createIdentityObject } from '../identities';\n/**\n * Get udid value from cookie/s\n */\nconst _getUdidFromCookie = () => COOKIE.getCookie('udid');\n/**\n * Add udid to identitites object (if any)\n */\nexport const getUdid = (identities) => {\n    const udid = _getUdidFromCookie();\n    if (udid) {\n        identities[IDENTITIES_KEYS.udid] = createIdentityObject(identities[IDENTITIES_KEYS.udid], udid, IDENTITY_STATE.fresh, true);\n    }\n};\n/**\n * Listen to events emited by MARKER\n */\nexport const listenToMarker = (updater, getter) => {\n    var _a, _b;\n    const handler = () => {\n        const existsInStorage = getter(IDENTITIES_KEYS.udid);\n        const udid = _getUdidFromCookie();\n        if (udid || existsInStorage) {\n            const value = udid || existsInStorage.value;\n            const state = udid ? IDENTITY_STATE.fresh : existsInStorage.state;\n            updater({ udid: { value, state } });\n        }\n    };\n    const udidTimer = window.setTimeout(() => {\n        handler();\n    }, ((_b = (_a = getGlobalConfig()) === null || _a === void 0 ? void 0 : _a.timeouts) === null || _b === void 0 ? void 0 : _b[IDENTITIES_KEYS.udid]) || TIMEOUT);\n    const done = () => {\n        window.clearTimeout(udidTimer);\n        handler();\n    };\n    window.addEventListener('szn:marker:cookie', done);\n};\n","import { getDomainLevel } from './url.js';\nimport { getCookie, removeCookie } from './cookie.js';\nimport { SID } from './constants.js';\n/**\n * Accepts sid candidate and returns true if sid is valid and false if not.\n * It can handle any value, only sid in string format may evaluate to true.\n * @param sid Potentially valid sid\n * @return True if valid sid, false otherwise\n */\nexport const isValidSid = (sid) => typeof sid === 'string' && !!sid.match(/^id=(\\d+)\\|t=(\\d+\\.\\d{3})\\|te=(\\d+\\.\\d{3})\\|c=([A-Z0-9]{32})$/);\n/**\n * Encodes sid into \"znstring\". Can handle any input, but only\n * valid sid in string format will yield actual hash.\n * @param sid Potentially valid sid\n * @return Hash if valid sid, null otherwise\n */\nexport const sidToHash = (sid) => {\n    if (!isValidSid(sid)) {\n        return null;\n    }\n    // atob and btoa may throw an exception, see https://developer.mozilla.org/en-US/docs/Web/API/atob#exceptions\n    try {\n        return window.btoa(encodeURIComponent(sid));\n    }\n    catch {\n        return null;\n    }\n};\n/**\n * Decodes \"znstring\" into sid. Can handle any input, but only\n * valid \"znstring\" in string format will yield sid.\n * @param hash Potentially hashed sid\n * @return Sid if valid hash, null otherwise\n */\nexport const hashToSid = (hash) => {\n    if (typeof hash !== 'string') {\n        return null;\n    }\n    // atob and btoa may throw an exception, see https://developer.mozilla.org/en-US/docs/Web/API/atob#exceptions\n    try {\n        const sid = decodeURIComponent(window.atob(hash));\n        if (isValidSid(sid)) {\n            return sid;\n        }\n        else {\n            return null;\n        }\n    }\n    catch {\n        return null;\n    }\n};\n/**\n * Retrieves sid cookie, validates its value and returns valid sid or null.\n * @return Valid sid or null\n */\nexport const getValidSidFromCookie = () => {\n    const sidCookieValue = getCookie(SID);\n    return isValidSid(sidCookieValue) ? sidCookieValue : null;\n};\n/**\n * Retrieves sid cookie, validates its value and removes the cookie\n * if the value is not a valid sid.\n */\nexport const removeInvalidSidCookie = () => {\n    if (!isValidSid(getCookie(SID))) {\n        removeCookie(SID, { domain: getDomainLevel(), path: '/' });\n    }\n};\n","import { getGlobalConfig } from '../config';\nimport { IDENTITIES_KEYS, IDENTITY_STATE, } from '../../types';\nimport { COOKIE, SID_UTILS } from '@iva/utils';\nimport { TIMEOUT } from '../consts';\nimport { createIdentityObject } from '../identities';\n/**\n * Get valid sid value from cookie/s. In case value is invalid, returns null\n */\nconst _getSidFromCookie = () => {\n    const sid = COOKIE.getCookie('sid');\n    return SID_UTILS.isValidSid(sid) ? sid : null;\n};\n/**\n * Add sid to identitites object (if any)\n */\nexport const getSid = (identities) => {\n    const sid = _getSidFromCookie();\n    if (sid) {\n        identities[IDENTITIES_KEYS.sid] = createIdentityObject(identities[IDENTITIES_KEYS.sid], sid, IDENTITY_STATE.fresh, true);\n    }\n};\n/**\n * Listen to events emited by DOT / LINKDEC\n */\nexport const listenToSidEvents = (updater, getter) => {\n    var _a, _b;\n    const handler = () => {\n        const existsInStorage = getter(IDENTITIES_KEYS.sid);\n        const sid = _getSidFromCookie();\n        if (sid || existsInStorage) {\n            const value = sid || existsInStorage.value;\n            const state = sid ? IDENTITY_STATE.fresh : existsInStorage.state;\n            updater({ sid: { value, state } });\n        }\n    };\n    const sidTimer = window.setTimeout(() => {\n        handler();\n    }, ((_b = (_a = getGlobalConfig()) === null || _a === void 0 ? void 0 : _a.timeouts) === null || _b === void 0 ? void 0 : _b[IDENTITIES_KEYS.sid]) || TIMEOUT);\n    const done = () => {\n        window.clearTimeout(sidTimer);\n        handler();\n    };\n    window.addEventListener('szn:dot:cookie', done);\n    window.addEventListener('szn:linkdecoration:sid', done);\n};\n","import { EVENT_FROM_TOP_NAME, EVENT_TO_TOP_NAME, TIMEOUT_PREMATURE_LOGIN } from './consts';\nimport { debug } from './debug';\nimport { getLoginObject } from './externals/login';\nimport { getIS } from './namespace';\nimport { isObject } from './utils';\nimport { isCrossFrameBridgeActive } from './config';\n// are we in top level?\nexport const isTopLevel = window.top === window.self && !window.frameElement;\n// some metadata about TOP -> synced to frames\nlet topLevelInfo = {\n    hasLoginBadge: false,\n};\nexport const getTopLevelInfo = () => topLevelInfo;\n/**\n * Feed all registered child frames\n */\nexport const feedChildFrames = (data) => {\n    if (!isTopLevel || !isCrossFrameBridgeActive()) {\n        return;\n    }\n    if (Array.isArray(getIS()._childFramesToFeed) && getIS()._childFramesToFeed.length) {\n        const { identities, topLevelData } = data;\n        getIS()._childFramesToFeed.forEach((f) => {\n            try {\n                (identities || topLevelData) && f.postMessage({ type: EVENT_FROM_TOP_NAME, identities, topLevelData }, '*');\n            }\n            catch (err) {\n                debug({ type: 'error', message: 'Post message to child frame error', err });\n            }\n        });\n    }\n};\n/**\n * Checking loop for login badge - is at least stub present?\n */\nconst loginBadgeCheck = () => {\n    const interval = Math.max(TIMEOUT_PREMATURE_LOGIN / 10, 100);\n    let attempts = 0;\n    const maxAttempts = Math.floor(TIMEOUT_PREMATURE_LOGIN / interval);\n    const badgeLoop = maxAttempts &&\n        window.setInterval(() => {\n            attempts++;\n            const hasLogin = !!getLoginObject();\n            if (hasLogin || attempts >= maxAttempts) {\n                topLevelInfo.hasLoginBadge = hasLogin;\n                badgeLoop && window.clearInterval(badgeLoop);\n                feedChildFrames({ topLevelData: { hasLoginBadge: hasLogin } });\n            }\n        }, interval);\n};\n/**\n * Register new child IS subscriber / listener in top IS\n * Feed current identitites to child IS\n */\nexport const handlerFromChildMessage = (event, getter) => {\n    var _a;\n    if (event.source && ((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === EVENT_TO_TOP_NAME) {\n        debug(`Registering child IS ${event.origin}`);\n        getIS()._childFramesToFeed.push(event.source);\n        feedChildFrames({ identities: getter() });\n    }\n};\n/**\n * Receive in child IS idetitites data from top IS\n * Update self storage (just identities which are not already existing)\n */\nexport const handlerFromTopMessage = (event, updater) => {\n    var _a, _b, _c, _d, _e;\n    if (((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === EVENT_FROM_TOP_NAME) {\n        if (((_b = event.data) === null || _b === void 0 ? void 0 : _b.identities) && isObject((_c = event.data) === null || _c === void 0 ? void 0 : _c.identities)) {\n            debug({ message: 'Data from top IS', identities: event.data.identities });\n            updater(event.data.identities);\n        }\n        if (((_d = event.data) === null || _d === void 0 ? void 0 : _d.topLevelData) && isObject((_e = event.data) === null || _e === void 0 ? void 0 : _e.topLevelData)) {\n            topLevelInfo = Object.assign(Object.assign({}, topLevelInfo), event.data.topLevelData);\n        }\n    }\n};\n/**\n * IS can be on page multiple times (in nested frames etc)\n * Child frame IS can ask / subscribe IS state (and its changes) to top frame IS\n */\nexport const initCrossFramesCommunication = (updater, getter) => {\n    // communication disabled by config\n    if (!isCrossFrameBridgeActive()) {\n        return;\n    }\n    if (isTopLevel) {\n        // register child IS subscriber / listener\n        window.addEventListener('message', (event) => handlerFromChildMessage(event, getter));\n        // check login badge and propagate\n        loginBadgeCheck();\n    }\n    else {\n        // cypress hack (cypress tests are running inside iframe -> window.top is not, what exected)\n        let destination = 'top';\n        try {\n            destination = window.Cypress || window.parent.Cypress ? 'parent' : 'top';\n        }\n        catch (_a) {\n            // no-op\n        }\n        // register self in top frame (top IS instance)\n        window[destination].postMessage({ type: EVENT_TO_TOP_NAME }, '*');\n        // listen to parent data\n        window.addEventListener('message', (event) => handlerFromTopMessage(event, updater));\n    }\n};\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { debug } from '../debug';\nimport { IDENTITIES_KEYS, } from '../../types';\nimport { EVENT_NAME, ID5_URL, TIMEOUT } from '../consts';\nimport { isTopLevel } from '../frames';\nimport { getHostname, loadScript } from '../utils';\nlet _instance = null;\nconst servicesDisallowed = ['email.seznam.cz'];\nconst services = [\n    'horoskopy.cz',\n    'novinky.cz',\n    'super.cz',\n    'hry.seznam.cz',\n    'prozeny.cz',\n    'seznamzpravy.cz',\n    'garaz.cz',\n    'sport.cz',\n];\n/**\n * On some services we are certain we do not want to run ID5\n */\nexport const _isBlacklistedService = () => {\n    return servicesDisallowed.includes(getHostname());\n};\n/**\n * On some services (internal) we are certain we can run ID5\n */\nexport const _isWhitelistedService = () => {\n    var _a, _b;\n    // debug / testing purposes\n    if ((_b = (_a = window.location) === null || _a === void 0 ? void 0 : _a.href) === null || _b === void 0 ? void 0 : _b.includes('allow_hostname_for_id5=1')) {\n        return true;\n    }\n    return services.includes(getHostname());\n};\n/**\n * Is WHITELISTED service or service with SSP script (partner)? Go ahead right away\n */\nexport const _isValidService = () => {\n    // TODO: consider SUL metadata as well\n    return !_isBlacklistedService() && (_isWhitelistedService() || !!window.sssp);\n};\n/**\n * Run whole ID5 flow only in some environments (one time check at beginning)\n */\nexport const _isValidEnvironment = () => {\n    return isTopLevel;\n};\n/**\n * Create instance (singleton with SEZNAM specific partnerId)\n */\nexport const _getInstance = (handler) => {\n    if (!_instance && window.ID5) {\n        try {\n            _instance = window.ID5.init({ partnerId: 265, cmpApi: 'iab' });\n            _instance.onAvailable(handler, TIMEOUT);\n            _instance.onUpdate(handler, TIMEOUT);\n        }\n        catch (_a) {\n            debug({ type: 'error', message: 'ID5 instance creation failed' });\n        }\n    }\n};\n/**\n * We can generate / fetch ID5 and store it in IS only \"with consent\" (used multiple times during LOGIN lifecycle updates)\n */\nexport const _canPropagateID5ToIS = (getter) => {\n    var _a;\n    const consent = getter(IDENTITIES_KEYS.consent);\n    return (_isValidService() &&\n        (\n        // consented\n        (_a = consent === null || consent === void 0 ? void 0 : consent.value) === null || _a === void 0 ? void 0 : _a.purposeOne));\n};\n/**\n * Fetch ID5 identificator (if not locally stored -> make api call)\n */\nexport const fetchId5 = (updater, getter) => {\n    // hard stop for some environments\n    if (!_isValidEnvironment()) {\n        return;\n    }\n    // create instance + fetch (if \"login, consent, ...\" conditions met)\n    const handler = () => __awaiter(void 0, void 0, void 0, function* () {\n        if (!_canPropagateID5ToIS(getter)) {\n            return;\n        }\n        try {\n            if (!window.ID5) {\n                yield loadScript(ID5_URL, 'id5');\n            }\n        }\n        catch (_a) {\n            debug({ type: 'error', message: 'ID5 script not loaded' });\n            return;\n        }\n        const ID5handler = (status) => __awaiter(void 0, void 0, void 0, function* () {\n            // anxious check (maybe login, consent, ... conditions changed in meantime)\n            if (!(yield _canPropagateID5ToIS(getter))) {\n                return;\n            }\n            const newId5 = status.getUserId();\n            if (newId5) {\n                updater({ id5: { value: newId5 } });\n            }\n        });\n        _getInstance(ID5handler);\n    });\n    handler();\n    // listen for login / consent changes\n    window.addEventListener(EVENT_NAME, ((e) => {\n        const { changes } = e.detail;\n        if (changes.includes(IDENTITIES_KEYS.login) || changes.includes(IDENTITIES_KEYS.consent)) {\n            handler();\n        }\n    }));\n    // listen for SSSP being loaded\n    if (!_isBlacklistedService() && !_isWhitelistedService()) {\n        window.addEventListener('ssploaded', handler);\n    }\n};\n","import { IDENTITIES_KEYS } from '../../types';\nimport { getConsent, listenToCmpDialogEvents } from './consent';\nimport { getBadgeFromDot, getLogin, listenToBadge } from './login';\nimport { getUdid, listenToMarker } from './udid';\nimport { getSid, listenToSidEvents } from './sid';\nimport { isAvailable } from '../config';\nimport { getTopLevelInfo } from '../frames';\nimport { TIMEOUT_PREMATURE_LOGIN } from '../consts';\nimport { fetchId5 } from './id5';\n/**\n * Pull identities in sync way (from cookies, ...)\n */\nexport const pullExternalsSync = (identities) => {\n    // consent\n    isAvailable(IDENTITIES_KEYS.consent) && getConsent(identities);\n    // login\n    isAvailable(IDENTITIES_KEYS.login) && getLogin(identities);\n    // udid\n    isAvailable(IDENTITIES_KEYS.udid) && getUdid(identities);\n    // sid\n    isAvailable(IDENTITIES_KEYS.sid) && getSid(identities);\n};\n/**\n * Pull identities in async way (from events, messages,...)\n */\nexport const pullExternalsAsync = (initObject, updater, getter) => {\n    const getterSpecified = (identificator) => {\n        var _a;\n        return (_a = getter()[identificator]) !== null && _a !== void 0 ? _a : initObject[identificator];\n    };\n    // consent\n    isAvailable(IDENTITIES_KEYS.consent) && listenToCmpDialogEvents(updater, getterSpecified);\n    // login\n    isAvailable(IDENTITIES_KEYS.login) && listenToBadge(updater, getterSpecified);\n    // udid\n    isAvailable(IDENTITIES_KEYS.udid) && listenToMarker(updater, getterSpecified);\n    // sid\n    isAvailable(IDENTITIES_KEYS.sid) && listenToSidEvents(updater, getterSpecified);\n    // id5\n    isAvailable(IDENTITIES_KEYS.id5) && fetchId5(updater, getterSpecified);\n};\n/**\n * Optional callbacks for \"early settling\"\n * For example after 1s there is no window.login.current object -> we can asume SZN badge is not in page\n */\nexport const prematureSettling = {\n    [IDENTITIES_KEYS.login]: (cb) => {\n        return window.setTimeout(() => {\n            // run premature callback\n            if (!getBadgeFromDot() && !getTopLevelInfo().hasLoginBadge) {\n                return cb(null);\n            }\n        }, TIMEOUT_PREMATURE_LOGIN);\n    },\n};\n","/**\n * Send custom event with detailed data\n */\nexport const sendEvent = (eventName, data) => {\n    const event = new CustomEvent(eventName, { detail: data || null });\n    window.dispatchEvent(event);\n};\n","import { getIdentitiesValues } from './identities';\n/**\n * Subscribers / observers\n */\nlet _subscribers = [];\nexport const runSubscribers = (data) => {\n    if (_subscribers.length) {\n        let justValues = null;\n        _subscribers.forEach((s) => {\n            if (!s.rich && !justValues) {\n                justValues = getIdentitiesValues(data.identities);\n            }\n            s.callback(Object.assign(Object.assign({}, data), { identities: s.rich ? data.identities : justValues }));\n        });\n    }\n};\n/**\n * Subscribe to storage changes.\n * Returns function for unsubscribing.\n */\nexport const subscribe = (callback, rich = false) => {\n    _subscribers.push({ callback, rich });\n    return () => {\n        _subscribers = _subscribers\n            .map((s) => {\n            return s.callback === callback ? null : s;\n        })\n            .filter(Boolean);\n    };\n};\n","import { IDENTITY_STATE, IDENTITIES_KEYS_SPECIAL, } from '../types';\nimport { setCache } from './cache';\nimport { isAvailable } from './config';\nimport { EVENT_NAME } from './consts';\nimport { debug } from './debug';\nimport { sendEvent } from './events';\nimport { feedChildFrames } from './frames';\nimport { createIdentityObject, isIdentityObject, validateIdentificator, validateValueType } from './identities';\nimport { getIS } from './namespace';\nimport { runSubscribers } from './subscribing';\nimport { isObject } from './utils';\n/**\n * Create / pollute IS object\n */\nexport const prepareIdentityStorageObject = (mergeData = {}) => {\n    const IS = getIS();\n    // merge data to existing IS object\n    const composeIS = () => (Object.assign(Object.assign({}, (IS || {})), mergeData));\n    if (IS) {\n        window.sznIVA.IS = composeIS();\n    }\n    else {\n        window.sznIVA = Object.assign(Object.assign({}, (window.sznIVA || {})), { IS: composeIS() });\n    }\n};\n/**\n * Cache storage state and notify rest of the world (send events / post messages, run subscribers).\n */\nexport const cacheAndNotify = (encoded, identities, changes) => {\n    if (encoded) {\n        setCache(encoded);\n    }\n    runSubscribers({ identities, changes });\n    sendEvent(EVENT_NAME, { identities, changes });\n    feedChildFrames({ identities });\n    debug('Cached and notified');\n};\n/**\n * Get value from identity (root or by dot notation -> sublevel of value object).\n */\nexport const getValueLevel = (identificator, identityValue) => {\n    var _a;\n    const identificatorSplit = identificator.split('.');\n    const subSplit = identificatorSplit.slice(1);\n    const reducer = (data) => subSplit.reduce((acc, key) => (acc || {})[key], data);\n    let value = null;\n    if (isIdentityObject(identityValue)) {\n        const { value: parsedValue } = identityValue;\n        value = parsedValue;\n    }\n    else {\n        value = identityValue;\n    }\n    const isValueObject = isObject(value);\n    const isRich = !!(identityValue === null || identityValue === void 0 ? void 0 : identityValue.value);\n    let subValue = null;\n    if (subSplit.length) {\n        subValue = isValueObject ? ((_a = reducer(value)) !== null && _a !== void 0 ? _a : null) : null;\n    }\n    else {\n        subValue = value;\n    }\n    if (isRich && subValue !== null) {\n        return Object.assign(Object.assign({}, identityValue), { value: subValue });\n    }\n    else {\n        return subValue;\n    }\n};\n/**\n * Create IDENTITY parcial object from each value ({value: ...})\n */\nexport const createValuesObjects = (identities, createValueForSpecial) => {\n    const specials = {}; // special identities (rusId, said, ...)\n    return Object.keys(identities).reduce((acc, key) => {\n        let keyHandled = key;\n        let valueHandled = identities[key];\n        // is special identity?\n        if (key in IDENTITIES_KEYS_SPECIAL) {\n            const k = key;\n            // transform key to main identity and prepare wrapped value\n            keyHandled = createValueForSpecial(k, valueHandled, specials);\n            if (keyHandled) {\n                valueHandled = specials[keyHandled];\n            }\n        }\n        if (keyHandled && valueHandled !== null && valueHandled !== undefined) {\n            acc[keyHandled] = { value: valueHandled };\n        }\n        return acc;\n    }, {});\n};\n/**\n * Sanitize submited identities.\n * Filter not supported ones.\n */\nexport const sanitizeIdentities = (storage, newIdentities) => {\n    const sanitedIdentities = {};\n    if (!isObject(newIdentities)) {\n        debug({ type: 'warn', message: `Submited identities data are invalid`, newIdentities });\n        return {};\n    }\n    Object.keys(newIdentities).forEach((iKey) => {\n        if (validateIdentificator(iKey)) {\n            const k = iKey;\n            const identityObject = newIdentities[k];\n            const valueValidated = validateValueType(k, identityObject.value);\n            if (!isAvailable(k) || !valueValidated.ok) {\n                debug({\n                    type: 'error',\n                    message: `Identity \"${k}\" is not supported or submited value is invalid`,\n                    value: identityObject.value,\n                });\n                return;\n            }\n            identityObject.value = valueValidated.value;\n            const valueObject = Object.assign({ state: IDENTITY_STATE.fresh, settled: true }, identityObject);\n            sanitedIdentities[k] = createIdentityObject(storage[k], valueObject.value, valueObject.state, true);\n        }\n    });\n    return sanitedIdentities;\n};\n","import { IDENTITIES_KEYS } from '../types';\nimport { DEFAULT_GET_RULES } from './consts';\n/**\n * Rules helpers\n */\nexport const rulesDefaults = (rules = {}) => (Object.assign(Object.assign({}, DEFAULT_GET_RULES), rules));\nexport const rulesDefaultsAll = (rules = {}, rulesGranular = {}) => {\n    const output = {};\n    for (const identificator in IDENTITIES_KEYS) {\n        output[identificator] = rulesDefaults(Object.assign(Object.assign({}, rules), (rulesGranular[identificator] || {})));\n    }\n    return output;\n};\n","import { IDENTITIES_KEYS, IDENTITY_STATE, } from '../types';\nimport { getCache } from './cache';\nimport { CACHE_MAX_AGE, EVENT_NAME, EVENT_NAME_BEFORE_UPDATE, TIMEOUT } from './consts';\nimport { decodeString, encodeString } from './encoding';\nimport { prematureSettling, pullExternalsAsync, pullExternalsSync } from './externals';\nimport { cacheAndNotify, getValueLevel, prepareIdentityStorageObject, sanitizeIdentities } from './general';\nimport { debug, dotLog } from './debug';\nimport { initCrossFramesCommunication } from './frames';\nimport { isEqual } from './utils';\nimport { identityOutput, isOK, validateIdentificator } from './identities';\nimport { rulesDefaults, rulesDefaultsAll } from './getrules';\nimport { isAvailable, getGlobalConfig } from './config';\nimport { getIS } from './namespace';\nimport { sendEvent } from './events';\n/**\n * Decode and parse storage.\n * It decoded global object or can be used for \"on demand\" decoding.\n */\nconst _decodeStorage = (toDecode = '') => {\n    var _a, _b;\n    const decoding = toDecode || ((_b = (_a = getIS()) === null || _a === void 0 ? void 0 : _a._storage) === null || _b === void 0 ? void 0 : _b.identities);\n    if (!decoding) {\n        return {};\n    }\n    const data = decodeString(decoding);\n    try {\n        return data ? JSON.parse(data) : {};\n    }\n    catch (err) {\n        debug({ type: 'warn', message: 'Storage could not be decoded, setting empty object', err });\n        return {};\n    }\n};\n/**\n * Encode and serialize storage.\n */\nconst _encodeStorage = (identities, dryRun = false) => {\n    const encoded = encodeString(JSON.stringify(identities));\n    if (dryRun) {\n        return encoded;\n    }\n    return (getIS()._storage.identities = encoded);\n};\n/**\n * Init global storage.\n * Prefill with cached data if exist and valid.\n */\nexport const initStorage = (force = false, mergeToInit = {}) => {\n    var _a, _b;\n    // already inited?\n    if (!force && ((_b = (_a = getIS()) === null || _a === void 0 ? void 0 : _a._storage) === null || _b === void 0 ? void 0 : _b.inited)) {\n        return;\n    }\n    debug('Storage initializing');\n    const cache = getCache();\n    let initObject = {};\n    let cacheDecoded = {};\n    // is cache usable?\n    try {\n        cacheDecoded = _decodeStorage(cache);\n        const cacheKeys = Object.keys(cacheDecoded);\n        // filter invalid keys from cache\n        const cacheValidKeys = cacheKeys.filter((k) => k in IDENTITIES_KEYS);\n        if (cacheValidKeys.length) {\n            initObject = cacheValidKeys.reduce((acc, key) => {\n                // check cache age + set state to \"cache\"\n                const cacheObject = cacheDecoded[key];\n                if (validateIdentificator(key) &&\n                    isAvailable(key) &&\n                    cacheObject.updated >= Date.now() - CACHE_MAX_AGE) {\n                    acc[key] = Object.assign(Object.assign({}, cacheObject), { state: IDENTITY_STATE.cache, settled: false });\n                }\n                return acc;\n            }, {});\n        }\n    }\n    catch (err) {\n        debug({ type: 'error', message: 'Storage cache could not be decoded / inited', err });\n    }\n    // INIT object priority > cache priority\n    initObject = Object.assign(Object.assign({}, initObject), mergeToInit);\n    const getter = () => getStorage(rulesDefaultsAll({ rich: true }));\n    // externals sync\n    pullExternalsSync(initObject);\n    debug({ message: 'Storage initialized', initObject });\n    prepareIdentityStorageObject({\n        _childFramesToFeed: [],\n        _storage: {\n            identities: Object.keys(initObject).length ? _encodeStorage(initObject, true) || null : null,\n            inited: true,\n        },\n    });\n    // externals async\n    pullExternalsAsync(initObject, updateStorage, getter);\n    // cache and let know rest of the world\n    cacheAndNotify(getIS()._storage.identities, initObject, Object.keys(initObject));\n    // init cross frames cooperation\n    initCrossFramesCommunication(updateStorage, getter);\n};\n/**\n * Get whole storage (decoded).\n */\nexport const getStorage = (rules) => {\n    try {\n        const storage = _decodeStorage();\n        const storageHandled = Object.keys(storage).reduce((acc, key) => {\n            const k = key;\n            const { rich, justSettled, cacheEnough } = rules[k];\n            const identity = storage[k];\n            if (validateIdentificator(k) && isAvailable(k) && isOK(identity, cacheEnough, justSettled)) {\n                acc[k] = identityOutput(identity, rich);\n            }\n            return acc;\n        }, {});\n        return storageHandled || {};\n    }\n    catch (err) {\n        debug({ type: 'warn', message: 'Can not read storage, returning {}', err });\n        return {};\n    }\n};\n/**\n * Get single item from storage.\n * Validates identificator.\n */\nexport const getStorageItem = (identificator, rules) => {\n    const mainIdentificatorPart = identificator.split('.')[0];\n    if (!isAvailable(mainIdentificatorPart)) {\n        return null;\n    }\n    const { rich, justSettled, cacheEnough } = rulesDefaults(rules);\n    if (!validateIdentificator(identificator)) {\n        debug({ type: 'warn', message: `Identity identificator (${identificator}) not valid, returning NULL` });\n        return null;\n    }\n    try {\n        const valueObject = _decodeStorage()[mainIdentificatorPart];\n        return valueObject && isOK(valueObject, cacheEnough, justSettled)\n            ? getValueLevel(identificator, identityOutput(valueObject, rich))\n            : null;\n    }\n    catch (err) {\n        debug({ type: 'warn', message: 'Identity could not be retrived, returning NULL', err });\n        return null;\n    }\n};\n/**\n * Get single item from storage as promise (get current value / listen to events / timeout)\n * Validates identificator.\n */\nexport const awaitStorageItem = (identificator, rules, doNotTimeout = false, satisfiedBy, logTimeouts) => {\n    if (!isAvailable(identificator)) {\n        return Promise.resolve(null);\n    }\n    // log timeouts to reporter\n    const log = (type) => logTimeouts && dotLog({ data: { action: 'IS-awaitStorageItem-timeout', identificator, type } });\n    const { rich, cacheEnough } = rulesDefaults(rules);\n    return new Promise((resolve) => {\n        var _a, _b;\n        const identity = getStorageItem(identificator, { rich: true, cacheEnough });\n        if (identity && isOK(identity, cacheEnough) && (!satisfiedBy || satisfiedBy(identity))) {\n            // we have fresh data already in storage\n            resolve(identityOutput(identity, rich));\n        }\n        else {\n            // timeouts for settled identity\n            let timeout = null;\n            let prematureTimeout = null;\n            const clearTimeouts = () => {\n                prematureTimeout && window.clearTimeout(prematureTimeout);\n                timeout && window.clearTimeout(timeout);\n            };\n            // total timeout\n            if (!doNotTimeout) {\n                timeout = window.setTimeout(() => {\n                    const identity = getStorageItem(identificator, { rich: true, cacheEnough });\n                    clearTimeouts();\n                    log('normal');\n                    resolve(identity ? identityOutput(identity, rich) : null);\n                }, ((_b = (_a = getGlobalConfig()) === null || _a === void 0 ? void 0 : _a.timeouts) === null || _b === void 0 ? void 0 : _b[identificator]) || TIMEOUT);\n            }\n            // small timeout - things do not look like waiting for full settled identity is worth the time\n            if (!doNotTimeout && prematureSettling[identificator]) {\n                prematureTimeout = prematureSettling[identificator]((prematureIdentity) => {\n                    clearTimeouts();\n                    log('premature');\n                    resolve(prematureIdentity);\n                });\n            }\n            // we are waiting for events (till timeout)\n            const handler = (event) => {\n                var _a, _b, _c;\n                const data = event.detail;\n                if (~((_a = data === null || data === void 0 ? void 0 : data.changes) === null || _a === void 0 ? void 0 : _a.indexOf(identificator)) &&\n                    isOK((_b = data === null || data === void 0 ? void 0 : data.identities) === null || _b === void 0 ? void 0 : _b[identificator], cacheEnough) &&\n                    (!satisfiedBy || satisfiedBy((_c = data === null || data === void 0 ? void 0 : data.identities) === null || _c === void 0 ? void 0 : _c[identificator]))) {\n                    window.removeEventListener(EVENT_NAME, handler);\n                    clearTimeouts();\n                    resolve(identityOutput(event.detail.identities[identificator], rich));\n                }\n            };\n            window.addEventListener(EVENT_NAME, handler);\n        }\n    });\n};\n/**\n * Purge storage object. Optionally specify just some identitites for purging.\n */\nexport const clearStorage = (identities = Object.values(IDENTITIES_KEYS)) => {\n    const storage = _decodeStorage();\n    if (Object.keys(storage).length) {\n        const newStorage = identities.reduce((acc, IDENTITY_KEY) => {\n            if (acc.storage[IDENTITY_KEY] !== undefined) {\n                delete acc.storage[IDENTITY_KEY];\n                acc.changes.push(IDENTITY_KEY);\n            }\n            return acc;\n        }, { storage: Object.assign({}, storage), changes: [] });\n        if (!newStorage.changes.length) {\n            return;\n        }\n        cacheAndNotify(_encodeStorage(newStorage.storage), newStorage.storage, newStorage.changes);\n    }\n};\n/**\n * Update (merge) current storage with submited data.\n * Validates submited object and ads metadata (timestamps, ...).\n */\nexport const updateStorage = (identities) => {\n    debug({ message: 'Updating storage', identities });\n    if (!identities) {\n        debug({ type: 'error', message: 'Invalid identities object', identities });\n        return;\n    }\n    const storage = _decodeStorage();\n    const sanitizedIdentities = sanitizeIdentities(storage, identities);\n    const newKeys = Object.keys(sanitizedIdentities);\n    if (newKeys.length) {\n        // find changed keys (old vs new storage state)\n        const notEqualKeys = newKeys.filter((sKey) => {\n            const newIdentity = (sanitizedIdentities[sKey] || {});\n            const currentIdentity = (storage[sKey] || {});\n            // do not fire unnecessary events when clearing non existing identity\n            if (currentIdentity.value === undefined && newIdentity.value === null) {\n                return false;\n            }\n            return (!isEqual(newIdentity.value, currentIdentity.value) ||\n                newIdentity.state !== currentIdentity.state ||\n                newIdentity.settled !== currentIdentity.settled);\n        });\n        // update and notify only if old != new (at least one key changed)\n        if (notEqualKeys.length) {\n            const newStorage = Object.assign(Object.assign({}, (storage || {})), sanitizedIdentities);\n            // delete identitites with NULL value (for example LOGIN change can trigger CONSENT removal)\n            const newStorageCleaned = Object.keys(newStorage).reduce((acc, key) => {\n                if (newStorage[key].value !== null) {\n                    acc[key] = newStorage[key];\n                }\n                else {\n                    debug({ message: 'Removing identity with NULL value', key });\n                }\n                return acc;\n            }, {});\n            debug({ message: 'Updating storage - after cleanup', newStorageCleaned });\n            sendEvent(EVENT_NAME_BEFORE_UPDATE, {\n                oldIdentities: storage,\n                newIdentities: newStorageCleaned,\n                changes: notEqualKeys,\n            });\n            cacheAndNotify(_encodeStorage(newStorageCleaned), newStorageCleaned, notEqualKeys);\n        }\n    }\n    else {\n        debug({ message: `No identities to update after sanitizing / validation`, identities });\n    }\n};\n","import { IDENTITIES_KEYS_SPECIAL } from '../types';\nimport { isObject } from './utils';\nimport { getStorageItem } from './storage';\nimport { validateValueType } from './identities';\nimport { getExtendedLoginFromWindowObject } from './externals/login';\nimport { debug } from './debug';\n/**\n * Special \"identities\" / \"identities parts\" (rusId, premium, said, ...) can be stored via public api\n * We need to wrap them in to main identity (login) before storing\n */\nexport const createValueForSpecial = (identificator, value, specials) => {\n    // validate\n    const valueValidated = validateValueType(identificator, value);\n    if (!valueValidated.ok) {\n        debug({\n            type: 'error',\n            message: `Submited value for identity (${identificator}) is invalid`,\n            value,\n        });\n        return null;\n    }\n    const _canStoreSpecial = (identificator) => {\n        var _a;\n        if (getExtendedLoginFromWindowObject()) {\n            return false;\n        }\n        else if (identificator === IDENTITIES_KEYS_SPECIAL.login && specials.login) {\n            // TODO - is existing only in cache -> allow and start with empty login object\n            return false;\n        }\n        else if (((_a = specials.login) === null || _a === void 0 ? void 0 : _a[identificator]) !== undefined) {\n            // TODO - is existing only in cache -> allow and start with empty login object\n            return false;\n        }\n        return true;\n    };\n    // login -> rusId, premium, said, state, pid, ...\n    if (identificator in IDENTITIES_KEYS_SPECIAL) {\n        // \"specials\" key not existing -> get current storage values\n        if (!isObject(specials.login)) {\n            specials.login = (getStorageItem('login', {\n                rich: false,\n                cacheEnough: true,\n                justSettled: false,\n            }) || {});\n        }\n        // setting {rusId: \"value\"} -> sets {uid: \"value\"}\n        if (identificator === IDENTITIES_KEYS_SPECIAL.rusId && _canStoreSpecial(identificator) && valueValidated.value) {\n            specials.login.uid = valueValidated.value;\n            return 'login';\n        }\n        // setting {said: \"value\"} -> sets {advert_uid: \"value\", said: \"value\"}\n        if (identificator === IDENTITIES_KEYS_SPECIAL.said && _canStoreSpecial(identificator)) {\n            specials.login.advert_uid = valueValidated.value;\n            specials.login.said = valueValidated.value;\n            return 'login';\n        }\n        if (identificator === IDENTITIES_KEYS_SPECIAL.premium && _canStoreSpecial(identificator)) {\n            specials.login.premium = valueValidated.value;\n            return 'login';\n        }\n        if (identificator === IDENTITIES_KEYS_SPECIAL.sbr && _canStoreSpecial(identificator)) {\n            specials.login.sbr = valueValidated.value;\n            return 'login';\n        }\n        if (identificator === IDENTITIES_KEYS_SPECIAL.state && _canStoreSpecial(identificator)) {\n            specials.login.state = valueValidated.value;\n            return 'login';\n        }\n        if (identificator === IDENTITIES_KEYS_SPECIAL.login) {\n            specials.login = valueValidated.value;\n            // setting {login: {rusId: \"0\"}}\n            if (specials.login.rusId !== undefined && specials.login.rusId < 1) {\n                delete specials.login.rusId;\n            }\n            // setting {login: {uid: \"0\"}}\n            if (specials.login.uid !== undefined && specials.login.uid < 1) {\n                delete specials.login.uid;\n            }\n            // setting {login: {rusId: \"value\"}} -> sets {login: {uid: \"value\"}}\n            if (specials.login.rusId && !specials.login.uid) {\n                specials.login.uid = specials.login.rusId;\n                delete specials.login.rusId;\n            }\n            // setting {login: {said: \"value\"}} -> sets {login: {said: \"value\", advert_uid: \"value\"}}\n            if (specials.login.said && !specials.login.advert_uid) {\n                specials.login.advert_uid = specials.login.said;\n            }\n            // nothing to update in login object\n            if (Object.keys(specials.login).length === 0) {\n                return null;\n            }\n            return 'login';\n        }\n    }\n    return null;\n};\n","import { IDENTITIES_KEYS, VALUES_TYPES, ADDRESS as AID, PHONE as TID, } from '../types';\nimport { isObject, isValidSHA256String, isValidUUID } from './utils';\n/**\n * Validation map. Specifify validation callback or array of supported keys inside identity\n */\nexport const whiteList = {\n    [IDENTITIES_KEYS.sid]: (value) => typeof value === VALUES_TYPES.string,\n    [IDENTITIES_KEYS.udid]: (value) => typeof value === VALUES_TYPES.string,\n    [IDENTITIES_KEYS.login]: ['state', 'uid', 'premium', 'sbr', 'advert_uid', 'pid', 'said', 'others', 'consentString'],\n    [IDENTITIES_KEYS.eid]: (value) => isValidSHA256String(value),\n    [IDENTITIES_KEYS.tid]: [TID.areaCode, TID.number],\n    [IDENTITIES_KEYS.aid]: [AID.state, AID.city, AID.street, AID.houseNumber, AID.postalCode],\n    [IDENTITIES_KEYS.consent]: ['consentString', 'name', 'version', 'purposeOne'],\n    [IDENTITIES_KEYS.id5]: (value) => typeof value === VALUES_TYPES.string,\n    [IDENTITIES_KEYS.secid]: (value) => isValidUUID(value),\n};\n/**\n * Validate / include just allowed keys in identity object\n */\nconst _validateIdentityKeys = (identityValue, whiteListItem) => {\n    return whiteListItem.reduce((accSingleIdentity, item) => {\n        const identityValueKey = identityValue[item];\n        if (identityValueKey !== undefined) {\n            accSingleIdentity[item] = identityValueKey;\n        }\n        return accSingleIdentity;\n    }, {});\n};\n/**\n * Trim not whitelisted identities values\n */\nexport const includeOnlyWhitelisted = (identities) => {\n    return Object.keys(identities).reduce((accIdentities, key) => {\n        const identityKey = key;\n        const identityValue = identities[identityKey];\n        const whiteListItem = whiteList[identityKey];\n        if (whiteListItem !== undefined) {\n            if (Array.isArray(whiteListItem) && isObject(identityValue)) {\n                // validateby whitelist 1. level keys\n                accIdentities[identityKey] = _validateIdentityKeys(identityValue, whiteListItem);\n            }\n            else if (typeof whiteListItem === 'function' && whiteListItem(identityValue)) {\n                // validate by whitelist function\n                accIdentities[identityKey] = identityValue;\n            }\n        }\n        return accIdentities;\n    }, {});\n};\n","import { COOKIE } from '@iva/utils';\nconst _terminator = (type, keys) => {\n    keys.forEach((key) => {\n        try {\n            if (type === 'LS') {\n                localStorage.removeItem(key);\n            }\n            else if (type === 'COOKIE') {\n                COOKIE.removeCookie(key);\n            }\n        }\n        catch (_a) {\n            // noop\n        }\n    });\n};\n/**\n * Clean up stale data (some caching metadata used by already disabled identitites, etc.)\n */\nexport const browserCleanUp = () => {\n    _terminator('LS', [\n        // LOTAME\n        'panoramaId',\n        'panoramaIdType_exp',\n        'panoramaId_exp',\n        'panoramaId_expiry_exp',\n        'panoramaId_expiry',\n        'panoramaIdType',\n    ]);\n    _terminator('COOKIE', [\n        // LOTAME\n        'panoramaId',\n        'panoramaIdType',\n        'panoramaId_expiry',\n    ]);\n};\n","import { IDENTITIES_KEYS, } from './types';\nimport { awaitStorageItem, clearStorage, getStorage, getStorageItem, initStorage, updateStorage, } from './modules/storage';\nimport { subscribe } from './modules/subscribing';\nimport { createValuesObjects, prepareIdentityStorageObject, sanitizeIdentities } from './modules/general';\nimport { DEFAULT_GET_RULES, EVENT_NAME_READY } from './modules/consts';\nimport { getNullableObject, isIdentitiesSimplifiedObject } from './modules/utils';\nimport { rulesDefaultsAll } from './modules/getrules';\nimport { createValueForSpecial } from './modules/specials';\nimport { getVersion } from './modules/versioning';\nimport { includeOnlyWhitelisted } from './modules/whitelisting';\nimport { sendEvent } from './modules/events';\nimport { pullInitialIdentities } from './modules/config';\nimport { browserCleanUp } from './modules/cleanup';\nimport { getInvalidUpdatesForBe, getInvalidUpdates } from './modules/invalidUpdates';\n// Ensures that `window.sznIVA.IS` is present right after the script is loaded\nprepareIdentityStorageObject();\n/**\n * Init global object. Clean up any stale browsers's data (cookies, LS, SS, ...)\n */\nconst _prepareInit = () => {\n    browserCleanUp();\n    return sanitizeIdentities({}, createValuesObjects(pullInitialIdentities(), createValueForSpecial));\n};\ninitStorage(false, _prepareInit());\n// export init (usable for testing purposes)\nexport const _init = (force = false, mergeInit = false) => initStorage(force, mergeInit ? _prepareInit() : {});\n/**\n * Get specific identity\n * @param identificator - Identity we want to retrieve (can be scoped -> \"consent.name\")\n * @param rules - Rules (rules for identity to be retrieved)\n * - rules.rich - If TRUE, whole identity object is retrieved (otherwise just value)\n * - rules.justSettled - If TRUE, identity need to be \"settled\"\n * - rules.cacheEnough - If TRUE, \"cache\" value is considered to be enough\n */\nexport const getIdentity = (identificator, rules = { rich: false, justSettled: true }) => { var _a; return (_a = getStorageItem(identificator, rules)) !== null && _a !== void 0 ? _a : null; };\n/**\n * Get specific identity as promise\n * @param identificator - Identity we want to retrieve\n * @param rules - Rules (rules for identity to be retrieved)\n * - rules.rich - If TRUE, whole identity object is retrieved (otherwise just value)\n * - rules.cacheEnough - If TRUE, \"cache\" value is considered to be enough\n */\nexport const getIdentitySettled = (identificator, rules = { rich: false }, doNotTimeout = false) => awaitStorageItem(identificator, rules, doNotTimeout);\n/**\n * Get all identities - with global + granular \"get\" rules\n * @param rules - global rules for all identities\n * - rich - if TRUE, whole identity objects are retrieved (otherwise just values)\n * - justSettled - if TRUE, identities need to be \"settled\"\n * - cacheEnough - if TRUE, \"cache\" values are considered to be enough\n * @param rulesGranular - separated rules for each identity (higher priority)\n * @param nullable - in case of empty object -> return null\n */\nexport const getIdentities = (rules = DEFAULT_GET_RULES, rulesGranular = {}, nullable = false) => {\n    const rls = rulesDefaultsAll(rules || DEFAULT_GET_RULES, rulesGranular || {});\n    return getNullableObject(getStorage(rls), nullable);\n};\n/**\n * Update identities (\"updated\" and \"state\" flags are updated for each submited identity)\n * - Native identities (cookies, global variables, ...) are intact\n * @param identities - Identities object, which will be merged with current identity storage (if values differs)\n */\nexport const updateIdentities = (identities) => updateStorage(createValuesObjects(identities, createValueForSpecial));\n/**\n * Purge identities from storage (mainly for test reasons)\n */\nexport const clearIdentities = (identities = Object.values(IDENTITIES_KEYS)) => clearStorage(identities);\n/**\n * Subscribe to identities changes\n * @param callback - Function to be called with data:\n * - data.identities: {...current storage state...}\n * - data.changes: [...array of keys of changed identitites]\n * @returns Function for unsubscribing\n */\nexport const subscribeIdentities = (callback, rich = false) => subscribe(callback, rich);\n/**\n * Prepare data for backend (ids).\n * Include only whitelisted keys (if any) , _version and _metadata (if includeMetadata = true)\n */\nexport const prepareIdsForBe = (identities, config) => {\n    const { includeMetadata = false } = config || {};\n    const isIdentityObjectFull = isIdentitiesSimplifiedObject(identities) && Object.keys(identities).length;\n    const _invalids = getInvalidUpdatesForBe();\n    // do we have any data to be structured / versioned?\n    if (isIdentityObjectFull || (includeMetadata && _invalids)) {\n        return Object.assign(Object.assign(Object.assign({}, (isIdentityObjectFull ? includeOnlyWhitelisted(identities) : {})), (includeMetadata && _invalids ? { _metadata: { _invalids } } : {})), { _version: getVersion() });\n    }\n    return null;\n};\n/**\n * Get \"viable\" login identity (\"state\", \"rusId / said\", \"premium\" has to be set)\n */\nexport const getViableLoginIdentity = (rules = { rich: false }, doNotTimeout = false) => {\n    return awaitStorageItem(IDENTITIES_KEYS.login, rules, doNotTimeout, (identity) => {\n        const login = ((identity === null || identity === void 0 ? void 0 : identity.value) || {});\n        return (!!login.state &&\n            !!(login.advert_uid || login.said || login.uid) &&\n            (typeof login.premium === 'boolean' || typeof login.sbr === 'boolean'));\n    }, true);\n};\nexport const getInvalidUpdatesLog = () => getInvalidUpdates();\n/**\n * Expose to global object\n */\nconst OUTPUT = {\n    _init,\n    getIdentity,\n    getIdentitySettled,\n    getIdentities,\n    updateIdentities,\n    clearIdentities,\n    subscribeIdentities,\n    prepareIdsForBe,\n    getViableLoginIdentity,\n    getInvalidUpdatesLog,\n};\nconst _metadata = {\n    // replaced by webpack (using current or semanticRelease \"future\")\n    v: '2.35.0',\n};\nprepareIdentityStorageObject(Object.assign(Object.assign({}, OUTPUT), { _metadata }));\n//Let outside world know that IS is ready\nsendEvent(EVENT_NAME_READY);\nexport default OUTPUT;\n","export const getVersion = () => {\n    return '1.1';\n};\n","/* eslint-disable camelcase */\n// Types\nimport { DOT } from '../../classes/dot.class';\nimport { NullableString } from 'types/common';\nimport { Hit, CommonData, IdsData } from '../../types/hit';\nimport { Config } from '../../types/config';\nimport { getCookie } from '../utils/cookie/cookie';\n// Methods\nimport { getDocumentUrl } from '../utils/general/url';\n// Constants\nimport { CW_UTIL_COOKIE_NAME } from '../../constants/index';\n\n// IVA Packages\nimport IS from '@iva/identity-storage';\n\n/**\n * Gets identity object including login, sid, udid and euconsent\n */\nexport const getIdentityObject = (): IdsData | null => {\n  const ids = IS.getIdentities({ cacheEnough: true, justSettled: false }, null, true);\n  return IS.prepareIdsForBe(ids, { includeMetadata: true });\n};\n\n/**\n * Serialize hit with JSON.stringify\n *\n * @param hit hit data defined by user\n */\nexport const serializeHit = (hit: Hit): NullableString => {\n  if (!hit || Object.keys(hit).length === 0) {\n    return null;\n  }\n\n  try {\n    return JSON.stringify(hit);\n  } catch {\n    return null;\n  }\n};\n\n/**\n * Adds u_agrm into hit scroll, spenttime, dop-.+. True if flag added\n *\n * @param config DOT configuration\n * @param hit all hit data\n */\nexport const addUserAgreement = (config: Config, hit: Hit): boolean => {\n  const regex = /^dop-.|^spenttime$|^scroll$/;\n\n  if (config.u_agrm !== null && hit.data && typeof hit.data.action === 'string' && regex.test(hit.data.action)) {\n    hit.data.u_agrm = config.u_agrm;\n    return true;\n  }\n\n  return false;\n};\n\n/**\n * Gets Cookie Wall session (request id) from cookie\n */\nexport const getCWSession = (): string => {\n  try {\n    const decoded = window.atob(getCookie(CW_UTIL_COOKIE_NAME) || '');\n\n    if (!decoded) {\n      // cw_util cookie does not exist or is empty\n      return '';\n    }\n\n    const parsed = JSON.parse(decoded);\n    return parsed.ri?.toString() || 'invalid-json';\n  } catch {\n    return 'invalid-b64';\n  }\n};\n\n/**\n * Gets common hit data from DOT configuration and website\n *\n * @param dot DOT instance\n */\nexport const getCommon = (dot: DOT): CommonData => {\n  const data: CommonData = {\n    service: dot._cfg.service,\n    lsid: dot._cfg.lsid,\n    id: dot._cfg.id,\n    version: dot._cfg.version,\n    pvid: dot._cfg.pageViewId,\n    spa: dot._cfg.spa,\n    url: getDocumentUrl(),\n    lses: dot.lastSession,\n    cwses: getCWSession(),\n    cdl: dot.cookieDeprecationLabel,\n    ab: dot._cfg.abtest,\n    serviceVariant: dot._cfg.serviceVariant,\n    premium: dot._cfg.premium === null ? '' : dot._cfg.premium,\n    ptitle: document.title,\n    ids: getIdentityObject() || ({} as IdsData),\n  };\n\n  return data;\n};\n\n// API\nexport default {\n  addUserAgreement,\n  getCommon,\n  serializeHit,\n  getIdentityObject,\n};\n","// Types\nimport { DOT } from '../../classes/dot.class';\nimport { KeyValuePairs } from '../../types/common';\nimport { Hit, IdsData, SavedHit } from '../../types/hit';\n// Methods\nimport { getIdentityObject } from '../hit/composeData';\n// Constants\nimport { LAZY_HITTING_ENABLED, LAZY_HITTING_DISABLED } from '../../constants/index';\n\n/* Set of allowed attributes */\nconst commonCfgList: KeyValuePairs<string> = {\n  premium: 'premium',\n  ids: 'ids',\n};\n\n/**\n * Adds values from additionalCfg to hit. Value is added only when is declared in commonCfgList\n *\n * @param hit saved Hit object\n * @param additionalCfg additional information\n */\nexport const _addAdditionalCfg = (hit: Hit, additionalCfg: KeyValuePairs<unknown>): void => {\n  for (const p in additionalCfg) {\n    if (commonCfgList[p] !== undefined) {\n      hit[commonCfgList[p]] = additionalCfg[p];\n    }\n  }\n\n  // update all identities automatically\n  hit.ids = getIdentityObject() || ({} as IdsData);\n};\n\n/**\n * Clears lazyHitting queue\n *\n * @param queue array that will be cleared\n */\nexport const _clearHitQueue = (queue: SavedHit[]): void => {\n  queue.length = 0;\n};\n\n/**\n * Check if lazyHitting is enabled\n *\n * @param status current lazyHitting status\n */\nexport const shouldLazyHit = (status: number): boolean => {\n  return status === LAZY_HITTING_ENABLED;\n};\n\n/**\n * Adds hit to lazyHitting queue\n *\n * @param queue array where hit will be saved\n * @param hitToSave hit which will be saved and send later\n */\nexport const addToHitQueue = (queue: SavedHit[], hitToSave: SavedHit): void => {\n  queue.push(hitToSave);\n};\n\n/**\n * Sends saved hits one by one with additional information\n *\n * @param dot DOT instance\n * @param additionalCfg additional information\n */\nexport const sendSavedHits = (dot: DOT, additionalCfg?: KeyValuePairs<unknown>): void => {\n  dot.hitQueue.forEach((item) => {\n    _addAdditionalCfg(item.hit, additionalCfg || {});\n    dot.hit(item.hit.action, item.hit, item.callback, item.useFetch);\n  });\n  _clearHitQueue(dot.hitQueue);\n};\n\n/**\n * Initialize lazy hitting for DOT instance\n * @param dot DOT instance\n */\nexport const initLazyHitting = (dot: DOT): void => {\n  dot.lazyHittingStatus = LAZY_HITTING_ENABLED;\n\n  // tries to send saved hits before user leaves page\n  const callback = (): void => {\n    sendSavedHits(dot);\n  };\n\n  dot.sentBeforeUnload = callback;\n\n  window.addEventListener('beforeunload', dot.sentBeforeUnload, false);\n};\n\n/**\n * Turn off lazy hitting for DOT instance and sends all saved hits with additional info\n * @param dot DOT instance\n * @param additionalConfig additional config which will be added to all saved hits\n */\nexport const finishLazyHitting = (dot: DOT, additionalConfig: KeyValuePairs<unknown>): void => {\n  dot.lazyHittingStatus = LAZY_HITTING_DISABLED;\n\n  window.removeEventListener('beforeunload', dot.sentBeforeUnload, false);\n  dot.sentBeforeUnload = null;\n\n  sendSavedHits(dot, additionalConfig);\n};\n\n// API\nexport default {\n  shouldLazyHit,\n  addToHitQueue,\n  sendSavedHits,\n  initLazyHitting,\n  finishLazyHitting,\n};\n","// Types\nimport { DOT } from 'classes/dot.class';\nimport { SavedHit } from 'types/hit';\n\n/**\n * Clears hit queue\n *\n * @param dot DOT instance\n */\nexport const _clearPostponedHits = (dot: DOT): void => {\n  dot.postponedQueue.length = 0;\n};\n\n/**\n * Check if hits should be postponed\n *\n * @param cookieRequestDone instance sid request status\n * @param udidRequestDone instance udid request status\n */\nexport const shouldPostponeHits = (dot: DOT): boolean => !dot.cookieRequestDone || !dot.udidRequestDone;\n\n/**\n * Adds hit to postponed hits queue\n *\n * @param dot DOT instance\n * @param hit hit which will be postponed\n */\nexport const addToPostponedQueue = (dot: DOT, hit: SavedHit): void => {\n  dot.postponedQueue.push(hit);\n};\n\n/**\n * Sends saved hits one by one with additional information\n *\n * @param dot DOT instance\n */\nexport const sendPostponedHits = (dot: DOT): void => {\n  if (shouldPostponeHits(dot)) {\n    dot.log('sendPostponedHits but sid or udid request not ready');\n    return;\n  }\n\n  dot.postponedQueue.forEach((item) => {\n    dot.hit(item.hit.action, item.hit, item.callback, item.useFetch);\n  });\n  _clearPostponedHits(dot);\n  dot.log('postponed hits queue sent');\n};\n\n// API\nexport default {\n  shouldPostponeHits,\n  addToPostponedQueue,\n  sendPostponedHits,\n};\n","import { KeyValuePairs } from '../../../types/common';\n\n/**\n * Traverse DOM and extract data-dot-data to object\n * @param elm Start of traversing (until document root reached)\n */\nexport const getDataDotData = (elm: HTMLElement): KeyValuePairs<unknown> => {\n  const dataD: KeyValuePairs<unknown> = {};\n  let node = elm;\n  while (node && node !== document.documentElement && node.dataset) {\n    const valueDotData = node.dataset.dotData;\n\n    if (!valueDotData) {\n      node = node.parentNode as HTMLElement;\n      continue;\n    }\n\n    try {\n      const dataDot = JSON.parse(valueDotData);\n      for (const key in dataDot) {\n        if (!(key in dataD)) {\n          dataD[key] = dataDot[key];\n        }\n      }\n    } catch {\n      // no-op\n    }\n\n    node = node.parentNode as HTMLElement;\n  }\n\n  return dataD;\n};\n\n/**\n * Get serialized list of data-dot values\n * @param elm Start of traversing (until document root reached)\n */\nexport const getDataDot = (elm: HTMLElement): string => {\n  const arr = [];\n  let node = elm;\n  while (node && node !== document.documentElement && node.dataset) {\n    const value = node.dataset.dot;\n    if (value) {\n      arr.unshift(value);\n    }\n    node = node.parentNode as HTMLElement;\n  }\n  return arr.join('/');\n};\n\n/**\n * Get serialized list of data-dot values - based on MouseEvent\n * @param evt Object's dispatched event where traversing starts (until document root reached)\n */\nexport const getDataDotFromEventTarget = (evt: MouseEvent): string => {\n  const arr = [];\n  const traversedPath = evt.composedPath() as HTMLElement[];\n  traversedPath.forEach((elem) => {\n    if (elem !== document.documentElement && elem.dataset?.dot) {\n      arr.unshift(elem.dataset.dot);\n    }\n  });\n  return arr.join('/');\n};\n\n/**\n * Get serialized list of css classes\n * @param elm Start of traversing (until document root reached)\n */\nexport const getCSSPath = (elm: HTMLElement): string => {\n  const arr = [];\n  let node = elm;\n  while (node && node !== document.documentElement && node.dataset) {\n    const value = node.getAttribute('class');\n    if (value) {\n      const valuesArray = value.split(' ');\n      if (valuesArray.length === 1) {\n        arr.unshift(value);\n      } else {\n        arr.unshift(valuesArray.sort().join('.'));\n      }\n    }\n    node = node.parentNode as HTMLElement;\n  }\n  return arr.join('/');\n};\n\n/**\n * Get closest data-fieldvalue (converted to bool)\n * @param elm Start of traversing (until data found or document root reached)\n */\nexport const getDataFieldValue = (elm: HTMLElement): boolean => {\n  let node = elm;\n  while (node && node !== document.documentElement) {\n    const value = node.getAttribute('data-fieldvalue');\n    if (value !== null) {\n      return value === '1';\n    }\n    node = node.parentNode as HTMLElement;\n  }\n  return true;\n};\n\n// API\nexport default { getDataDotData, getDataDot, getCSSPath, getDataFieldValue };\n","// Classes\nimport { DOT } from '../../../classes/dot.class';\n// Types\nimport { Config } from 'types/config';\nimport { GetInfoRequestEvent, GetInfoResponseEvent } from '../../../types/iframe';\n// Constants\nimport { CFG_FROM_TOP_FRAME_TIMEOUT, DOT_TIMEOUT_IN_IFRAME_BRIDGE, EVENTS } from '../../../constants';\n\n// are we in the top level?\nexport const isTopLevel = (win: Window = window): boolean => {\n  try {\n    return (win.top === win.self || !!win.Cypress) && !win.frameElement;\n  } catch {\n    return win.top === win.self;\n  }\n};\n\n// get top level window reference\nexport const getTopWindow = (win: Window = window): Window => (isTopLevel(win) ? win : getTopWindow(win.parent));\n\nexport const handlerFromChildMessage = (event: MessageEvent<GetInfoRequestEvent>, dot: DOT) => {\n  if (event.source && event.data.type === EVENTS.GET_INFO_EVENT) {\n    event.source.postMessage(\n      <GetInfoResponseEvent>{\n        type: EVENTS.GET_INFO_EVENT,\n        site: window.document.location.href,\n        config: dot._cfg,\n      },\n      <WindowPostMessageOptions>'*'\n    );\n  }\n};\n\nconst handlerFromTopMessage = (dot: DOT) => {\n  let timeout: number | null = null;\n  let interval: number | null = null;\n  // cypress hack (cypress tests are running inside iframe -> window.top is not, what expected)\n  let destination: 'top' | 'parent' = 'top';\n  try {\n    destination = (window as any).Cypress || (window as any).parent.Cypress ? 'parent' : 'top';\n  } catch {\n    // no-op\n  }\n\n  const fromTopHandler = (event: MessageEvent) => {\n    if (event.data.type === EVENTS.GET_INFO_EVENT && (event.data.site || event.data.config)) {\n      const info = dot.getInfo();\n\n      info.site = event.data.site;\n      info.topConfig = event.data.config;\n\n      dot.log(`iframeBridge iframe received message with site: ${info.site} and a config: ${info.topConfig}`);\n      window.clearTimeout(timeout);\n      window.clearInterval(interval);\n      window.removeEventListener('message', fromTopHandler);\n      window.dispatchEvent(new Event(EVENTS.GET_INFO_COMPLETE));\n    }\n  };\n\n  window.addEventListener('message', fromTopHandler);\n\n  const pingTop = () =>\n    window[destination].postMessage(<GetInfoRequestEvent>{ type: EVENTS.GET_INFO_EVENT }, document.referrer || '*');\n\n  pingTop();\n\n  interval = window.setInterval(pingTop, 250);\n\n  timeout = window.setTimeout(() => {\n    dot.log('iframeBridge: timeouted getInfo request from ' + window.location.href);\n    window.clearInterval(interval);\n  }, DOT_TIMEOUT_IN_IFRAME_BRIDGE);\n};\n\nexport const initIframeBridge = (dot: DOT) => {\n  if (isTopLevel()) {\n    if (window.DOT !== dot) {\n      // this should prevent registering multiple listeners, only top DOT instance should listen\n      return;\n    }\n    // register child DOT subscriber / listener\n    window.addEventListener('message', (event: MessageEvent<GetInfoRequestEvent>) =>\n      handlerFromChildMessage(event, dot)\n    );\n  } else {\n    // register top DOT subscriber / listener and try several times to get top DOT\n    handlerFromTopMessage(dot);\n    dot.log('iframeBridge: getInfo requested from ' + window.location.href);\n  }\n};\n\n/**\n * Configure iframe DOT instance with the top window DOT configuration\n * @param dot Instance of iframe DOT\n * @returns Promise of Config object\n */\nexport const configureFromTopFrame = (dot: DOT): Promise<Config | null> => {\n  dot.cfg({}); // because of adding PM Listeners for iframeBridge (need right config flow)\n\n  return new Promise((resolve, reject) => {\n    const cancel = window.setTimeout(() => {\n      dot.log('iframeBridge timeouted', 'error');\n      reject();\n    }, CFG_FROM_TOP_FRAME_TIMEOUT);\n\n    window.addEventListener(EVENTS.GET_INFO_COMPLETE, () => {\n      window.clearTimeout(cancel);\n      const { topConfig } = dot.getInfo();\n      if (!topConfig) {\n        dot.log('iframeBridge failed to get top window DOT config', 'error');\n        reject();\n      }\n\n      dot.cfg(topConfig);\n      dot.log('iframe DOT configured from top DOT');\n      resolve(topConfig);\n    });\n  });\n};\n","// Types\nimport { DOT } from '../../classes/dot.class';\nimport { KeyValuePairs } from '../../types/common';\nimport { Data, ImpressUtmData } from '../../types/hit';\n// Methods\nimport { getDataDot, getDataDotData } from '../utils/html/traversing';\nimport { setWindowNameWithId } from '../init';\nimport { getGeometry } from '../geometry/geometry';\nimport { getParameterFromURLQuery, getParameterFromURLHash } from '../utils/general/url';\n// Constants\nimport { EVENTS, SSP_ALLOWED_SOURCES } from '../../constants/index';\n\n/**\n * Sets referrer for SPA website\n * @param dot DOT instance\n */\nexport const _getSPAReferrer = (dot: DOT): string => {\n  const referrer = dot.SPAReferrer || document.referrer;\n  dot.SPAReferrer = window.location.href;\n  return referrer;\n};\n\n/**\n * Gets sspUtmSource from URL query or hash\n */\nexport const _getSspUtmSource = (): ImpressUtmData => {\n  const paramName = 'utm_medium';\n  const value = getParameterFromURLQuery(paramName) || getParameterFromURLHash(paramName);\n\n  return value && SSP_ALLOWED_SOURCES[value] ? { sspUtmSource: SSP_ALLOWED_SOURCES[value] } : {};\n};\n\n/**\n * Adds impressData to data object (d: {...}).\n * @param {Object} dataObject\n * @param {Object} impressData\n */\nexport const _addImpressData = (dataObject: Data, impressData: KeyValuePairs<unknown>): Data => {\n  if (!dataObject.d) {\n    dataObject.d = {};\n  }\n\n  for (const key in impressData) {\n    dataObject.d[key] = impressData[key];\n  }\n\n  return dataObject;\n};\n\n/**\n * Sets current status for impressBeforeAdloadSent\n * @param dot DOT instance\n * @param status status to be set\n */\nexport const setImpressBeforeAdload = (dot: DOT, status: boolean): void => {\n  if (window.DOT) {\n    window.DOT.impressBeforeAdloadSent = status;\n  }\n  dot.impressBeforeAdloadSent = status;\n};\n\n/**\n * Sends impress hit\n *\n * @param dot DOT instance\n * @param callback called when hit is sent\n * @param impressData additional data which will be added to hit data (d: {...})\n */\nexport const sendImpress = (dot: DOT, callback: () => void = null, impressData?: KeyValuePairs<unknown>): void => {\n  const data: Data = {\n    q: dot._cfg.query,\n    d: {\n      tid: window.name,\n      referer: dot._cfg.spa ? _getSPAReferrer(dot) : document.referrer,\n      path: getDataDot(document.body),\n    },\n  };\n\n  if (dot._cfg.spa) {\n    setWindowNameWithId(dot);\n  }\n\n  if (impressData) {\n    _addImpressData(data, impressData);\n  } else {\n    data.d = { ...data.d, ...getDataDotData(document.body) };\n  }\n\n  data.d = { ...data.d, ..._getSspUtmSource(), ...getGeometry(dot.dataElms) };\n  dot.hit('impress', data, callback);\n\n  // dispatch event for the first impress on page\n  if (!window.DOT?.firstImpressSent) {\n    window.dispatchEvent(new CustomEvent(EVENTS.FIRST_IMPRESS_SENT));\n  }\n\n  dot.firstImpressSent = true;\n  setImpressBeforeAdload(dot, true);\n};\n\n/**\n * If cookieRequest done, sends impress hit, otherwise adds load event to cookieRequest\n * @param dot DOT instance\n * @param callback called when impress is sent\n */\nexport const handleImpress = (dot: DOT, callback?: () => void): void => {\n  if (dot.cookieRequestDone) {\n    dot.impress(callback, null);\n    return;\n  }\n\n  const impressHandler = () => {\n    dot.cookieRequest.removeEventListener('load', impressHandler);\n    dot.cookieRequestDone = true;\n    dot.impress(callback, null);\n  };\n\n  dot.cookieRequest.addEventListener('load', impressHandler);\n};\n\n// API\nexport default { sendImpress, handleImpress, setImpressBeforeAdload };\n","import { Hit, SharedHitData } from '../../types/hit';\n\n/**\n *\n * Update (write over / merge) shared hit data. Consider only valid shared data -> rest is filtered out\n */\nexport const handleSubmitedSharedData = (\n  current: SharedHitData,\n  submited: SharedHitData,\n  merge = false\n): SharedHitData => {\n  // not and object submited\n  if (!(submited && typeof submited === 'object' && !Array.isArray(submited))) {\n    return current;\n  }\n\n  const output = {};\n  // is object with relevant keys / values?\n  try {\n    for (const [key, data] of Object.entries(submited)) {\n      if (data?.value !== undefined && Array.isArray(data?.actions || [])) {\n        output[key] = data;\n      }\n    }\n  } catch {\n    // noop\n  }\n\n  return { ...(merge ? current : {}), ...output };\n};\n\n/**\n * Remove shared hit data (all / specific keys)\n */\nexport const cleanStoredSharedData = (current: SharedHitData, keys: unknown): SharedHitData => {\n  const output = { ...current };\n  if (Array.isArray(keys) && keys.length) {\n    keys.forEach((key) => {\n      delete output[key];\n    });\n    return output;\n  } else {\n    return {};\n  }\n};\n\n/**\n * Filter out shared data according to hit \"action\" type\n */\nexport const extendHitWithSharedData = (hit: Hit, sharedData: SharedHitData) => {\n  for (const [key, data] of Object.entries(sharedData)) {\n    if (!data.actions || !data.actions.length || data.actions?.includes(hit.action)) {\n      if (!hit.data) {\n        hit.data = {};\n      }\n      hit.data[key] = data.value;\n    }\n  }\n};\n","/* eslint-disable no-unused-vars */\n// Types\nimport { DOT } from '../../classes/dot.class';\nimport { RequestInitWithPriority } from '../../types/common';\nimport { Hit, Data, PropagateHitsMessageEvent } from '../../types/hit';\n// Methods\nimport { addUserAgreement, getCommon, serializeHit } from './composeData';\nimport { shouldLazyHit, addToHitQueue } from '../lazyHitting/lazyHitting';\nimport { addToPostponedQueue, shouldPostponeHits } from '../postponedHitting/postponedHitting';\nimport { getDataDot } from '../utils/html/traversing';\nimport { getTopWindow, isTopLevel } from '../utils/html/iframe';\nimport { isPageOpenfromLocalFile } from '../utils/general/url';\nimport { isSznAdmin } from '../identityObject/identityObject';\nimport { setImpressBeforeAdload } from '../impress/impress';\n\n// Constants\nimport { EVENTS, HTTP_METHODS, PROPAGATE_HITS_BLACKLIST } from '../../constants';\nimport { extendHitWithSharedData } from './sharedData';\n\nconst _isItFinalSpenttimeHit = (hit: Hit) => hit.data?.action === 'spenttime' && hit.data?.type === 'final';\n\n/**\n * Creates hit XHR request\n *\n * @param dot DOT instance\n * @param hit all serialized hit data\n * @param postData POST request body\n * @param callback called when XHR loads. In case of any error is called with Error param\n */\nexport const _xhr = (dot: DOT, hit: Hit, callback?: (arg?: Error) => void): void => {\n  if (!window.XMLHttpRequest) {\n    dot.log('XHR is not available. Cannot send hit.', 'error');\n    return;\n  }\n\n  // config values\n  const { url: configUrl, host, hitTimeout } = dot._cfg;\n\n  // create request\n  const xhr = new XMLHttpRequest();\n  const sender = dot.variant ? `dot-${dot.variant.toLowerCase()}` : '';\n  const senderVersion = process.env._DOT_VERSION || '';\n  const url = _isItFinalSpenttimeHit(hit)\n    ? `${configUrl.replace('__HOST__', host)}?client-id=${sender}&client-version=${senderVersion}`\n    : configUrl.replace('__HOST__', host);\n\n  // prepare JSON body\n  const body = serializeHit(hit);\n  if (!body) {\n    dot.log('Invalid json data. Cannot prepare request body.');\n    return;\n  }\n\n  // handle callback\n  let callbackCalled = false;\n  if (typeof callback === 'function') {\n    const timeoutId = setTimeout(() => {\n      const error = new Error('Hit timed out');\n      error.name = 'TimeoutError';\n      // eslint-disable-next-line no-use-before-define\n      callCallback(error);\n    }, hitTimeout);\n\n    const callCallback = (argument?: Error): void => {\n      clearTimeout(timeoutId);\n      if (!callbackCalled) {\n        callbackCalled = true;\n        return callback(argument);\n      }\n    };\n\n    xhr.onerror = (): void => {\n      const error = new Error('Hit failed');\n      error.name = 'NetworkError';\n      callCallback(error);\n    };\n\n    xhr.onabort = (): void => {\n      const error = new Error('Hit aborted');\n      error.name = 'AbortError';\n      callCallback(error);\n    };\n\n    xhr.onload = (): void => {\n      callCallback();\n    };\n  }\n\n  // Request preparation (method, url, asyncFlag).\n  xhr.open(HTTP_METHODS.POST, url, true);\n\n  // Send the proper header information along with the request\n  xhr.setRequestHeader('Content-Type', 'application/json');\n\n  // Sender (DOT) information\n  xhr.setRequestHeader('X-Client-Id', sender);\n  xhr.setRequestHeader('X-Client-Version', senderVersion);\n  // Device information\n  xhr.setRequestHeader('X-Sec-CH-UA-Model', dot.UAData.model);\n  xhr.setRequestHeader('X-Sec-CH-UA-Platform-Version', dot.UAData.platformVersion);\n\n  // Required to send with cookies.\n  xhr.withCredentials = true;\n\n  // Send request\n  xhr.send(body);\n};\n\n/**\n * Creates hit Fetch promise\n *\n * @param dot DOT instance\n * @param hit all serialized hit data\n * @param postData POST request body\n * @param callback called when Fetch promise resolves. In case of any error is called with Error param\n */\nexport const _fetch = async (dot: DOT, hit: Hit, callback?: (arg?: Error) => void) => {\n  // config values\n  const { url: configUrl, host, hitTimeout } = dot._cfg;\n\n  const sender = dot.variant ? `dot-${dot.variant.toLowerCase()}` : '';\n  const senderVersion = process.env._DOT_VERSION || '';\n  const url = _isItFinalSpenttimeHit(hit)\n    ? `${configUrl.replace('__HOST__', host)}?client-id=${sender}&client-version=${senderVersion}`\n    : configUrl.replace('__HOST__', host);\n\n  // prepare JSON body\n  const body = serializeHit(hit);\n  if (!body) {\n    dot.log('Invalid json data. Cannot prepare request body.');\n    return;\n  }\n\n  // handle hit timeout\n  const controller = new AbortController();\n  const timeoutId = setTimeout(() => {\n    controller.abort();\n    const error = new Error('Hit timed out');\n    error.name = 'TimeoutError';\n    // eslint-disable-next-line no-use-before-define\n    callCallback(error);\n  }, hitTimeout);\n\n  // handle callback if exists\n  let callbackCalled = false;\n  const callCallback = (argument?: Error): void => {\n    clearTimeout(timeoutId);\n    if (typeof callback === 'function' && !callbackCalled) {\n      callbackCalled = true;\n      return callback(argument);\n    }\n  };\n\n  try {\n    const response = await fetch(url, {\n      method: HTTP_METHODS.POST,\n      keepalive: true,\n      priority: 'high',\n      credentials: 'include',\n      signal: controller.signal,\n      body,\n      headers: {\n        'Content-Type': 'application/json',\n        'X-Client-Id': sender,\n        'X-Client-Version': senderVersion,\n        'X-Sec-CH-UA-Model': dot.UAData.model,\n        'X-Sec-CH-UA-Platform-Version': dot.UAData.platformVersion,\n      },\n    } as RequestInitWithPriority);\n\n    if (!response.ok) {\n      const error = new Error('Hit failed');\n      error.name = 'NetworkError';\n      callCallback(error);\n      throw error;\n    }\n\n    callCallback();\n  } catch (e) {\n    if (dot._cfg.error) {\n      dot.error(e);\n    }\n    dot.log('Something went wrong with fetch request initialization, fallback to xhr');\n    _xhr(dot, hit, callback);\n  }\n};\n\n/**\n * Sends beacon API hit\n *\n * @param dot DOT instance\n * @param hit all serialized hit data\n */\nexport const _beaconApi = (dot: DOT, hit: Hit, callback?: (arg?: Error) => void): void => {\n  const { url: configUrl, host } = dot._cfg;\n  const sender = dot.variant ? `dot-${dot.variant.toLowerCase()}` : '';\n  const senderVersion = process.env._DOT_VERSION || '';\n  const url = `${configUrl.replace('__HOST__', host)}?client-id=${sender}&client-version=${senderVersion}`;\n\n  // eslint-disable-next-line camelcase\n  const device_info = {\n    ...(dot.UAData.model && { model: dot.UAData.model }),\n    // eslint-disable-next-line camelcase\n    ...(dot.UAData.platformVersion && { platform_version: dot.UAData.platformVersion }),\n  };\n\n  const hitWithDeviceInfo = {\n    ...hit,\n    // eslint-disable-next-line camelcase\n    ...(Object.keys(device_info).length && { device_info }),\n  };\n\n  const blob = new Blob([JSON.stringify(hitWithDeviceInfo)], { type: 'application/json' });\n\n  try {\n    navigator.sendBeacon?.(url, blob);\n\n    if (typeof callback === 'function') {\n      return callback();\n    }\n  } catch (e) {\n    if (dot._cfg.error) {\n      dot.error(e);\n    }\n    dot.log('Failed sendBeacon with a Blob whose type is not a CORS-safelisted value for the data argument', 'error');\n\n    if (typeof callback === 'function') {\n      return callback(e);\n    }\n  }\n};\n\n/**\n * Sends hit\n *\n * @param dot DOT instance\n * @param action hit action\n * @param data hit data object\n * @param callback called when hit is sent. In case of any error is called with Error param\n * @param useFetch should use Fetch API for sending hit\n */\nexport const sendHit = (\n  dot: DOT,\n  action: string,\n  data: Data = {},\n  callback?: (arg?: Error) => void,\n  useFetch = false\n): void => {\n  if (isSznAdmin()) {\n    dot.log('Current user is admin from helpdesk. Cannot send hit.');\n    if (typeof callback === 'function') {\n      return callback(new Error('admin_session'));\n    }\n    return;\n  }\n\n  const hit: Hit = {\n    ...data,\n    action,\n    ...getCommon(dot),\n  };\n\n  if (hit?.action === 'adload') {\n    // reset impressBeforeAdloadSent after sending adload hit\n    setImpressBeforeAdload(dot, false);\n  }\n\n  // stopping hits from page loaded from local disk\n  if (isPageOpenfromLocalFile()) {\n    dot.log(`hit from file protocol ommitted: ${JSON.stringify(hit)}`, 'info');\n    return;\n  }\n\n  // We have no idea why negative spenttime value happens, the code shouldn't generate them.\n  // To not mess up with analytics, we do this sanity check here, see UZID-137 for more info.\n  if (hit?.d?.action === 'spenttime' && (hit?.d?.time as number) < 0) {\n    return;\n  }\n\n  // stopping hits with duplicate spenttime\n  if (hit?.data?.time && dot?.spenttimeState?.data?.d?.time && dot?.spenttimeState?.data?.d?.time >= hit?.data?.time) {\n    return;\n  }\n\n  if (dot.shouldLog()) {\n    hit.instanceId = dot.instanceId;\n  }\n\n  // rename q -> query (Backward compatibility)\n  if (hit.q !== undefined) {\n    hit.query = hit.q;\n    delete hit.q;\n  }\n\n  // rename d -> data (Backward compatibility)\n  if (hit.d !== undefined) {\n    hit.data = hit.d;\n    delete hit.d;\n  }\n\n  // shared data for hits\n  extendHitWithSharedData(hit, dot.sharedHitData);\n\n  hit.lsid = data.lsid || hit.lsid;\n\n  if (shouldLazyHit(dot.lazyHittingStatus)) {\n    addToHitQueue(dot.hitQueue, { hit, callback, useFetch });\n    return;\n  }\n\n  if (shouldPostponeHits(dot)) {\n    addToPostponedQueue(dot, { hit, callback, useFetch });\n    return;\n  }\n\n  addUserAgreement(dot._cfg, hit);\n\n  // propagate to _top\n  const { propagateHits } = dot._cfg;\n  if (!isTopLevel() && propagateHits && !PROPAGATE_HITS_BLACKLIST.includes(hit.action)) {\n    getTopWindow().postMessage({ type: EVENTS.PROPAGATE_HIT_MESSAGE, hit }, '*');\n  }\n\n  const { forceBeacon } = dot._cfg;\n  if (navigator.sendBeacon && (forceBeacon || _isItFinalSpenttimeHit(hit))) {\n    _beaconApi(dot, hit, callback);\n    return;\n  }\n\n  if (useFetch && window.fetch) {\n    _fetch(dot, hit, callback);\n    return;\n  }\n\n  _xhr(dot, hit, callback);\n};\n\n/**\n * Sends hit asynchronously\n *\n * @param dot DOT instance\n * @param action hit action\n * @param data hit data object\n * @param callback called when async hit is sent\n */\nexport const sendHitAsync = (dot: DOT, action: string, data: Data = {}, callback?: () => void): void => {\n  callback = callback || function () {};\n  setTimeout(() => {\n    sendHit(dot, action, data);\n    callback();\n  }, 0);\n};\n\n/**\n * Listen and forward propagated hits from frames\n *\n * @param dot DOT instance\n */\nexport const addPropagatedHitsListener = (dot: DOT) => {\n  window.addEventListener('message', (event: MessageEvent<PropagateHitsMessageEvent>) => {\n    if (\n      event.data.type === EVENTS.PROPAGATE_HIT_MESSAGE &&\n      !PROPAGATE_HITS_BLACKLIST.includes(event.data.hit.action) &&\n      dot === window.DOT\n    ) {\n      const propagatedHitData = { ...event.data.hit };\n\n      // extend \"path\" for \"mousedown\" events\n      const extendPath = event.data.hit.action === 'mousedown';\n      let extendedPath = '';\n      let sender = null;\n\n      if (extendPath) {\n        try {\n          sender = (event.source as Window)?.frameElement;\n        } catch {\n          if (!sender) {\n            const frames = document.querySelectorAll('iframe[src*=\"share.seznam.cz\"]');\n            for (let f = 0; f <= frames.length; f++) {\n              if ((frames[f] as HTMLIFrameElement)?.contentWindow === event.source) {\n                sender = frames[f];\n                break;\n              }\n            }\n          }\n        }\n      }\n\n      // sender detected - extend \"path\"\n      if (sender) {\n        const dotData = getDataDot(sender as HTMLElement);\n        extendedPath = dotData ? dotData + (propagatedHitData.data.path ? '/' : '') : '';\n      }\n\n      // prepend top level \"path\" to propagated \"path\"\n      if (propagatedHitData.data?.path) {\n        propagatedHitData.data.path = `${extendedPath}${propagatedHitData.data.path}`;\n      }\n\n      _xhr(dot, { ...propagatedHitData, service: dot._cfg.service });\n    }\n  });\n};\n","const rules = [\n  {\n    browser: 'firefox',\n    test: /firefox\\/(\\d+)\\./i,\n  },\n];\n\ntype UserAgent = {\n  browser?: string;\n  majorVersion?: number;\n};\n\nexport const parseUserAgent = (rawUserAgent: string): UserAgent => {\n  const userAgent: UserAgent = {};\n\n  for (const { browser, test } of rules) {\n    if (userAgent.browser) {\n      break;\n    }\n\n    const matches = test.exec(rawUserAgent);\n\n    if (matches) {\n      userAgent.browser = browser;\n\n      if (matches.length > 1) {\n        userAgent.majorVersion = Number(matches[1]);\n      }\n    }\n  }\n\n  return userAgent;\n};\n\n/**\n * Detects Safari browser\n */\nexport const isSafari = () => {\n  const { userAgent } = navigator;\n\n  return userAgent.includes('Safari/') && !userAgent.includes('Chrome/') && !userAgent.includes('Chromium/');\n};\n\n/**\n * Detects Sbrowser\n */\nexport const isSbrowser = (): boolean => {\n  return /SznProhlizec/.test(navigator.userAgent);\n};\n\nexport const getHighEntropyValues = (): Promise<UADataValues | null> => {\n  return new Promise((resolve) => {\n    if (!navigator?.userAgentData?.getHighEntropyValues) {\n      resolve(null);\n      return;\n    }\n    navigator.userAgentData\n      .getHighEntropyValues(['model', 'platformVersion'])\n      .then((data) => {\n        resolve(data);\n      })\n      .catch(() => {\n        resolve(null);\n      });\n  });\n};\n\nexport const getCDLValue = async (): Promise<string> => {\n  if ('cookieDeprecationLabel' in navigator) {\n    try {\n      return await navigator.cookieDeprecationLabel.getValue();\n    } catch {\n      return '';\n    }\n  }\n\n  return '';\n};\n\n// API\nexport default { isSafari, isSbrowser, getHighEntropyValues, getCDLValue };\n","// Types\nimport { NullableString } from '../../../types/common';\n// Modules\nimport { getCookie, removeCookie } from './cookie';\n// Constants\nimport { CW_REFERRER_COOKIE_NAME, CW_REFERRER_CURRENT_COOKIE_NAME } from '../../../constants/index';\n\n/**\n * Gets CW referrer cookie value from local domain\n */\nexport const getCWReferrerCookie = (): NullableString =>\n  getCookie(CW_REFERRER_COOKIE_NAME) ?? getCookie(CW_REFERRER_CURRENT_COOKIE_NAME);\n\n/**\n * Deletes CW referrer cookie\n */\nexport const removeCWReferrerCookie = (): void => {\n  removeCookie({ name: CW_REFERRER_COOKIE_NAME });\n  removeCookie({ name: CW_REFERRER_COOKIE_NAME, domain: window.location.hostname });\n  removeCookie({ name: CW_REFERRER_CURRENT_COOKIE_NAME });\n  removeCookie({ name: CW_REFERRER_CURRENT_COOKIE_NAME, domain: window.location.hostname });\n};\n","// Types\nimport { DOT } from '../classes/dot.class';\n// Methods\nimport { isLocalStorageAvailable, setToLocalStorage, getFromLocalStorage } from './utils/storage/storage';\nimport { clearSpenttimeInterval, clearVisibilitychangeEvent } from './spenttime/spenttime';\nimport { addPropagatedHitsListener } from './hit/hit';\nimport { getCDLValue, getHighEntropyValues } from './utils/general/browser';\nimport { getCWReferrerCookie, removeCWReferrerCookie } from './utils/cookie/cookieWallCookie';\n// Constants\nimport { LAST_SESSION_KEY, CDL_KEY, EVENTS } from '../constants/index';\n\n/**\n * Setup new unique page ID and saves it into window.name\n * @param dot DOT instance\n */\nexport const setWindowNameWithId = (dot: DOT): void => {\n  dot._cfg.id = '' + new Date().getTime() + Math.random();\n  if (dot._cfg.spenttimeSpaReset) {\n    clearSpenttimeInterval(dot);\n    clearVisibilitychangeEvent(dot);\n  }\n  if (!window.name) {\n    window.name = dot._cfg.id;\n  }\n};\n\n/**\n * Sets model and platformVersion from Navigator.UserAgentData\n * @param dot DOT instance\n */\nexport const setUAData = async (dot: DOT) => {\n  if (window.DOT?.UAData) {\n    // top level DOT data can be used\n    dot.UAData = window.DOT.UAData;\n    return;\n  }\n\n  const UAData = await getHighEntropyValues();\n\n  if (UAData?.model) {\n    dot.UAData.model = UAData.model;\n  }\n\n  if (UAData?.platformVersion) {\n    dot.UAData.platformVersion = UAData.platformVersion;\n  }\n};\n\n/**\n * Sets cookieDeprecationLabel from Navigator.cookieDeprecationLabel\n * Saves to DOT instance and updates localStorage\n * @param dot DOT instance\n */\nexport const setCookieDeprecationLabel = async (dot: DOT) => {\n  const localStorageValue = getFromLocalStorage(CDL_KEY) || '';\n  dot.cookieDeprecationLabel = localStorageValue;\n\n  const apiValue = await getCDLValue();\n  if (apiValue !== localStorageValue) {\n    setToLocalStorage(CDL_KEY, apiValue);\n    dot.cookieDeprecationLabel = apiValue;\n  }\n\n  // let all DOT instances know that another check for CDL was done and value could be changed\n  window.dispatchEvent(new CustomEvent(EVENTS.CDL_DONE));\n\n  // listen to other DOT instances to sync value\n  window.addEventListener(EVENTS.CDL_DONE, () => {\n    dot.cookieDeprecationLabel = getFromLocalStorage(CDL_KEY) || '';\n  });\n};\n\n/**\n * Initialize DOT instance\n * @param dot DOT instance\n */\nexport const init = (dot: DOT): void => {\n  setUAData(dot);\n  setCookieDeprecationLabel(dot);\n\n  // Cookie Wall referrer\n  const cwReferrer = getCWReferrerCookie();\n  if (cwReferrer !== null) {\n    const ref = decodeURIComponent(cwReferrer);\n    Object.defineProperty(document, 'referrer', {\n      get: () => ref,\n      configurable: true,\n    });\n    removeCWReferrerCookie();\n  }\n\n  dot.ts = new Date().getTime();\n  setWindowNameWithId(dot);\n  dot.lastSession = dot.ts;\n\n  if (isLocalStorageAvailable()) {\n    /* Save current timestamp to localStorage. It enables to measure unique visits and time among individual visits. */\n    dot.lastSession = parseInt(getFromLocalStorage(LAST_SESSION_KEY), 10) || 0;\n    setToLocalStorage(LAST_SESSION_KEY, dot.ts.toString());\n  }\n\n  addPropagatedHitsListener(dot);\n};\n\n// API\nexport default { setWindowNameWithId, init };\n","// Types\nimport { DOT } from '../../classes/dot.class';\nimport { Data } from '../../types/hit';\n// Methods\nimport { getGeometry } from '../geometry/geometry';\n\n/**\n * Composes and sends delayed hit\n * @param dot DOT instance\n */\nexport const _sendDelayed = (dot: DOT): void => {\n  const data: Data = {\n    d: {\n      count: dot.delayed.count,\n      ...getGeometry(dot.dataElms),\n    },\n  };\n  dot.hit(dot.delayed.action, data);\n  dot.delayed.count = 0;\n};\n\n/**\n * Initialize sending delayed hit\n * @param dot DOT instance\n * @param action delayed hit action\n */\nexport const delay = (dot: DOT, action: string): void => {\n  dot.delayed.action = action;\n\n  if (dot.delayed.timeout) {\n    clearTimeout(dot.delayed.timeout);\n    dot.delayed.timeout = null;\n  }\n\n  dot.delayed.count++;\n\n  dot.delayed.timeout = setTimeout((): void => {\n    _sendDelayed(dot);\n  }, dot._cfg.delay);\n};\n\n// API\nexport default { delay };\n","// Types\nimport { DOT } from '../../classes/dot.class';\n\nconst BEFORE_MESSAGE = 'Module Error: ';\n\n/**\n * Prints method placeholder\n * @param dot DOT instance\n * @param moduleName name of module which includes called method\n * @param methodName name of called method\n */\n// eslint-disable-next-line no-unused-vars\nexport const placeholder = (dot: DOT, moduleName: string, methodName: string, ...params): void => {\n  const message = `'${methodName}' method not found, because [${moduleName}] module is not part of DOT-${dot.variant} variant`;\n\n  dot.log(`${BEFORE_MESSAGE}${message}`, 'error');\n};\n\n// API\nexport default { placeholder };\n","import { debugFactory } from '@iva/debugger';\nimport { LOG_COLOR_BG, SERVICE_NAME, LOG_COLOR_DEFAULT } from '../../constants/index';\n\nconst DEBUG_CONFIG = {\n  name: SERVICE_NAME,\n  bColor: LOG_COLOR_BG,\n  fColor: LOG_COLOR_DEFAULT,\n};\n\n// Use the parameter ?sznivadbg=1 or ?sznivadbg=DOT for debugging\n\nexport const dotDebugFactory = (config) => debugFactory({ ...DEBUG_CONFIG, ...config });\n\nexport default { dotDebugFactory };\n","/**\n * Generate random hexadecimal number\n * @param min Minimum (included)\n * @param max Maximum (excluded)\n * @param pad Pad with leading nulls to this length\n * @returns hexadecimal number\n */\nexport const getRandomHexdec = (min: number, max: number, pad = 0): string =>\n  Math.floor(Math.random() * (max - min) + min)\n    .toString(16)\n    .padStart(pad, '0');\n\n/**\n * Generate random color hexadecimal code\n * @param min Minimum amount for each color component (included)\n * @param max Maximum amount for each color component (excluded)\n * @returns Full hexadecimal color code including sharp sign\n */\nexport const getRandomColor = (min = 0x00, max = 0x100): string =>\n  `#${getRandomHexdec(min, max, 2)}${getRandomHexdec(min, max, 2)}${getRandomHexdec(min, max, 2)}`;\n","// Types\nimport { KeyValuePairs, NullableString } from '../types/common';\nimport { Config, Service, ConfigValue } from '../types/config';\nimport { Delay, InfoObject, UserAgentData, SspAllowedSources } from '../types/dot';\nimport { Data, SavedHit, SharedHitData } from '../types/hit';\nimport { Spenttime } from '../types/spenttime';\n// Methods\nimport {\n  getConfig,\n  enableAfterCfgEvent,\n  configure,\n  isInstanceConfigured,\n  getValue,\n  _fireAfterCfgEvent,\n} from '../modules/config/config';\nimport { init } from '../modules/init';\nimport { sendHit, sendHitAsync } from '../modules/hit/hit';\nimport { handleImpress, sendImpress } from '../modules/impress/impress';\nimport { delay } from '../modules/hit/delayedHit';\nimport { placeholder } from '../modules/logger/methodPlaceholder';\nimport { dotDebugFactory } from '../modules/logger/log';\nimport { getRandomColor } from '../modules/utils/general/string';\nimport { configureFromTopFrame } from '../modules/utils/html/iframe';\nimport { cleanStoredSharedData, handleSubmitedSharedData } from '../modules/hit/sharedData';\n// Constants\nimport { LAZY_HITTING_DISABLED, LOG_COLOR_MIN, LOG_COLOR_MAX, SSP_ALLOWED_SOURCES } from '../constants/index';\n\nexport class DOT {\n  /**\n   * DOT variant\n   */\n  protected _variant: Service;\n\n  /**\n   * Timestamp of instance initialization\n   */\n  protected _ts: number;\n\n  /**\n   * Timestamp of instance initialization from localStorage\n   */\n  protected _lastSession: number;\n\n  /**\n   * Collection of html elements for visibility check\n   */\n  protected _dataElms: [];\n\n  /**\n   * Config object for sending delayed hits\n   */\n  protected _delayed: Delay;\n\n  /**\n   * Instance configuration status\n   */\n  protected _configured: boolean;\n\n  /**\n   * Referrer for SPA website\n   */\n  protected _SPAReferrer: string;\n\n  /**\n   * Last fcp value\n   */\n  protected _lastFCP: number;\n\n  /**\n   * Saved hits from lazy hitting\n   */\n  protected _hitQueue?: SavedHit[];\n\n  /**\n   * Lazy hitting status\n   */\n  protected _lazyHittingStatus?: number;\n\n  /**\n   * Saved hits waiting for SID sync\n   */\n  protected _postponedQueue?: SavedHit[];\n\n  /**\n   * SID syncing status\n   */\n  protected _synced?: boolean;\n\n  /**\n   * True when sid XHR is loaded\n   */\n  protected _cookieRequestDone?: boolean;\n\n  /**\n   * Reference to sid XHR\n   */\n  protected _cookieRequest?: XMLHttpRequest;\n\n  /**\n   * True when udid request is resolved\n   */\n  protected _udidRequestDone?: boolean;\n\n  /**\n   * True when first impress hit has been sent\n   */\n  protected _firstImpressSent: boolean;\n\n  /**\n   * True when necessary impress right before adload has been sent\n   */\n  protected _impressBeforeAdloadSent: boolean;\n\n  /**\n   * Custom event after cfg() enable status\n   */\n  protected _fireEventAfterCfg: boolean;\n\n  /**\n   * Reference to function that tries to send all saved hits onbeforeunload\n   */\n  protected _sentBeforeUnload?: () => void;\n\n  /**\n   * Object to keep data about time spent on the site\n   */\n  protected _spenttimeState: Spenttime;\n\n  /** spenttime configuration status\n   */\n  protected _spenttimeConfigured: boolean;\n\n  /**\n   * Instance configuration\n   */\n  protected _config: Config;\n\n  /**\n   * info object\n   */\n  protected _info: InfoObject;\n\n  /**\n   * Random instance ID to distinguish in the console logs\n   */\n  protected _instanceId: number;\n\n  /**\n   * Random color to distinguish in the console logs\n   */\n  protected _instanceColor: string;\n\n  /**\n   * UserAgentData from navigator object\n   */\n  protected _UAData: UserAgentData;\n\n  /**\n   * Chrome cookie deprecation label value\n   */\n  protected _cookieDeprecationLabel: string;\n\n  /**\n   * Internal configurated logger function\n   */\n  protected _log: ReturnType<typeof dotDebugFactory>;\n\n  /**\n   * Data which are included in all hits\n   */\n  protected _sharedHitData: SharedHitData;\n\n  /**\n   * DOT constructor\n   * @param variant DOT variant\n   */\n  constructor(variant?: Service) {\n    this._variant = variant ? variant : null;\n    this._ts = 0;\n    this._lastSession = 0;\n    this._dataElms = [];\n    this._delayed = {\n      action: '',\n      timeout: null,\n      count: 0,\n    };\n    this._configured = false;\n    this._SPAReferrer = '';\n    this._lastFCP = -1;\n    this._hitQueue = [];\n    this._lazyHittingStatus = LAZY_HITTING_DISABLED;\n    this._postponedQueue = [];\n    this._synced = false;\n    this._cookieRequestDone = false;\n    this._cookieRequest = null;\n    this._udidRequestDone = false;\n    this._firstImpressSent = false;\n    this._impressBeforeAdloadSent = false;\n    this._fireEventAfterCfg = false;\n    this._sentBeforeUnload = null;\n    this._config = getConfig(this._variant);\n    this._info = {\n      site: window.document.location.href,\n      topConfig: null,\n    };\n    this._UAData = {\n      model: '',\n      platformVersion: '',\n    };\n    this._cookieDeprecationLabel = '';\n\n    // Logger\n    this._instanceId = Math.floor(Math.random() * 10000);\n    this._instanceColor = getRandomColor(LOG_COLOR_MIN, LOG_COLOR_MAX);\n    this._log = dotDebugFactory({ fColor: this._instanceColor });\n    this._sharedHitData = {};\n    this.log(`NEW DOT ${this._variant}`);\n\n    init(this);\n  }\n\n  /**\n   /=============================================================================\n   /\n   / Getters and Setters\n   /\n   /=============================================================================\n  */\n\n  /**\n   * Gets _variant property\n   */\n  public get variant(): Service {\n    return this._variant;\n  }\n\n  /**\n   * Gets _ts property\n   */\n  public get ts(): number {\n    return this._ts;\n  }\n\n  /**\n   * Sets _ts property\n   */\n  public set ts(value: number) {\n    this._ts = value;\n  }\n\n  /**\n   * Gets _lastSession property\n   */\n  public get lastSession(): number {\n    return this._lastSession;\n  }\n\n  /**\n   * Sets _lastSession property\n   */\n  public set lastSession(value: number) {\n    this._lastSession = value;\n  }\n\n  /**\n   * Gets _dataElms property\n   */\n  public get dataElms(): [] {\n    return this._dataElms;\n  }\n\n  /**\n   * Sets _dataElms property\n   */\n  public set dataElms(value: []) {\n    this._dataElms = value;\n  }\n\n  /**\n   * Gets _delayed property\n   */\n  public get delayed(): Delay {\n    return this._delayed;\n  }\n\n  /**\n   * Sets _delayed property\n   */\n  public set delayed(value: Delay) {\n    this._delayed = value;\n  }\n\n  /**\n   * Gets _configured property\n   */\n  public get configured(): boolean {\n    return this._configured;\n  }\n\n  /**\n   * Sets _configured property\n   */\n  public set configured(value: boolean) {\n    this._configured = value;\n  }\n\n  /**\n   * Gets _SPAReferrer property\n   */\n  public get SPAReferrer(): string {\n    return this._SPAReferrer;\n  }\n\n  /**\n   * Sets _SPAReferrer property\n   */\n  public set SPAReferrer(value: string) {\n    this._SPAReferrer = value;\n  }\n\n  /**\n   * Gets _lastFCP property\n   */\n  public get lastFCP(): number {\n    return this._lastFCP;\n  }\n\n  /**\n   * Sets _lastFCP property\n   */\n  public set lastFCP(value: number) {\n    this._lastFCP = value;\n  }\n\n  /**\n   * Gets _hitQueue property\n   */\n  public get hitQueue(): SavedHit[] {\n    return this._hitQueue;\n  }\n\n  /**\n   * Sets _hitQueue property\n   */\n  public set hitQueue(value: SavedHit[]) {\n    this._hitQueue = value;\n  }\n\n  /**\n   * Gets _lazyHittingStatus property\n   */\n  public get lazyHittingStatus(): number {\n    return this._lazyHittingStatus;\n  }\n\n  /**\n   * Sets _lazyHittingStatus property\n   */\n  public set lazyHittingStatus(value: number) {\n    this._lazyHittingStatus = value;\n  }\n\n  /**\n   * Gets _postponedQueue property\n   */\n  public get postponedQueue(): SavedHit[] {\n    return this._postponedQueue;\n  }\n\n  /**\n   * Sets _postponedQueue property\n   */\n  public set postponedQueue(value: SavedHit[]) {\n    this._postponedQueue = value;\n  }\n\n  /**\n   * Gets _synced property\n   */\n  public get synced(): boolean {\n    return this._synced;\n  }\n\n  /**\n   * Sets _synced property\n   */\n  public set synced(value: boolean) {\n    this._synced = value;\n  }\n\n  /**\n   * Gets _cookieRequestDone property\n   */\n  public get cookieRequestDone(): boolean {\n    return this._cookieRequestDone;\n  }\n\n  /**\n   * Sets _cookieRequestDone property\n   */\n  public set cookieRequestDone(value: boolean) {\n    this._cookieRequestDone = value;\n  }\n\n  /**\n   * Gets _cookieRequest property\n   */\n  public get cookieRequest(): XMLHttpRequest {\n    return this._cookieRequest;\n  }\n\n  /**\n   * Sets _cookieRequest property\n   */\n  public set cookieRequest(value: XMLHttpRequest) {\n    this._cookieRequest = value;\n  }\n\n  /**\n   * Gets _udidRequestDone property\n   */\n  public get udidRequestDone(): boolean {\n    return this._udidRequestDone;\n  }\n\n  /**\n   * Sets _udidRequestDone property\n   */\n  public set udidRequestDone(value: boolean) {\n    this._udidRequestDone = value;\n  }\n\n  /**\n   * Gets _firstImpressSent property\n   */\n  public get firstImpressSent(): boolean {\n    return this._firstImpressSent;\n  }\n\n  /**\n   * Sets _firstImpressSent property\n   */\n  public set firstImpressSent(value: boolean) {\n    this._firstImpressSent = value;\n  }\n\n  /**\n   * Gets _impressBeforeAdloadSent property\n   */\n  public get impressBeforeAdloadSent(): boolean {\n    return this._impressBeforeAdloadSent;\n  }\n\n  /**\n   * Sets _impressBeforeAdloadSent property\n   */\n  public set impressBeforeAdloadSent(value: boolean) {\n    this._impressBeforeAdloadSent = value;\n  }\n\n  /**\n   * Gets _fireEventAfterCfg property\n   */\n  public get fireEventAfterCfg(): boolean {\n    return this._fireEventAfterCfg;\n  }\n\n  /**\n   * Sets _fireEventAfterCfg property\n   */\n  public set fireEventAfterCfg(value: boolean) {\n    this._fireEventAfterCfg = value;\n  }\n\n  /**\n   * Gets _sentBeforeUnload property\n   */\n  public get sentBeforeUnload(): () => void {\n    return this._sentBeforeUnload;\n  }\n\n  /**\n   * Sets _sentBeforeUnload property\n   */\n  public set sentBeforeUnload(value: () => void) {\n    this._sentBeforeUnload = value;\n  }\n\n  /**\n   * Gets _spenttime property, object that keeps spenttime state\n   */\n  public get spenttimeState(): Spenttime {\n    return this._spenttimeState;\n  }\n\n  /**\n   * Sets _spenttimeState property, object that keeps spenttime state\n   */\n  public set spenttimeState(value: Spenttime) {\n    this._spenttimeState = value;\n  }\n\n  /**\n   * Gets _spenttimeConfigured property\n   */\n  public get spenttimeConfigured(): boolean {\n    return this._spenttimeConfigured;\n  }\n\n  /**\n   * Sets _spenttimeConfigured property\n   */\n  public set spenttimeConfigured(value: boolean) {\n    this._spenttimeConfigured = value;\n  }\n\n  /**\n   * Gets _config property\n   */\n  public get _cfg(): Config {\n    return this._config;\n  }\n\n  /**\n   * Gets _instanceId\n   */\n  public get instanceId(): number {\n    return this._instanceId;\n  }\n\n  /**\n   * Gets _UAData property\n   */\n  public get UAData(): UserAgentData {\n    return this._UAData;\n  }\n\n  /**\n   * Sets _UAData property\n   */\n  public set UAData(value: UserAgentData) {\n    this._UAData = value;\n  }\n\n  /**\n   * Gets _cookieDeprecationLabel property\n   */\n  public get cookieDeprecationLabel(): string {\n    return this._cookieDeprecationLabel;\n  }\n\n  /**\n   * Sets _cookieDeprecationLabel property\n   */\n  public set cookieDeprecationLabel(value: string) {\n    this._cookieDeprecationLabel = value;\n  }\n\n  /**\n   * Gets _sharedHitData property\n   */\n  public get sharedHitData(): SharedHitData {\n    return this._sharedHitData;\n  }\n\n  /**\n   /=============================================================================\n   /\n   / Public API\n   /\n   /=============================================================================\n  */\n\n  /**\n   * Configures DOT instance\n   *\n   * @param customConfig config data object\n   * @param impressCallback called when impress is sent\n   */\n  public cfg(customConfig: KeyValuePairs<unknown>, impressCallback?: () => void): void {\n    configure(this, customConfig);\n\n    if (this._cfg.impress) {\n      handleImpress(this, impressCallback);\n    }\n\n    if (this.configured) {\n      return;\n    }\n    this.configured = true;\n\n    _fireAfterCfgEvent(this);\n  }\n\n  /**\n   * Configure this DOT instance with the top window DOT configuration.\n   * Call this instead of DOT.cfg() in an iframe.\n   * @returns Promise of Config object used to config this instance\n   */\n  public cfgFromTopFrame(): Promise<Config | null> {\n    return configureFromTopFrame(this);\n  }\n\n  /**\n   * Returns true if DOT.cfg() has been called\n   */\n  public isConfigured(): boolean {\n    return isInstanceConfigured(this);\n  }\n\n  /**\n   * Turns on hitting after the first call of cfg()\n   * Returns The name of the custom event.\n   */\n  public setAfterCfgEvent(): string {\n    return enableAfterCfgEvent(this);\n  }\n\n  /**\n   * Returns value from instance config\n   * @param key key of config value\n   */\n  public getCfgValue(key: string): ConfigValue | null {\n    return getValue(this, key);\n  }\n\n  /**\n   * Returns instance config object\n   */\n  public getCfg() {\n    return this._cfg;\n  }\n\n  /**\n   * get additional info object filled from parent dot instance\n   *\n   * see modules/utils/iframe.ts\n   */\n  public getInfo(): InfoObject {\n    return this._info;\n  }\n\n  /**\n   * Sends impress hit\n   *\n   * @param callback called when impress is sent\n   * @param impressData custom data which will be added to hit data (d:{...})\n   */\n  public impress(callback: () => void, impressData: KeyValuePairs<unknown>): void {\n    sendImpress(this, callback, impressData);\n  }\n\n  /**\n   * Returns new DOT instance\n   */\n  public getNewInstance(): DOT {\n    return new DOT();\n  }\n\n  /**\n   * Sends hit\n   *\n   * @param action event when hit is sent (event, load, etc.)\n   * @param data advanced data\n   * @param callback called when hit is sent. In case of any error is called with Error param\n   * @param useFetch should use Fetch API for sending hit\n   */\n  // eslint-disable-next-line no-unused-vars\n  public hit(action: string, data: Data = {}, callback?: (arg?: Error) => void, useFetch = false): void {\n    sendHit(this, action, data, callback, useFetch);\n  }\n\n  /**\n   * Sends hit asynchronously\n   *\n   * @param action event when hit is sent (event, load, etc.)\n   * @param data advanced data\n   * @param callback called when hit is sent. In case of any error, callback is called with Error param\n   */\n  // eslint-disable-next-line no-unused-vars\n  public hitAsync(action: string, data: Data = {}, callback?: (arg?: unknown) => void): void {\n    sendHitAsync(this, action, data, callback);\n  }\n\n  /**\n   * Sends delayed hit\n   * @param action delayed hit action\n   */\n  public _delay(action: string): void {\n    delay(this, action);\n  }\n\n  /**\n   * Gets allowed sources for SSP\n   */\n  public _getSspAllowedSources(): SspAllowedSources {\n    return SSP_ALLOWED_SOURCES;\n  }\n\n  public load(): void {\n    placeholder(this, 'load', 'load');\n  }\n\n  public error(...params: [e?: ErrorEvent, callback?: () => void]): void {\n    placeholder(this, 'error', 'error', params);\n  }\n\n  public spenttime(): void {\n    placeholder(this, 'spenttime', 'spenttime');\n  }\n\n  public cancelSpenttime(): void {\n    placeholder(this, 'spenttime', 'cancelSpenttime');\n  }\n\n  public handleSid(): void {\n    placeholder(this, 'linkdecoration', 'handleSid [deprecated]');\n  }\n\n  public runLinkdecoration(): void {\n    placeholder(this, 'linkdecoration', 'runLinkdecoration');\n  }\n\n  public getSid(): NullableString {\n    placeholder(this, 'linkdecoration', 'getSid');\n    return null;\n  }\n\n  public _handleSid(): void {\n    placeholder(this, 'Sbrowser sync SID', '_handleSid');\n  }\n\n  /**\n   * Print message with DOT instance ID into console\n   */\n  public log(message: string, type: 'log' | 'warn' | 'error' | 'info' | 'table' = 'log', ...data: unknown[]): boolean {\n    return this._log({\n      subName: this._instanceId,\n      type,\n      message,\n      ...data,\n    });\n  }\n\n  public shouldLog(): boolean {\n    return this._log();\n  }\n\n  /**\n   * Shared hit data\n   */\n  public getSharedHitData(): SharedHitData {\n    return this._sharedHitData;\n  }\n  public clearSharedHitData(keys?: string[]): void {\n    this._sharedHitData = cleanStoredSharedData(this._sharedHitData, keys);\n  }\n  public setSharedHitData(data: SharedHitData, merge = false): void {\n    this._sharedHitData = handleSubmitedSharedData(this._sharedHitData, data, merge);\n  }\n}\n","import { parseUserAgent, isSafari } from '../utils/general/browser';\n\nconst isRedirectPage = (): boolean =>\n  window.document.location.href.startsWith('https://www.seznam.cz/nastaveni-souhlasu');\n\nexport const shouldUseRedirect = (): boolean => {\n  const { browser, majorVersion } = parseUserAgent(window.navigator.userAgent);\n\n  if (isRedirectPage()) {\n    return false;\n  }\n\n  return isSafari() || (browser === 'firefox' && majorVersion >= 101);\n};\n","// Types\nimport { DOT } from '../../classes/dot.class';\nimport { NullableString, NullableNumber, KeyValuePairs } from '../../types/common';\nimport { CookieData, ParsedSid, SidCookieRequestResponse } from '../../types/cookie';\n// Methods\nimport { getSidCookie, setCookieAndReport } from '../utils/cookie/cookie';\nimport { isSeznamDomain } from '../utils/general/url';\nimport { sendPostponedHits } from '../postponedHitting/postponedHitting';\nimport { updateSidIdentity } from '../identityObject/identityObject';\nimport { setToLocalStorage } from '../utils/storage/storage';\n// Constants\nimport { EVENTS, HTTP_METHODS, MAX_ITERATIONS, INTERVAL_TIMEOUT } from '../../constants/index';\n// IVA Libs\nimport { CONSENT, SID_STORE_CHECK } from '@sklik/cmp2-common';\nimport { SID_UTILS } from '@iva/utils';\n\n/**\n * Get body data for XHR request (based on SID cookie)\n * Temporarly adds consent string to body\n */\nexport const _createRequestBody = (): NullableString => {\n  const sid = getSidCookie();\n  const consent = CONSENT.getConsentFromCookieList()?.consentString;\n\n  const params = [SID_UTILS.isValidSid(sid) ? `dsid=${sid}` : null, consent ? `euconsent-v2=${consent}` : null].filter(\n    Boolean\n  );\n\n  return params.length ? params.join('&') : null;\n};\n\n/**\n * Sets sid on foreign domain (all domains except seznam.cz)\n * @param sid cookie string value\n */\nexport const setSidIntoForeignDomain = (sid: string): void => {\n  updateSidIdentity(sid);\n  setToLocalStorage('sid', sid);\n  setCookieAndReport({ value: sid, name: 'sid', expires: [3, 'days'] });\n};\n\n/**\n * Sets sid on seznam domain\n * @param sid cookie string value\n */\nexport const setSidIntoSeznamDomain = (dot: DOT, sid: string): void => {\n  const sidCookie = getSidCookie();\n  if (sidCookie) {\n    dot.log('Sid cookie already exists.');\n    window.dispatchEvent(\n      new CustomEvent(EVENTS.COOKIE_EVENT, { detail: <CookieData>{ name: 'sid', value: sidCookie } })\n    );\n    return;\n  }\n  // no sid currently in domain\n  updateSidIdentity(sid);\n  setToLocalStorage('sid', sid);\n  setCookieAndReport({ value: sid, name: 'sid', expires: [3, 'days'] });\n};\n\n/**\n * Saves sid into browser\n * @param sid cookie string value\n */\nexport const saveSidIntoBrowser = (dot: DOT, sid: string): void => {\n  if (isSeznamDomain()) {\n    dot.log('Save sid on seznam domain.');\n    setSidIntoSeznamDomain(dot, sid);\n    return;\n  }\n  dot.log('Save sid on foreign domain.');\n  setSidIntoForeignDomain(sid);\n};\n\n/**\n * XHR success callback (sets cookie and logs info data)\n * @param service String identificator of service\n * @param response SXHR response string\n */\nexport const _handleCookieRequestResponse = (dot: DOT, service: string, response: string): void => {\n  dot.log('Cookie request successfully received response.');\n\n  let data: SidCookieRequestResponse | null = null;\n\n  // parse received data\n  try {\n    data = JSON.parse(response);\n  } catch {\n    // no-op\n    return;\n  }\n\n  // check response structure\n  if (!(data.status === 'ok' && data.sid)) {\n    dot.log('Something bad in cookie response: ' + response);\n    return;\n  }\n\n  if (!SID_UTILS.isValidSid(data.sid)) {\n    dot.log(`Got invalid sid ${data.sid}`);\n    return;\n  }\n\n  try {\n    // because of AMP\n    saveSidIntoBrowser(dot, data.sid);\n  } catch {\n    // no-op\n    return;\n  }\n\n  dot.log(`Sid cookie synchronised to service ${service}`);\n  dot.log(`show sid ${data.sid}`);\n};\n\n/**\n * Additionally waits for consent with purpose one and sends sid request\n * @param sidXhr\n * @param requestBody\n */\nexport const sendRequestAfterAdditionalConsent = (\n  dot: DOT,\n  sidXhr: XMLHttpRequest,\n  requestBody: NullableString\n): void => {\n  dot.log('Still waiting for potentional consent cookie with purposeOne...');\n\n  let interval = null;\n  let iterationCount = 0;\n\n  const finishInterval = () => {\n    clearInterval(interval);\n    interval = null;\n  };\n\n  const trySendRequest = () => {\n    const consentCookie = CONSENT.getConsentFromCookieList();\n    if (!consentCookie) {\n      // no consent cookie\n      return;\n    }\n    finishInterval();\n    // eslint-disable-next-line no-use-before-define\n    window.removeEventListener(EVENTS.SCMP_CONSENT_SET, scmpHandler);\n\n    // consent cookie exists\n    if (CONSENT.hasPurposeOne(consentCookie.consentString)) {\n      dot.log('Got consent with purposeOne. Sending sid request.');\n      sidXhr.send(requestBody);\n    } else {\n      dot.log('Got consent without purposeOne. Cannot send sid request.');\n    }\n  };\n\n  const scmpHandler = () => {\n    // try to send sid request legally\n    trySendRequest();\n  };\n\n  const periodicalCheck = () => {\n    if (iterationCount >= MAX_ITERATIONS) {\n      // stop interval and listen for CMP event at least\n      finishInterval();\n      window.addEventListener(EVENTS.SCMP_CONSENT_SET, scmpHandler);\n    }\n\n    // try to send sid request legally\n    trySendRequest();\n\n    // keep checking\n    iterationCount++;\n  };\n\n  // set up periodical check\n  interval = setInterval(periodicalCheck, INTERVAL_TIMEOUT);\n};\n\n/**\n * Prepare and send cookie sync XHR request\n * @param dot DOT instance\n * @param config Variant specific config\n */\nexport const createCookieRequest = (dot: DOT): void => {\n  if (!window.XMLHttpRequest) {\n    dot.log('XHR is not available.', 'error');\n    return;\n  }\n\n  const { thirdPartyCookieUrl, host, service } = dot._cfg;\n\n  const xhr = new XMLHttpRequest();\n  dot.cookieRequest = xhr;\n\n  const url = thirdPartyCookieUrl.replace('__HOST__', host);\n  const body = _createRequestBody();\n  const sender = dot.variant ? `dot-${dot.variant.toLowerCase()}` : '';\n  const senderVersion = process.env._DOT_VERSION || '';\n\n  xhr.onreadystatechange = () => {\n    if (xhr.readyState !== 4) {\n      // no-op\n      return;\n    }\n\n    dot.cookieRequestDone = true;\n\n    if (xhr.status === 200 && xhr.responseText) {\n      _handleCookieRequestResponse(dot, service, xhr.responseText);\n    } else {\n      dot.log('Something went wrong with cookie request.', 'error');\n    }\n\n    sendPostponedHits(dot);\n  };\n\n  // Request preparation (method, url, asyncFlag).\n  xhr.open(HTTP_METHODS.POST, url, true);\n\n  // Send the proper header information along with the request\n  xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');\n\n  // Sender (DOT) information\n  xhr.setRequestHeader('X-Client-Id', sender);\n  xhr.setRequestHeader('X-Client-Version', senderVersion);\n\n  // Required to send with cookies.\n  xhr.withCredentials = true;\n\n  // Send request\n  SID_STORE_CHECK.sidLegalStoreCheckPromise().then((allowed) => {\n    if (allowed) {\n      xhr.send(body);\n      dot.log('Can now legally store SID (partner with purposeOne consent)');\n    } else {\n      dot.log('Can not legally store SID (partner without purposeOne consent)');\n      xhr.dispatchEvent(new CustomEvent('load'));\n      window.dispatchEvent(new CustomEvent(EVENTS.COOKIE_EVENT, { detail: <CookieData>{ name: 'sid' } }));\n      dot.cookieRequestDone = true;\n\n      dot.log('Processing postponed hits');\n      sendPostponedHits(dot);\n      dot.log('Hits gonna be sent even without sid');\n\n      // wait for potentional consent and send request later\n      sendRequestAfterAdditionalConsent(dot, xhr, body);\n    }\n  });\n};\n\n/**\n * Parse sid cookie string and return object\n */\nexport const _parseCookieValue = (value?: string): ParsedSid | null => {\n  if (!value) {\n    return null;\n  }\n  const params = value.trim().split('|');\n  const splitParams: KeyValuePairs<string | number> = {};\n  params.forEach((str) => {\n    const substr: RegExpExecArray | null[] = /(.+)=(.+)/g.exec(str) || [null];\n    if (substr[1]) {\n      const [, paramKey, paramValue] = substr;\n      splitParams[paramKey] = paramValue;\n    }\n  });\n  return splitParams as ParsedSid;\n};\n\n/**\n * Get time (in ms) representing last sid update (or null if no sid)\n */\nexport const _getTimeSinceCookieUpdate = (value?: string): NullableNumber => {\n  // te=<timestamp> - UNIX timestamp (with millisecond precision) of last contact with this SID.\n  // It is set to current UNIX time each time a request with this SID is processed.\n  const sidCookieData = _parseCookieValue(value);\n  if (!sidCookieData?.te) {\n    return null;\n  }\n  return new Date().getTime() - (sidCookieData.te as number) * 1000;\n};\n\n/**\n * Should cookie refresh be disabled (validate serverSideRefresher config and sid max age)?\n */\nexport const shouldDisableCookieRefresh = (serverSideRefresher?: boolean): boolean => {\n  const sid = getSidCookie();\n  const maxAgeSidCookie = 24 * 60 * 60 * 1000; // 24 hours\n  return !!(serverSideRefresher && sid && _getTimeSinceCookieUpdate(sid) < maxAgeSidCookie);\n};\n\n/**\n * Checking that sid cookie exists\n * @returns true - sid cookie exists, false - no\n */\nexport const hasAlreadySetSid = (): boolean => {\n  return window.sznIVA?.linkdec?.sid?.state === 'done' && window.sznIVA.linkdec.sid.sid === getSidCookie();\n};\n\n// API\nexport default {\n  createCookieRequest,\n  sendRequestAfterAdditionalConsent,\n  shouldDisableCookieRefresh,\n  hasAlreadySetSid,\n};\n","var e={330:function(e,t,n){e=n.nmd(e);var r=\"__lodash_hash_undefined__\",o=9007199254740991,i=\"[object Arguments]\",a=\"[object Boolean]\",s=\"[object Date]\",c=\"[object Function]\",u=\"[object GeneratorFunction]\",l=\"[object Map]\",d=\"[object Number]\",f=\"[object Object]\",p=\"[object Promise]\",g=\"[object RegExp]\",v=\"[object Set]\",h=\"[object String]\",w=\"[object Symbol]\",b=\"[object WeakMap]\",y=\"[object ArrayBuffer]\",_=\"[object DataView]\",m=\"[object Float32Array]\",j=\"[object Float64Array]\",O=\"[object Int8Array]\",S=\"[object Int16Array]\",A=\"[object Int32Array]\",I=\"[object Uint8Array]\",x=\"[object Uint8ClampedArray]\",z=\"[object Uint16Array]\",C=\"[object Uint32Array]\",$=/\\w*$/,E=/^\\[object .+?Constructor\\]$/,V=/^(?:0|[1-9]\\d*)$/,k={};k[i]=k[\"[object Array]\"]=k[y]=k[_]=k[a]=k[s]=k[m]=k[j]=k[O]=k[S]=k[A]=k[l]=k[d]=k[f]=k[g]=k[v]=k[h]=k[w]=k[I]=k[x]=k[z]=k[C]=!0,k[\"[object Error]\"]=k[c]=k[b]=!1;var F=\"object\"==typeof n.g&&n.g&&n.g.Object===Object&&n.g,R=\"object\"==typeof self&&self&&self.Object===Object&&self,M=F||R||Function(\"return this\")(),P=t&&!t.nodeType&&t,T=P&&e&&!e.nodeType&&e,B=T&&T.exports===P;function N(e,t){return e.set(t[0],t[1]),e}function L(e,t){return e.add(t),e}function U(e,t,n,r){var o=-1,i=e?e.length:0;for(r&&i&&(n=e[++o]);++o<i;)n=t(n,e[o],o,e);return n}function D(e){var t=!1;if(null!=e&&\"function\"!=typeof e.toString)try{t=!!(e+\"\")}catch(e){}return t}function q(e){var t=-1,n=Array(e.size);return e.forEach((function(e,r){n[++t]=[r,e]})),n}function H(e,t){return function(n){return e(t(n))}}function G(e){var t=-1,n=Array(e.size);return e.forEach((function(e){n[++t]=e})),n}var X,W=Array.prototype,J=Function.prototype,K=Object.prototype,Q=M[\"__core-js_shared__\"],Y=(X=/[^.]+$/.exec(Q&&Q.keys&&Q.keys.IE_PROTO||\"\"))?\"Symbol(src)_1.\"+X:\"\",Z=J.toString,ee=K.hasOwnProperty,te=K.toString,ne=RegExp(\"^\"+Z.call(ee).replace(/[\\\\^$.*+?()[\\]{}|]/g,\"\\\\$&\").replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g,\"$1.*?\")+\"$\"),re=B?M.Buffer:void 0,oe=M.Symbol,ie=M.Uint8Array,ae=H(Object.getPrototypeOf,Object),se=Object.create,ce=K.propertyIsEnumerable,ue=W.splice,le=Object.getOwnPropertySymbols,de=re?re.isBuffer:void 0,fe=H(Object.keys,Object),pe=Me(M,\"DataView\"),ge=Me(M,\"Map\"),ve=Me(M,\"Promise\"),he=Me(M,\"Set\"),we=Me(M,\"WeakMap\"),be=Me(Object,\"create\"),ye=Le(pe),_e=Le(ge),me=Le(ve),je=Le(he),Oe=Le(we),Se=oe?oe.prototype:void 0,Ae=Se?Se.valueOf:void 0;function Ie(e){var t=-1,n=e?e.length:0;for(this.clear();++t<n;){var r=e[t];this.set(r[0],r[1])}}function xe(e){var t=-1,n=e?e.length:0;for(this.clear();++t<n;){var r=e[t];this.set(r[0],r[1])}}function ze(e){var t=-1,n=e?e.length:0;for(this.clear();++t<n;){var r=e[t];this.set(r[0],r[1])}}function Ce(e){this.__data__=new xe(e)}function $e(e,t,n){var r=e[t];ee.call(e,t)&&Ue(r,n)&&(void 0!==n||t in e)||(e[t]=n)}function Ee(e,t){for(var n=e.length;n--;)if(Ue(e[n][0],t))return n;return-1}function Ve(e,t,n,r,o,p,b){var E;if(r&&(E=p?r(e,o,p,b):r(e)),void 0!==E)return E;if(!Xe(e))return e;var V=De(e);if(V){if(E=function(e){var t=e.length,n=e.constructor(t);return t&&\"string\"==typeof e[0]&&ee.call(e,\"index\")&&(n.index=e.index,n.input=e.input),n}(e),!t)return function(e,t){var n=-1,r=e.length;for(t||(t=Array(r));++n<r;)t[n]=e[n];return t}(e,E)}else{var F=Te(e),R=F==c||F==u;if(He(e))return function(e,t){if(t)return e.slice();var n=new e.constructor(e.length);return e.copy(n),n}(e,t);if(F==f||F==i||R&&!p){if(D(e))return p?e:{};if(E=function(e){return\"function\"!=typeof e.constructor||Ne(e)?{}:Xe(t=ae(e))?se(t):{};var t}(R?{}:e),!t)return function(e,t){return Fe(e,Pe(e),t)}(e,function(e,t){return e&&Fe(t,We(t),e)}(E,e))}else{if(!k[F])return p?e:{};E=function(e,t,n,r){var o,i=e.constructor;switch(t){case y:return ke(e);case a:case s:return new i(+e);case _:return function(e,t){var n=t?ke(e.buffer):e.buffer;return new e.constructor(n,e.byteOffset,e.byteLength)}(e,r);case m:case j:case O:case S:case A:case I:case x:case z:case C:return function(e,t){var n=t?ke(e.buffer):e.buffer;return new e.constructor(n,e.byteOffset,e.length)}(e,r);case l:return function(e,t,n){return U(t?n(q(e),!0):q(e),N,new e.constructor)}(e,r,n);case d:case h:return new i(e);case g:return function(e){var t=new e.constructor(e.source,$.exec(e));return t.lastIndex=e.lastIndex,t}(e);case v:return function(e,t,n){return U(t?n(G(e),!0):G(e),L,new e.constructor)}(e,r,n);case w:return o=e,Ae?Object(Ae.call(o)):{}}}(e,F,Ve,t)}}b||(b=new Ce);var M=b.get(e);if(M)return M;if(b.set(e,E),!V)var P=n?function(e){return function(e,t,n){var r=t(e);return De(e)?r:function(e,t){for(var n=-1,r=t.length,o=e.length;++n<r;)e[o+n]=t[n];return e}(r,n(e))}(e,We,Pe)}(e):We(e);return function(e,t){for(var n=-1,r=e?e.length:0;++n<r&&!1!==t(e[n],n););}(P||e,(function(o,i){P&&(o=e[i=o]),$e(E,i,Ve(o,t,n,r,i,e,b))})),E}function ke(e){var t=new e.constructor(e.byteLength);return new ie(t).set(new ie(e)),t}function Fe(e,t,n,r){n||(n={});for(var o=-1,i=t.length;++o<i;){var a=t[o],s=r?r(n[a],e[a],a,n,e):void 0;$e(n,a,void 0===s?e[a]:s)}return n}function Re(e,t){var n,r,o=e.__data__;return(\"string\"==(r=typeof(n=t))||\"number\"==r||\"symbol\"==r||\"boolean\"==r?\"__proto__\"!==n:null===n)?o[\"string\"==typeof t?\"string\":\"hash\"]:o.map}function Me(e,t){var n=function(e,t){return null==e?void 0:e[t]}(e,t);return function(e){return!(!Xe(e)||(t=e,Y&&Y in t))&&(Ge(e)||D(e)?ne:E).test(Le(e));var t}(n)?n:void 0}Ie.prototype.clear=function(){this.__data__=be?be(null):{}},Ie.prototype.delete=function(e){return this.has(e)&&delete this.__data__[e]},Ie.prototype.get=function(e){var t=this.__data__;if(be){var n=t[e];return n===r?void 0:n}return ee.call(t,e)?t[e]:void 0},Ie.prototype.has=function(e){var t=this.__data__;return be?void 0!==t[e]:ee.call(t,e)},Ie.prototype.set=function(e,t){return this.__data__[e]=be&&void 0===t?r:t,this},xe.prototype.clear=function(){this.__data__=[]},xe.prototype.delete=function(e){var t=this.__data__,n=Ee(t,e);return!(n<0||(n==t.length-1?t.pop():ue.call(t,n,1),0))},xe.prototype.get=function(e){var t=this.__data__,n=Ee(t,e);return n<0?void 0:t[n][1]},xe.prototype.has=function(e){return Ee(this.__data__,e)>-1},xe.prototype.set=function(e,t){var n=this.__data__,r=Ee(n,e);return r<0?n.push([e,t]):n[r][1]=t,this},ze.prototype.clear=function(){this.__data__={hash:new Ie,map:new(ge||xe),string:new Ie}},ze.prototype.delete=function(e){return Re(this,e).delete(e)},ze.prototype.get=function(e){return Re(this,e).get(e)},ze.prototype.has=function(e){return Re(this,e).has(e)},ze.prototype.set=function(e,t){return Re(this,e).set(e,t),this},Ce.prototype.clear=function(){this.__data__=new xe},Ce.prototype.delete=function(e){return this.__data__.delete(e)},Ce.prototype.get=function(e){return this.__data__.get(e)},Ce.prototype.has=function(e){return this.__data__.has(e)},Ce.prototype.set=function(e,t){var n=this.__data__;if(n instanceof xe){var r=n.__data__;if(!ge||r.length<199)return r.push([e,t]),this;n=this.__data__=new ze(r)}return n.set(e,t),this};var Pe=le?H(le,Object):function(){return[]},Te=function(e){return te.call(e)};function Be(e,t){return!!(t=null==t?o:t)&&(\"number\"==typeof e||V.test(e))&&e>-1&&e%1==0&&e<t}function Ne(e){var t=e&&e.constructor;return e===(\"function\"==typeof t&&t.prototype||K)}function Le(e){if(null!=e){try{return Z.call(e)}catch(e){}try{return e+\"\"}catch(e){}}return\"\"}function Ue(e,t){return e===t||e!=e&&t!=t}(pe&&Te(new pe(new ArrayBuffer(1)))!=_||ge&&Te(new ge)!=l||ve&&Te(ve.resolve())!=p||he&&Te(new he)!=v||we&&Te(new we)!=b)&&(Te=function(e){var t=te.call(e),n=t==f?e.constructor:void 0,r=n?Le(n):void 0;if(r)switch(r){case ye:return _;case _e:return l;case me:return p;case je:return v;case Oe:return b}return t});var De=Array.isArray;function qe(e){return null!=e&&function(e){return\"number\"==typeof e&&e>-1&&e%1==0&&e<=o}(e.length)&&!Ge(e)}var He=de||function(){return!1};function Ge(e){var t=Xe(e)?te.call(e):\"\";return t==c||t==u}function Xe(e){var t=typeof e;return!!e&&(\"object\"==t||\"function\"==t)}function We(e){return qe(e)?function(e,t){var n=De(e)||function(e){return function(e){return function(e){return!!e&&\"object\"==typeof e}(e)&&qe(e)}(e)&&ee.call(e,\"callee\")&&(!ce.call(e,\"callee\")||te.call(e)==i)}(e)?function(e,t){for(var n=-1,r=Array(e);++n<e;)r[n]=t(n);return r}(e.length,String):[],r=n.length,o=!!r;for(var a in e)!t&&!ee.call(e,a)||o&&(\"length\"==a||Be(a,r))||n.push(a);return n}(e):function(e){if(!Ne(e))return fe(e);var t=[];for(var n in Object(e))ee.call(e,n)&&\"constructor\"!=n&&t.push(n);return t}(e)}e.exports=function(e){return Ve(e,!0,!0)}}},t={};function n(r){var o=t[r];if(void 0!==o)return o.exports;var i=t[r]={id:r,loaded:!1,exports:{}};return e[r](i,i.exports,n),i.loaded=!0,i.exports}n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,{a:t}),t},n.d=function(e,t){for(var r in t)n.o(t,r)&&!n.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},n.g=function(){if(\"object\"==typeof globalThis)return globalThis;try{return this||new Function(\"return this\")()}catch(e){if(\"object\"==typeof window)return window}}(),n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.nmd=function(e){return e.paths=[],e.children||(e.children=[]),e};var r={};n.d(r,{S:function(){return A}});var o=n(330),i=n.n(o);const a=function(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:\"log\",n=arguments.length>2?arguments[2]:void 0;const{name:r,fColor:o,bColor:a}=e,s=`display: inline-block; color: ${o}; background: ${a}; padding: 1px 4px; border-radius: 3px;`,c=`%c${r}${n?\" \"+n:\"\"}`;for(var u=arguments.length,l=new Array(u>3?u-3:0),d=3;d<u;d++)l[d-3]=arguments[d];const f=(null!=l?l:[]).map((e=>i()(e)));\"table\"===t&&1===f.length?(console.log(c,s),console.table(f[0])):\"table\"===t&&2===f.length?(console.log(c,s,f[0]),console.table(f[1])):console[t](c,s,...f)},s=\"sznivadbg\",c=\"iva_dbg_event_\",u=function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:window;return!(e.top!==e.self&&!e.Cypress||e.frameElement)},l=()=>{var e;return null===(e=window.sznIVA)||void 0===e?void 0:e.debugger},d=e=>{window.sznIVA=window.sznIVA||{},window.sznIVA.debugger=Object.assign(Object.assign({},window.sznIVA.debugger),e)},f=e=>{const t=window.location.search||\"\",n=new RegExp(`${e}=([^&]*)`),r=t.match(n)||[];return r.length>1?r[1]:null},p=()=>{var e;const t=f(s);if(t)return t;const n=(()=>{var e;return null===(e=l())||void 0===e?void 0:e.topFrameRule})();if(n)return n;try{const t=(null===(e=window.localStorage)||void 0===e?void 0:e.getItem(s))||\"\";if(t)return t}catch(e){a(g(),\"warn\",void 0,JSON.stringify(e))}return\"\"};const g=()=>({name:\"debugger\",fColor:\"#AAA\",bColor:\"#777\"});(()=>{if(u())window.addEventListener(\"message\",(e=>(e=>{var t,n,r;try{if(\"function\"==typeof(null===(t=null==e?void 0:e.source)||void 0===t?void 0:t.postMessage)&&(null===(n=null==e?void 0:e.data)||void 0===n?void 0:n.type)===`${c}request_debug_settings`){const t=p();e.source.postMessage({type:`${c}debug_settings`,rule:t},{targetOrigin:\"*\"}),(null===(r=l())||void 0===r?void 0:r.iframeBridgeNotified)||(t&&a(g(),void 0,void 0,`Top frame sends a debugger rule \"${t}\" to iframes.`),d({iframeBridgeNotified:!0}))}}catch(e){a(g(),\"error\",void 0,`${e instanceof Error?e.message:\"An unknown error occurred in handlerFromChildMessage\"}`)}})(e)));else{window.addEventListener(\"message\",(e=>(e=>{e.data.type===`${c}debug_settings`&&d({topFrameRule:e.data.rule})})(e)));try{window.top.postMessage({type:`${c}request_debug_settings`},document.referrer||\"*\")}catch(e){a(g(),\"error\",void 0,`${e instanceof Error?e.message:\"An unknown error occurred during initIframeBridge\"}`)}}})();const v=\"sznIVA\",h=\"sBrowser\",w=(_={name:\"SbrwsrSid\",fColor:\"#399e5a\",bColor:\"#6ef9f5\"},(()=>{var e,t,n;const r=f(\"sznivadbgsave\");if(null===r)return;const o=null===(e=window.localStorage)||void 0===e?void 0:e.getItem(s);r===o||null===o&&\"\"===r||(\"\"===r?(null===(t=window.localStorage)||void 0===t||t.removeItem(s),a(g(),void 0,void 0,\"Rule was removed from the local storage.\")):(null===(n=window.localStorage)||void 0===n||n.setItem(s,null!=r?r:\"\"),a(g(),void 0,void 0,`Rule \"${r}\" was saved to the local storage.`)))})(),(_=Object.assign({fColor:\"white\",bColor:\"black\"},_))&&_.name&&_.fColor&&_.bColor?function(){const e=[\"log\",\"warn\",\"error\",\"info\",\"table\"];for(var t=arguments.length,n=new Array(t),r=0;r<t;r++)n[r]=arguments[r];const o=n.length,i=(e=>{var t;const n=p();return!(null===(t=l())||void 0===t?void 0:t.welcomeNotified)&&n&&u()&&(d({welcomeNotified:!0}),a(g(),\"log\",void 0,`===============================================\\n | 🕷 DEBUGGER is set to \"${n}\".\\n | Use \"1\" to let any component log or use component name[s] to filter them.\\n | Using \"!component\" lets log all components except those listed.\\n | Save the rule to local storage using GET parameter \"?sznivadbgsave=${n}\"\\n | and remove it by \"?sznivadbgsave=\".\\n \\`=======================================================`)),((e,t)=>!(!e||\"1\"!==e&&(~e.indexOf(\"!\")?~e.toLowerCase().indexOf(`!${t.toLowerCase()}`):!~e.toLowerCase().indexOf(t.toLowerCase()))))(n,e)})(_.name);if(!i||0===o)return i;if(1===o&&\"object\"==typeof n[0]&&!Array.isArray(n[0])&&null!==n[0]){const[e]=n,{state:t,type:r,subName:o,message:s}=e,u=function(e,t){var n={};for(var r in e)Object.prototype.hasOwnProperty.call(e,r)&&t.indexOf(r)<0&&(n[r]=e[r]);if(null!=e&&\"function\"==typeof Object.getOwnPropertySymbols){var o=0;for(r=Object.getOwnPropertySymbols(e);o<r.length;o++)t.indexOf(r[o])<0&&Object.prototype.propertyIsEnumerable.call(e,r[o])&&(n[r[o]]=e[r[o]])}return n}(e,[\"state\",\"type\",\"subName\",\"message\"]);if(i){const e=[];void 0!==s&&e.push(s),1===Object.values(u).length?e.push(u[Object.keys(u)[0]]):Object.values(u).length&&e.push(u),a(_,r,o,...e)}return t&&((e,t,n)=>{const{name:r}=e,o=`${c}${r}`,i=Object.assign({state:t},n);window.sznIVA=window.sznIVA||{},window.sznIVA[r]=window.sznIVA[r]||{},Object.assign(window.sznIVA[r],i);const a=new CustomEvent(o,{detail:i});window.dispatchEvent(a)})(_,t,u),i}return i&&1===o?(a(_,\"log\",void 0,n[0]),i):i&&2===o&&~e.indexOf(n[0])?(a(_,n[0],void 0,n[1]),i):i&&o>1&&!~e.indexOf(n[0])?(a(_,\"log\",void 0,...n),i):i&&o>2&&~e.indexOf(n[0])?(a(_,n[0],void 0,...n.slice(1)),i):(a(g(),\"warn\",void 0,\"Debugger received unknown argument combination. args:\",n),i)}:()=>!1),b=e=>{const t=e+\"=\",n=decodeURIComponent(document.cookie).split(\";\");for(let e=0;e<n.length;e++){let r=n[e];for(;\" \"===r.charAt(0);)r=r.substring(1);if(0===r.indexOf(t))return r.substring(t.length,r.length)}return\"\"},y=window.name;var _;let m=0;try{m=parseInt(window.localStorage.getItem(\"dot_lastSession\"),10)||0}catch{}const j=()=>{if(window.sznIVA&&window.sznIVA.IS){const e=window.sznIVA.IS.getIdentities({cacheEnough:!0,justSettled:!1},null,!1);return window.sznIVA.IS.prepareIdsForBe(e)}return{}},O=(e,t)=>{const n={action:e,androidSid:t,dsid:b(\"sid\")};if(!window.XMLHttpRequest)return;const r={action:\"event\",service:\"androidSidSync\",data:n,ptitle:document.title,url:document.location.href,ids:j(),id:y,lses:m,version:\"1.0\"},o=new XMLHttpRequest;let i=\"\";try{i=JSON.stringify(r)}catch{return}o.open(\"POST\",\"https://h.seznam.cz/hit\",!0),o.setRequestHeader(\"Content-Type\",\"application/json\"),o.setRequestHeader(\"X-Client-Id\",\"sbrowsersid-android\"),o.setRequestHeader(\"X-Client-Version\",\"1.0\"),o.withCredentials=!0,o.send(i)},S=/AppDataConsent:\\s*false/,A=e=>{if(~navigator.userAgent.indexOf(\"SznProhlizec\")){const t=(e=>t=>{if(O(\"syncCalled\",t),!t)return w(\"Sid not available\"),O(\"sidNotFound\",t),-1;if(S.test(t))return w('\"AppDataConset\" is set to false, ignoring the sid'),O(\"noConsent\",t),1;if(-1===t.indexOf(\"te=\"))return w(\"Sid not valid\"),O(\"invalidSid\",t),-1;try{return(()=>{const e=window.location.hostname.replace(/^www\\./,\"\");return\"seznam.cz\"===e||e.endsWith(\".seznam.cz\")})()?(O(\"syncCancelledOnSznDomain\",t),w({message:\"Not saving cookie on seznamm domain\",sid:t}),0):(((e,t)=>{const n=new Date;n.setTime(n.getTime()+2592e5);const r=`sid=${t}; domain=${location.hostname.split(\".\").slice(-2).join(\".\")}; path=/; expires=${n.toUTCString()}${\"https:\"===location.protocol?\"; secure\":\"\"}`;document.cookie=r})(0,t),window.localStorage&&localStorage.setItem(\"sid\",t),O(\"synced\",t),w({message:\"Sid cookie synchronised\",sid:t}),e?(e(t),0):0)}catch(e){return O(\"syncFailed\",t),w({type:\"error\",message:\"Failed to set cookie/localStorage\",sid:t,error:e}),1}})(e);window[v]=window[v]||{},window[v][h]=window[v][h]||{},window[v][h].handleSid=t,w({message:'\"handleSid\" deployed to IVA namesapce',namespace:window[v]});const{sbrowser:n}=window;if(\"function\"==typeof(null==n?void 0:n.getSid))return 0===t(n.getSid());try{window.webkit.messageHandlers.sidHandler.postMessage(\"getSid\"),w(\"postMessage sent to Sbrowser\")}catch(e){return w({type:\"error\",message:\"Failed to send postMessage to Sbrowser\",error:e}),!1}return!0}return!1};var I=r.S;export{I as handleSbrowserSid};","export const VERSION = require('../package.json').version;\n\nexport const PARAM_NAMES = {\n  SZNCLID: 'sznclid',\n  SZNAIID: 'sznaiid',\n  CONSENT: 'consent',\n  SZNTIME: 'szntime',\n};\n\nexport const COOKIE_NAMES = {\n  SID: 'sid',\n  SZNAIID: 'sznaiid',\n};\n\nexport const ACTIONS = {\n  SID: {\n    NOT_STORED: 'notstored',\n    SAME: 'same',\n    DIFFERENT: 'different',\n  },\n  SZNAIID: {\n    NOT_STORED: 'sznaiid_notstored',\n    SAME: 'sznaiid_same',\n    DIFFERENT: 'sznaiid_different',\n  },\n  NO_CONSENT: 'noconsent',\n};\n\nexport const EVENTS = {\n  SID_STORED: 'szn:linkdecoration:sid',\n  SZNAIID_STORED: 'szn:linkdecoration:sznaiid',\n};\n\nexport const HIT_TARGET = 'https://h.seznam.cz/hit';\nexport const HIT_ACTIONS = {\n  CMPONE: 'cmpone',\n  RCCONSENT: 'rcconsent',\n  IABCONSENT: 'iabconsent',\n};\n\nexport const DEBUG_CONFIG = {\n  bColor: '#4b0082',\n  fColor: '#fff',\n  name: 'linkdec',\n};\n\nexport const SCMP_SSP_INTERNAL = 'scmp_sspServerData';\nexport const SCMP_SSP_EVENT = 'cmpdatareceived';\n\n// How long to look for consent in ms\nexport const CONSENT_DETECTION_TIMEOUT = 5000;\nexport const CONSENT_DETECTION_INTERVAL = 1000;\nexport const CONSENT_BLACKLIST = ['echo24.cz'];\nexport const SID_BLACKLIST = ['echo24.cz'];\nexport const SZNTIME_VALIDITY_THRESHOLD = 30; // seconds\n","import { debugFactory } from '@iva/debugger';\nimport { DEBUG_CONFIG } from '../../config.js';\n\nconst debug = debugFactory(DEBUG_CONFIG);\n\nexport { debug };\n","import { CONSENT_DETECTION_TIMEOUT, CONSENT_DETECTION_INTERVAL, HIT_ACTIONS } from '../../config.js';\nimport { debug } from './debug.js';\nimport { CONSENT } from '@sklik/cmp2-common';\nimport { COOKIE } from '@iva/utils';\n\nexport const [RUN, DO_NOT_RUN, UNCERTAIN] = [1, 2, 3];\n\n/**\n * Read data from window and decides whether to run callback,\n * never run callback or if it cannot be decided yet\n * @return {Number}\n */\nexport const getShouldRunFromWindow = () => {\n  const cmpone = COOKIE.getCookie(CONSENT.CONSENT_PURPOSE_ONE_COOKIE_NAME);\n  if (cmpone) {\n    if (cmpone === '1') {\n      return { result: RUN, reason: HIT_ACTIONS.CMPONE };\n    } else if (cmpone === '0') {\n      return { result: DO_NOT_RUN, reason: HIT_ACTIONS.CMPONE };\n    }\n  } else if (window.rc && !window.rc.internal) {\n    if (window.rc.consent === 1) {\n      return { result: RUN, reason: HIT_ACTIONS.RCCONSENT };\n    } else if (window.rc.consent === 0) {\n      return { result: DO_NOT_RUN, reason: HIT_ACTIONS.RCCONSENT };\n    }\n  } else {\n    const consent = CONSENT.getConsentFromCookieList();\n    if (consent) {\n      return {\n        result: consent.purposeOne ? RUN : DO_NOT_RUN,\n        reason: HIT_ACTIONS.IABCONSENT,\n      };\n    }\n  }\n  return { result: UNCERTAIN };\n};\n\n/**\n * Wait for consent to store SID cookie. After timeout return that there is no.\n * @param {*} callback function with shouldRun argument\n * @param {number} customTimeout custom timeout of consent waiting in ms\n * @returns undefined\n */\nexport const detectShouldRun = (callback, consentTimeout) => {\n  let shouldRun = getShouldRunFromWindow();\n  // Run immediately\n  if (shouldRun.result !== UNCERTAIN) {\n    callback(shouldRun);\n    return;\n  }\n\n  let interval = null;\n  let iterationCount = 0;\n\n  const consentTimeoutOk = typeof consentTimeout === 'number' && consentTimeout >= 0;\n  const maxIterations = Math.ceil(\n    consentTimeoutOk\n      ? consentTimeout / CONSENT_DETECTION_INTERVAL\n      : CONSENT_DETECTION_TIMEOUT / CONSENT_DETECTION_INTERVAL\n  );\n\n  /**\n   * Clear interval and event listener, then execute callback\n   */\n  const clearAndRun = (_shouldRun) => {\n    clearInterval(interval);\n    interval = null;\n    callback(_shouldRun);\n  };\n\n  const periodicalCheck = () => {\n    shouldRun = getShouldRunFromWindow();\n    // Should run\n    if (shouldRun.result !== UNCERTAIN) {\n      clearAndRun(shouldRun);\n      return;\n    }\n\n    // Keep checking\n    iterationCount++;\n\n    // 5s have elapsed, stop checking\n    if (iterationCount >= maxIterations) {\n      clearAndRun({ result: DO_NOT_RUN });\n      debug('giving up');\n      return;\n    }\n    debug(\"unsure whether to run, I'll keep trying\");\n  };\n\n  // Check periodically\n  interval = setInterval(periodicalCheck, CONSENT_DETECTION_INTERVAL);\n\n  // wait for rc event\n  const handleRCEvent = (e) => {\n    if (e.detail && e.detail.consent) {\n      clearAndRun({ result: RUN, reason: HIT_ACTIONS.RCCONSENT });\n    }\n\n    window.removeEventListener('szn:rc:setconsentvalue', handleRCEvent);\n  };\n\n  window.addEventListener('szn:rc:setconsentvalue', handleRCEvent);\n};\n","import { xorCrypt } from './xorCrypt.js';\nimport { debug } from './debug.js';\nimport { isValid } from '../sid.js';\n\n/**\n * Decodes encoded SID.\n * @param {String} sznclid - Value of \"sznclid\" UTM parameter.\n */\nconst decodeClid = (sznclid) => {\n  const count = Math.ceil(sznclid.length / 4) * 4;\n  const padded = sznclid.padEnd(count, '=');\n  try {\n    const decoded = atob(padded.replace(/_/g, '/').replace(/-/g, '+'));\n\n    // first char is key use it in xorCrypt\n    const sid = xorCrypt(decoded.substring(1), decoded.charCodeAt(0));\n\n    if (isValid(sid)) {\n      // got valid sid - return it\n      return sid;\n    }\n\n    // did not get valid sid\n    debug('warn', `\"decodeClid\" - SID ${sznclid} did not pass validation, returning null`);\n    return null;\n  } catch (e) {\n    debug('error', `\"decodeClid\" - SID ${sznclid} threw error during validation. ${e}`);\n    return null;\n  }\n};\n\nexport { decodeClid };\n","/**\n * String xor crypt.\n * @param {String} str - String to decrypt.\n * @param {*} key - Key necessary for decrypting.\n */\nconst xorCrypt = (str, key) => {\n  const chars = str.split('');\n  const decodedChars = chars.map((char) => String.fromCharCode(key ^ char.charCodeAt()));\n\n  return decodedChars.join('');\n};\n\nexport { xorCrypt };\n","import { URL } from '@iva/utils';\n\n/**\n * Removes \"param\" from URL.\n */\nexport const clearURL = (paramName) =>\n  window.history.replaceState(null, document.title, URL.removeParam(window.location.href, paramName));\n\n/**\n * Retrieves parameter value and removes it from URL.\n * @param {String} url URL from which to retrieve sznclid.\n * @param {*} paramName - Name (key) of param to get.\n * @return {String | null} param value or null, if none has been found.\n */\nconst cutParamFromUrl = (url, paramName) => {\n  const queryString = url.includes('?') ? url.split('?')[1] : '';\n  const hash = !queryString && url.includes('#') ? url.split('#')[1] : '';\n\n  // queryString includes hash, if no queryString, use hash\n  const source = queryString || hash;\n\n  if (!source.includes(paramName)) {\n    return null;\n  }\n\n  clearURL(paramName);\n\n  const regex = new RegExp(`(?:^|[&#])${paramName}=([^&#]+)`);\n  const result = regex.exec(source);\n\n  if (result && result.length > 0) {\n    return result[1];\n  }\n  return null;\n};\n\nexport { cutParamFromUrl };\n","import { HIT_TARGET, VERSION } from '../../config.js';\n// Utils\nimport { debug } from './debug.js';\n\nlet dotInstance = null;\n\nconst service = 'idt';\nconst dotConfig = {\n  service,\n  load: false,\n  mousedown: false,\n  impress: false,\n};\n\n/**\n * Configures dotInstance when window.DOT.getNewInstance is available\n */\nconst configureDot = () => {\n  if (window.DOT && window.DOT.getNewInstance) {\n    dotInstance = window.DOT.getNewInstance();\n    dotInstance.cfg(dotConfig);\n    debug('DOT instance configured');\n  }\n};\n\n/**\n * Gets identity object\n * @returns identity object\n */\nconst getIdentityObject = () => {\n  if (window.sznIVA && window.sznIVA.IS) {\n    const ids = window.sznIVA.IS.getIdentities({ cacheEnough: true, justSettled: false }, null, false);\n    return window.sznIVA.IS.prepareIdsForBe(ids);\n  }\n\n  return {};\n};\n\n/**\n * Send a specific POST hit request.\n * @param {String} action - Action that is being logged.\n * @param {object} customData - data that will be added into hit data.\n * @param {boolean} consent has/doesn't have consent\n */\nconst sendHit = (action, customData, consent = null) => {\n  // prepare hit data\n  let hitData = { action };\n\n  if (consent !== null) {\n    hitData.hasConsent = consent.toString();\n  }\n\n  if (customData) {\n    hitData = {\n      ...hitData,\n      ...customData,\n    };\n  }\n\n  // try to config DOT\n  if (!dotInstance) {\n    configureDot();\n  }\n\n  // DOT instance created, send hit\n  if (dotInstance) {\n    dotInstance.hit('event', hitData);\n    debug('Hit was sent via dot instance - ', action);\n    return;\n  }\n\n  if (!window.XMLHttpRequest) {\n    return;\n  }\n\n  // creating hit manually\n  const ids = getIdentityObject();\n  const hit = {\n    action: 'event',\n    service,\n    data: hitData,\n    ptitle: document.title,\n    url: document.location.href,\n    ids,\n    version: '1.0',\n  };\n  const sender = 'linkdecoration';\n  const senderVersion = VERSION || 'undefined';\n\n  const xhr = new XMLHttpRequest();\n\n  let body = '';\n\n  try {\n    body = JSON.stringify(hit);\n  } catch {\n    return;\n  }\n\n  // Request preparation (method, url, asyncFlag).\n  xhr.open('POST', HIT_TARGET, true);\n\n  // Send the proper header information along with the request\n  xhr.setRequestHeader('Content-Type', 'application/json');\n\n  // Sender (Linkdecoration) information\n  xhr.setRequestHeader('X-Client-Id', sender);\n  xhr.setRequestHeader('X-Client-Version', senderVersion);\n\n  // Required to send with cookies.\n  xhr.withCredentials = true;\n\n  // Send request\n  xhr.send(body);\n  debug('Hit was manually sent - ', action);\n};\n\nexport { sendHit };\n","const getConsentDate = () => {\n  const d = new Date();\n  d.setMonth(d.getMonth() + 13);\n  d.setDate(d.getDate() - 1);\n  return d.toUTCString();\n};\n\nconst getSidDate = () => {\n  const d = new Date();\n  d.setMonth(d.getMonth() + 1);\n  return d.toUTCString();\n};\n\nconst getSznaiidDate = () => {\n  const d = new Date();\n  d.setMonth(d.getMonth() + 1);\n  return d.toUTCString();\n};\n\nconst commonCookieOptions = {\n  domain: '.' + location.hostname.split('.').slice(-2).join('.'),\n  secure: location.protocol === 'https:',\n  path: '/',\n};\n\nexport const getConsentCookieOptions = () => ({\n  ...commonCookieOptions,\n  expires: getConsentDate(),\n});\n\nexport const getSidCookieOptions = () => ({\n  ...commonCookieOptions,\n  expires: getSidDate(),\n});\n\nexport const getSznaiidCookieOptions = () => ({\n  ...commonCookieOptions,\n  expires: getSznaiidDate(),\n});\n","// Modules\nimport { decodeClid } from './utils/decodeClid.js';\nimport { cutParamFromUrl } from './utils/cutParamFromUrl.js';\nimport { sendHit } from './utils/sendHit.js';\nimport { getSidCookieOptions } from './utils/cookieUtils.js';\n\n// Utils\nimport { debug } from './utils/debug.js';\nimport { COOKIE, URL } from '@iva/utils';\n\n// Constants\nimport { ACTIONS, EVENTS, COOKIE_NAMES, PARAM_NAMES, SID_BLACKLIST } from '../config.js';\n\nexport const handleMissingSid = (sid) => {\n  debug(`did not find SID cookie, creating new`);\n  COOKIE.setCookie(COOKIE_NAMES.SID, sid, getSidCookieOptions());\n  if (window.sznIVA && window.sznIVA.IS) {\n    window.sznIVA.IS.updateIdentities({ sid });\n  }\n  window.dispatchEvent(new CustomEvent(EVENTS.SID_STORED, { detail: sid }));\n};\n\n/**\n * Matches SID with cookie and sends hit with action and returns action type as a string.\n * @param {String} sid - User's ID.\n * @return {('notstored' | 'same' | 'different')} Action based on context in browser.\n */\nexport const storeSid = (sid, reason) => {\n  // get actual sid\n  const localSidCookie = COOKIE.getCookie(COOKIE_NAMES.SID);\n\n  if (!localSidCookie) {\n    // not stored sid, only linkdecoration SAVING COOKIE\n    // eslint-disable-next-line camelcase\n    sendHit(ACTIONS.SID.NOT_STORED, { reason, ld_sid: sid }, true);\n    handleMissingSid(sid);\n    return ACTIONS.SID.NOT_STORED;\n  }\n  if (localSidCookie === sid) {\n    // both are same\n    debug('found SID cookie with the same SID value');\n    sendHit(ACTIONS.SID.SAME);\n    return ACTIONS.SID.SAME;\n  }\n  debug('found SID cookie with different value from linkdec SID');\n  // eslint-disable-next-line camelcase\n  sendHit(ACTIONS.SID.DIFFERENT, { ld_sid: localSidCookie });\n  return ACTIONS.SID.DIFFERENT;\n};\n\n/**\n * Attempts to retrieve SID from UTM.\n * @return {String | null} SID or null if fail to parse or no sznclid in URL.\n */\nexport const getSid = () => {\n  debug({\n    message: 'getting SID',\n    state: 'running',\n    sid: {\n      state: 'start',\n    },\n  });\n\n  const sznclid = cutParamFromUrl(window.location.href, PARAM_NAMES.SZNCLID);\n\n  // blacklist\n  const domain = URL.getDomainLevel(undefined, undefined, false);\n  if (SID_BLACKLIST.includes(domain)) {\n    debug(`SID handler stoped, domain \"${domain}\" is blacklisted.`);\n    return null;\n  }\n\n  if (!sznclid) {\n    debug({\n      state: 'running',\n      message: 'did not find sznclid in url',\n      sid: {\n        state: 'done',\n        error: 'no sznclid in URL',\n        sznclid,\n      },\n    });\n    return null;\n  }\n\n  debug(`found parameter \"${PARAM_NAMES.SZNCLID}\", decoding...`);\n  const sid = decodeClid(sznclid);\n  if (sid) {\n    debug({\n      state: 'running',\n      message: 'successfully retrieved \"sid\"',\n      sid: {\n        state: 'done',\n        sid,\n      },\n    });\n    return sid;\n  }\n\n  debug({\n    state: 'running',\n    message: 'sznclid is invalid - could not be decoded',\n    sid: {\n      state: 'error',\n      sid,\n      sznclid,\n      error: 'failed to decode sznclid',\n    },\n  });\n  return null;\n};\n\n/**\n * Validates SID.\n * @param {String} sid - SID to be validated.\n * @return {Boolean} True if valid, false otherwise.\n */\nexport const isValid = (sid) => {\n  // SID format described here:\n  // https://gitlab.seznam.net/datacollect/datacollect-nginx-modules/-/tree/master/ap_mod#sid-cookie-format\n  const regex = /^id=[0-9]+\\|t=[0-9]+.[0-9]+\\|te=[0-9]+.[0-9]+(\\|opt-out=True)?\\|c=[0-9A-Z]+$/;\n\n  try {\n    const res = regex.test(sid);\n    return res;\n  } catch {\n    return false;\n  }\n};\n","// Methods\nimport { cutParamFromUrl } from './utils/cutParamFromUrl';\nimport { getSznaiidCookieOptions } from './utils/cookieUtils';\nimport { sendHit } from './utils/sendHit';\n\n// Utils\nimport { debug } from './utils/debug.js';\nimport { COOKIE } from '@iva/utils';\n\n// Constants\nimport { COOKIE_NAMES, PARAM_NAMES, ACTIONS, EVENTS } from '../config.js';\n\n/**\n * Attempts to retrieve SZNAIID from URL.\n * @return {String | null} SZNAIID or null if no sznaiid in URL.\n */\nexport const getSznaiid = () => {\n  debug({\n    message: 'getting SZNAIID',\n    state: 'running',\n    sznaiid: {\n      state: 'start',\n    },\n  });\n\n  const sznaiid = cutParamFromUrl(window.location.href, PARAM_NAMES.SZNAIID);\n\n  if (!sznaiid) {\n    debug({\n      state: 'running',\n      message: 'did not find sznaiid in url',\n      sznaiid: {\n        state: 'done',\n        error: 'no sznaiid in URL',\n        sznaiid,\n      },\n    });\n    return null;\n  }\n\n  debug({\n    state: 'running',\n    message: 'successfully retrieved \"sznaiid\"',\n    sznaiid: {\n      state: 'done',\n      sznaiid,\n    },\n  });\n  return sznaiid;\n};\n\n/**\n * Stores SZNAIID cookie\n * @param {String} sznaiid value from URL\n * @return {('sznaiid_notstored' | 'sznaiid_same' | 'sznaiid_different')} Action based on context in browser.\n */\nexport const storeSznaiid = (sznaiid, reason) => {\n  let action = '';\n\n  // get actual sznaiid\n  const localSznaiidCookie = COOKIE.getCookie(COOKIE_NAMES.SZNAIID);\n\n  if (!localSznaiidCookie) {\n    debug('did not find SZNAIID cookie, creating new');\n    sendHit(ACTIONS.SZNAIID.NOT_STORED);\n    action = ACTIONS.SZNAIID.NOT_STORED;\n  } else if (localSznaiidCookie === sznaiid) {\n    debug('found SZNAIID cookie with same SZNAIID value, refreshing expiration date of cookie');\n    sendHit(ACTIONS.SZNAIID.SAME);\n    action = ACTIONS.SZNAIID.SAME;\n  } else {\n    debug('found SZNAIID cookie with different SZNAIID value, overwriting cookie');\n    sendHit(ACTIONS.SZNAIID.DIFFERENT);\n    action = ACTIONS.SZNAIID.DIFFERENT;\n  }\n\n  COOKIE.setCookie(COOKIE_NAMES.SZNAIID, sznaiid, getSznaiidCookieOptions());\n  sendHit(reason, { sznaiid }, true);\n  window.dispatchEvent(new CustomEvent(EVENTS.SZNAIID_STORED, { detail: sznaiid }));\n\n  return action;\n};\n","import { CONSENT } from '@sklik/cmp2-common';\nimport { COOKIE, URL } from '@iva/utils';\nimport { cutParamFromUrl } from './utils/cutParamFromUrl.js';\nimport { debug } from './utils/debug.js';\nimport { getConsentCookieOptions } from './utils/cookieUtils.js';\nimport {\n  CONSENT_BLACKLIST,\n  CONSENT_DETECTION_TIMEOUT,\n  PARAM_NAMES,\n  SCMP_SSP_EVENT,\n  SCMP_SSP_INTERNAL,\n} from '../config.js';\n\n/**\n * Saves consent for future use.\n * @param {String} consent - User's consent.\n */\nconst storeConsent = (value) => COOKIE.setCookie(CONSENT.CONSENT_COOKIE_NAME, value, getConsentCookieOptions());\n\n/**\n * Returns whether consent should be stored or not.\n * @param {Object} cmpDataObject Object stored by SSP.\n * @return {Boolean}\n */\nconst shouldStore = (cmpDataObject) => {\n  if (!cmpDataObject || typeof cmpDataObject !== 'object') {\n    return false;\n  }\n  if (cmpDataObject.startDate && cmpDataObject.showDialog) {\n    return true;\n  }\n  return false;\n};\n\n/**\n * Retrieves consent from URL and then stores it, if the website wants it.\n * @param {*} url - window.location.href\n */\nexport const handleConsent = (url) => {\n  const consent = cutParamFromUrl(url, PARAM_NAMES.CONSENT);\n\n  // blacklist\n  const domain = URL.getDomainLevel(undefined, undefined, false);\n  if (CONSENT_BLACKLIST.includes(domain)) {\n    debug(`consent handler stoped, domain \"${domain}\" is blacklisted.`);\n    return;\n  }\n\n  if (!consent) {\n    debug({ message: 'did not get consent, or invalid consent (from url)', consent });\n    return;\n  }\n\n  debug({ message: 'got consent from url, waiting for approval to store', consent });\n\n  if (shouldStore(window[SCMP_SSP_INTERNAL])) {\n    debug('Received approval to store synchronously, storing consent');\n    storeConsent(consent);\n\n    // all done, return\n    return;\n  }\n\n  const callback = (e) => {\n    if (!e.detail) {\n      debug('warn', `Received \"${SCMP_SSP_EVENT}\" event without any data`);\n      return;\n    }\n    if (shouldStore(e.detail)) {\n      debug('Received approval from event, storing consent');\n      storeConsent(consent);\n    } else {\n      debug('This website does not want our consent, NOT storing');\n    }\n    window.removeEventListener(SCMP_SSP_EVENT, callback);\n  };\n\n  window.addEventListener(SCMP_SSP_EVENT, callback);\n  setTimeout(() => window.removeEventListener(SCMP_SSP_EVENT, callback), CONSENT_DETECTION_TIMEOUT);\n};\n","// Modules\nimport { detectShouldRun, RUN } from './modules/utils/detectShouldRun.js';\nimport { getSid, storeSid } from './modules/sid.js';\nimport { getSznaiid, storeSznaiid } from './modules/sznaiid.js';\nimport { getSzntime, isSzntimeValid } from './modules/szntime.js';\nimport { handleConsent } from './modules/consent.js';\n\n// Utils\nimport { debug } from './modules/utils/debug.js';\n\n// Constants\nimport { ACTIONS, DEBUG_CONFIG } from './config.js';\n\n/**\n * Initialize debug object\n */\nconst start = () =>\n  debug({\n    message: 'starting',\n    state: 'start',\n  });\n\n/**\n * Sets state to 'done'\n */\nconst finish = () =>\n  debug({\n    message: 'finishing',\n    state: 'done',\n  });\n\n/**\n * Retrieves and stores SID\n * Retrieves and stores consent\n * Retrieves and stores SZNAIID\n * and detects whether the library should run or not and acts in accordance.\n */\nconst runLinkdecoration = (handleCallback, consentTimeout) => {\n  if (window.sznIVA && window.sznIVA[DEBUG_CONFIG.name]) {\n    debug('duplicate execution - terminating');\n    return;\n  }\n\n  start();\n\n  // SID\n  const sid = getSid();\n  // SZNAIID\n  const sznaiid = getSznaiid();\n  // SZNTIME\n  const szntime = getSzntime();\n\n  // Szntime is optional:\n  // - if not present, do not affect storing sznclid (SID)\n  // - if present, check validity (delta time < threshold) and then decide if to save sznclid (SID) or not\n  if (!szntime) {\n    debug('szntime is empty or zero');\n  } else if (!isSzntimeValid(szntime)) {\n    debug('szntime not valid - finishing');\n    finish();\n    return;\n  }\n\n  // Consent\n  handleConsent(window.location.href);\n\n  if (!sid && !sznaiid) {\n    debug('nothing to do - finishing');\n    finish();\n    return;\n  }\n\n  detectShouldRun((shouldRun) => {\n    let action = null;\n    if (shouldRun.result === RUN) {\n      const results = [];\n\n      if (sid) {\n        results.push(storeSid(sid, shouldRun.reason));\n      }\n\n      if (sznaiid) {\n        results.push(storeSznaiid(sznaiid, shouldRun.reason));\n      }\n\n      action = results.join('|');\n    } else {\n      action = ACTIONS.NO_CONSENT;\n    }\n\n    if (typeof handleCallback === 'function') {\n      handleCallback(action);\n    }\n  }, consentTimeout);\n\n  finish();\n};\n\nexport { getSid, runLinkdecoration };\n","// Methods\nimport { cutParamFromUrl } from './utils/cutParamFromUrl';\n\n// Utils\nimport { debug } from './utils/debug.js';\n\n// Constants\nimport { PARAM_NAMES, SZNTIME_VALIDITY_THRESHOLD } from '../config.js';\n\n/**\n * Attempts to retrieve SZNTIME from URL.\n * @return {Number | null} SZNTIME or null if no szntime in URL.\n */\nexport const getSzntime = () => {\n  debug({\n    message: 'getting SZNTIME',\n    state: 'running',\n    szntime: {\n      state: 'start',\n    },\n  });\n\n  const szntime = cutParamFromUrl(window.location.href, PARAM_NAMES.SZNTIME);\n\n  if (!szntime) {\n    debug({\n      state: 'running',\n      message: 'did not find szntime in url',\n      szntime: {\n        state: 'done',\n        error: 'no szntime in URL',\n        szntime,\n      },\n    });\n    return null;\n  }\n\n  debug({\n    state: 'running',\n    message: 'successfully retrieved \"szntime\"',\n    szntime: {\n      state: 'done',\n      szntime,\n    },\n  });\n  return Number(szntime);\n};\n\n/**\n * Check whether given SZNTIME is still fresh (CURRENT_TIME - SZNTIME < THRESHOLD)\n * @param szntime {Number | null} SZNTIME\n */\nexport const isSzntimeValid = (szntime) => {\n  const currTime = Date.now() / 1000;\n  const diff = Math.abs(szntime - currTime);\n\n  if (diff >= SZNTIME_VALIDITY_THRESHOLD) {\n    debug({\n      state: 'running',\n      message: `szntime threshold exceeded: ${diff}`,\n      szntime: {\n        state: 'done',\n        error: `szntime threshold exceeded: ${diff}`,\n        szntime,\n      },\n    });\n    return false;\n  }\n\n  debug({\n    state: 'running',\n    message: 'szntime threshold within limit',\n    szntime: {\n      state: 'done',\n      szntime,\n    },\n  });\n  return true;\n};\n","// Types\nimport { DOT } from '../../classes/dot.class';\nimport { HandleSidOutput } from '../../types/common';\n// Methods\nimport { getSidCookie, setCookieAndReport } from '../utils/cookie/cookie';\nimport { getZnStringFromLocationSearch, getParameterFromURLQuery } from '../utils/general/url';\nimport { isSbrowser } from '../utils/general/browser';\nimport { shouldUseRedirect } from '../redirect/redirect';\nimport { shouldDisableCookieRefresh, createCookieRequest, hasAlreadySetSid, saveSidIntoBrowser } from './sid';\nimport { setToLocalStorage } from '../utils/storage/storage';\nimport { updateSidIdentity } from '../identityObject/identityObject';\nimport { CONSENT, SID_STORE_CHECK } from '@sklik/cmp2-common';\n// IVA libraries\nimport { handleSbrowserSid } from '@iva/sbrowser-sid';\nimport { runLinkdecoration } from '@iva/linkdecoration';\nimport { SID_UTILS } from '@iva/utils';\n\n/**\n * Tries to synchronise SID cookie in Sbrowser\n * @param sid cookie value\n */\nexport const _handleSbrowserPostmessage = (dot: DOT, sid?: string): HandleSidOutput => {\n  if (!sid) {\n    dot.log('Sbrowser: Sid not available');\n    return -1;\n  }\n\n  const APP_DATA_CONSENT_REGEX = /AppDataConsent:\\s*false/;\n  if (APP_DATA_CONSENT_REGEX.test(sid)) {\n    dot.log('Sbrowser: \"AppDataConset\" is set to false, ignoring the sid');\n    return 1;\n  }\n\n  if (!sid.includes('te=')) {\n    dot.log('Sbrowser: Sid not valid');\n    return -1;\n  }\n\n  try {\n    SID_STORE_CHECK.sidLegalStoreCheck(() => {\n      setToLocalStorage('sid', sid);\n      updateSidIdentity(sid);\n      setCookieAndReport({\n        name: 'sid',\n        value: sid,\n        expires: [3, 'days'],\n      });\n    });\n  } catch {\n    return 1;\n  }\n\n  dot.log('Sbrowser: SID cookie synchronised');\n  dot.log(`Sbrowser: show sid: ${sid}`);\n  return 0;\n};\n\n/**\n * Synces sid cookie to local domain\n * @param dot DOT instance\n */\nexport const syncSid = (dot: DOT): void => {\n  if (dot.synced || window?.DOT?.synced) {\n    // main DOT already synced sid, no need to do it again\n    dot.log(`SID is already synced`);\n    dot.cookieRequestDone = true;\n    return;\n  }\n\n  dot.synced = true;\n\n  let sbrowserSyncCalled = false;\n  if (isSbrowser()) {\n    dot._handleSid = (sid?: string): void => {\n      _handleSbrowserPostmessage(dot, sid);\n    };\n\n    if (handleSbrowserSid()) {\n      sbrowserSyncCalled = true;\n    }\n  }\n\n  // call linkdecoration\n  runLinkdecoration(null, 30000);\n\n  // cut sid from redirect back url if exists\n  const znstring = getZnStringFromLocationSearch(dot);\n\n  if (hasAlreadySetSid()) {\n    // LINKDECORATION\n    dot.log('linkdecoration has already set SID cookie');\n    dot.log('saving SID from cookie to localstorage');\n    setToLocalStorage('sid', getSidCookie());\n    dot.cookieRequestDone = true;\n  } else if (znstring) {\n    // CMP REDIRECT\n    const sidValue = SID_UTILS.hashToSid(znstring);\n\n    if (!sidValue) {\n      dot.log(`Unable to get sid from znstring - invalid hash: ${znstring}`);\n      dot.cookieRequestDone = true;\n      return;\n    }\n    dot.log(`Unhashed sid from redirect: ${sidValue}`);\n\n    const tcParameter = getParameterFromURLQuery('_tc');\n    const tcString = tcParameter ? decodeURIComponent(window.atob(tcParameter)) : null;\n\n    dot.cookieRequestDone = true;\n\n    if (CONSENT.hasPurposeOne(tcString) || CONSENT.hasPurposeOneFromCookieList()) {\n      dot.log(`SID from redirect taken: ${sidValue}`);\n      try {\n        saveSidIntoBrowser(dot, sidValue);\n      } catch {\n        // no op\n        return;\n      }\n    }\n  } else if (sbrowserSyncCalled || shouldUseRedirect()) {\n    // SBROWSER OR SHOULD REDIRECT\n    dot.cookieRequestDone = true;\n    dot.log('sync already called by Sbrowser OR redirect should sync sid');\n  } else {\n    if (shouldDisableCookieRefresh(dot._cfg.serverSideRefresher)) {\n      // SERVERSIDE REFRESHER\n      dot.log('disabling cookie refresher');\n      if (document?.body) {\n        document.body.setAttribute('data-dot-cookie-refresh-disabled', '');\n      }\n      dot.cookieRequestDone = true;\n    } else {\n      // COOKIE REQUEST\n      dot.log('creating SID cookie request');\n      createCookieRequest(dot);\n    }\n  }\n};\n\nexport default { syncSid };\n","// Types\nimport { DOT } from '../../classes/dot.class';\nimport { NullableString } from '../../types/common';\n// Methods\nimport { getSid, runLinkdecoration } from '@iva/linkdecoration';\n\n/**\n * Adds linkdecoration API to DOT instance\n * @param dot DOT instance\n */\nexport const addLinkdecoration = (dot: DOT): void => {\n  dot.handleSid = runLinkdecoration; // backward compatibility\n  dot.runLinkdecoration = runLinkdecoration;\n\n  dot.getSid = (): NullableString => {\n    return getSid();\n  };\n};\n\n// API\nexport default { addLinkdecoration };\n","export const COOKIE = {\n    NAME: 'udid',\n    INTERVAL_24: 24 * 60 * 60 * 1000, // 24 hodin\n    EXPIRACY_DAYS: 30,\n    REFRESH_DAYS: 20,\n};\nexport const RANDOM_ID_LENGTH = 32;\nexport const DEBUG_CONFIG = {\n    name: 'MRKR',\n    bColor: '#e6b800',\n    fColor: '#fff',\n};\nexport const STATES = {\n    START: 'start',\n    DONE: 'done',\n    ERROR: 'error',\n};\nexport const EVENT_NAME = 'szn:marker:cookie';\n","import { DEBUG_CONFIG } from '../config.js';\nimport { debugFactory } from '@iva/debugger';\n// Use the parameter ?sznivadbg=1 for debugging\nconst debug = debugFactory(DEBUG_CONFIG);\nexport { debug };\n","import { COOKIE, EVENT_NAME } from '../config.js';\nimport { debug } from './debug.js';\nimport { SID_STORE_CHECK as STORE_CHECK } from '@sklik/cmp2-common';\nimport { COOKIE as COOKIE_UTILS } from '@iva/utils';\n/**\n * Returns the domain name that will be set in the cookie.\n * @return {String} Domain name.\n */\nconst getDomain = () => {\n    const isTld = (hostname) => !hostname.includes('.');\n    const { hostname } = window.location;\n    return (isTld(hostname) ? '' : '.') + hostname.split('.').slice(-2).join('.');\n};\n/**\n * Sets cookie with the given value.\n * @param {String} value - Value to be saved into the cookie.\n */\nexport const setCookie = (value) => {\n    // store as 1st party cookie\n    const date = new Date();\n    date.setTime(date.getTime() + COOKIE.EXPIRACY_DAYS * COOKIE.INTERVAL_24);\n    const domain = getDomain();\n    const secure = window.location.protocol === 'https:';\n    COOKIE_UTILS.setCookie(COOKIE.NAME, value, {\n        path: '/',\n        domain,\n        secure,\n        expires: date.toUTCString(),\n    });\n};\n/**\n * Sets udid cookie with the given value + report by CustomEvent\n */\nconst setUdidAndDispatchEvent = (value) => {\n    setCookie(value);\n    if (window.sznIVA?.IS) {\n        window.sznIVA.IS.updateIdentities({ udid: value });\n    }\n    window.dispatchEvent(new CustomEvent(EVENT_NAME, { detail: value }));\n    debug({ message: 'Final mark has been saved into browser.' });\n};\n/**\n * Sets udid cookie and reports\n * Before storing it checks if it's legal when forceCookie is false\n */\nexport const setUdidCookieAndReport = (value, forceCookie) => {\n    if (!value) {\n        debug({ message: 'Final mark was not saved - missing value.' });\n        return Promise.resolve();\n    }\n    // check if cookie creation should be forced\n    if (forceCookie) {\n        setUdidAndDispatchEvent(value);\n        return Promise.resolve();\n    }\n    return new Promise((resolve) => {\n        // check if cookie can be legally stored before saving\n        STORE_CHECK.sidLegalStoreCheck(() => {\n            setUdidAndDispatchEvent(value);\n            resolve();\n        }, () => {\n            debug({ message: 'Final mark was not saved - missing consent.' });\n            resolve();\n        });\n    });\n};\n","const udidEndpoint = 'https://h.seznam.cz/udid';\nexport function fetchUdid(markerCookie) {\n    return new Promise(async (resolve, reject) => {\n        let payload = '';\n        try {\n            payload = JSON.stringify({\n                // random hex string of 32 characters\n                // eslint-disable-next-line camelcase\n                request_id: crypto\n                    .getRandomValues(new Uint8Array(16))\n                    .reduce((acc, val) => acc + val.toString(16).padStart(2, '0'), ''),\n                // old udid\n                ...(markerCookie && { udid: markerCookie }),\n            });\n        }\n        catch (e) {\n            reject(e);\n            return;\n        }\n        if (typeof fetch !== 'undefined') {\n            const response = await fetch(udidEndpoint, {\n                method: 'POST',\n                headers: {\n                    'Content-Type': 'application/json',\n                },\n                body: payload,\n                credentials: 'include',\n            });\n            if (!response.ok) {\n                reject(new Error('Network response was not ok'));\n                return;\n            }\n            response\n                .json()\n                .then((res) => (!!res.udid ? resolve(res.udid) : reject('Empty udid identifier')))\n                .catch(reject);\n        }\n        else {\n            // @ts-ignore it is test\n            const xhr = new XMLHttpRequest();\n            xhr.open('POST', udidEndpoint, true);\n            xhr.setRequestHeader('Content-Type', 'application/json');\n            xhr.withCredentials = true;\n            xhr.onreadystatechange = function () {\n                if (xhr.readyState === 4) {\n                    if (xhr.status >= 200 && xhr.status < 300) {\n                        try {\n                            const response = JSON.parse(xhr.responseText);\n                            if (response.udid) {\n                                resolve(response.udid);\n                            }\n                            else {\n                                reject(new Error('Empty udid identifier'));\n                            }\n                        }\n                        catch (e) {\n                            reject(e);\n                        }\n                    }\n                    else {\n                        reject(new Error('Network response was not ok'));\n                    }\n                }\n            };\n            xhr.onerror = function () {\n                reject(new Error('Network request failed'));\n            };\n            xhr.send(payload);\n        }\n    });\n}\n","import { COOKIE, STATES } from './config.js';\nimport { setUdidCookieAndReport } from './modules/cookie.js';\nimport { debug } from './modules/debug.js';\nimport { fetchUdid } from './modules/requests.js';\nimport { COOKIE as COOKIE_UTILS } from '@iva/utils';\n/**\n * Fetch and saving a cookie `udid` (unique domain identifier), if cookie is not present\n */\nexport const marker = async (forceCookie = false) => {\n    let markerCookie = COOKIE_UTILS.getCookie(COOKIE.NAME);\n    debug({ message: `Checking currently stored cookies: \"${markerCookie}\"`, state: STATES.START });\n    if (!markerCookie) {\n        markerCookie = await fetchUdid().catch((error) => {\n            debug({ message: `Error during fetching udid: ${error}`, state: STATES.ERROR });\n            return '';\n        });\n        debug({ message: `Final mark to be saved into cookie: \"udid=${markerCookie}\"` });\n        await setUdidCookieAndReport(markerCookie, forceCookie);\n    }\n    debug({ message: 'Marker is finished', state: STATES.DONE });\n};\n/**\n * Generating and saving a cookie `udid` (unique domain identifier) without consent check\n * Relies on fact, that consent exists during function call\n */\nexport const markerForceCookie = async () => {\n    debug({ message: 'Force creating mark.' });\n    await marker(true);\n};\n","// Types\nimport { DOT } from '../../classes/dot.class';\n// Methods\nimport { sendPostponedHits } from '../postponedHitting/postponedHitting';\n// Constants\nimport { UDID_REQUEST_TIMEOUT } from '../../constants/index';\n// IVA Libs\nimport { marker } from '@iva/marker';\n\nlet markerCalled = false;\n\nexport const resetMarkerCalled = () => {\n  markerCalled = false;\n};\n\nexport const runMarker = (dot: DOT) => {\n  if (markerCalled) {\n    dot.log('marker already called');\n    dot.udidRequestDone = true;\n    return;\n  }\n\n  markerCalled = true;\n  dot.log('calling marker');\n\n  const done = () => {\n    dot.udidRequestDone = true;\n    sendPostponedHits(dot);\n  };\n\n  const timeout = setTimeout(() => {\n    done();\n    dot.log('marker done by timeout');\n  }, UDID_REQUEST_TIMEOUT);\n\n  marker().finally(() => {\n    clearTimeout(timeout);\n    done();\n    dot.log('marker done');\n  });\n};\n","(function () {\n\tif (window._1gif) {\n\t\tconst img = new Image(1, 1);\n\n\t\timg.src = window._1gif;\n\t}\n\tdelete window._1gif;\n})();\n","const blacklist = ['Bytespider; spider-feedback@bytedance.com'];\nconst browserAllowed = (userAgent) => {\n    return !blacklist.some((item) => userAgent.includes(item));\n};\nexport { browserAllowed };\n","export const WINDOW_IVA_NAMESPACE = 'sznIVA';\nexport const ERROR_STORAGE_NAME = 'errorStorage';\nexport const BASE_URL = 'https://confessor.iva.seznam.cz';\n","import { BASE_URL } from '../constants';\nexport default class HitSender {\n    /**\n     * Instantiate HitSender.\n     * @param {String} endpoint Name of the component.\n     * @param {String} baseURL Optional target URL to which further data may be appended.\n     */\n    constructor(endpoint, baseUrl) {\n        this.target = '';\n        this.isFirst = true;\n        this.maxLength = 2048;\n        this.target = `${baseUrl || BASE_URL}/${endpoint}`;\n    }\n    delimiter() {\n        if (this.isFirst) {\n            this.isFirst = false;\n            return '?';\n        }\n        return '&';\n    }\n    append(addition) {\n        const newTarget = this.target + this.delimiter() + addition;\n        if (newTarget.length < this.maxLength) {\n            this.target = newTarget;\n        }\n    }\n    encode(value) {\n        return encodeURIComponent(value);\n    }\n    /**\n     * Add query parameter to the URL.\n     * @param {String} key\n     * @param {String} value\n     * @return {HitSender} Current instance is returned to allow method chaining.\n     */\n    appendValue(key, value) {\n        this.append(this.encode(key) + '=' + this.encode(value));\n        return this;\n    }\n    /**\n     * Send GET request to the target.\n     */\n    send() {\n        const pixel = new Image();\n        pixel.src = this.target;\n        return this.target;\n    }\n}\n","import { WINDOW_IVA_NAMESPACE, ERROR_STORAGE_NAME } from '../constants';\nexport const storeMessage = (msg) => {\n    if (!window[WINDOW_IVA_NAMESPACE]) {\n        window[WINDOW_IVA_NAMESPACE] = { [ERROR_STORAGE_NAME]: new Set() };\n    }\n    if (!window[WINDOW_IVA_NAMESPACE][ERROR_STORAGE_NAME]) {\n        window[WINDOW_IVA_NAMESPACE][ERROR_STORAGE_NAME] = new Set();\n    }\n    window[WINDOW_IVA_NAMESPACE][ERROR_STORAGE_NAME].add(msg);\n};\nexport const hasMessage = (msg) => {\n    if (!window[WINDOW_IVA_NAMESPACE] || !window[WINDOW_IVA_NAMESPACE][ERROR_STORAGE_NAME]) {\n        return false;\n    }\n    return window[WINDOW_IVA_NAMESPACE][ERROR_STORAGE_NAME].has(msg);\n};\n","import { browserAllowed } from './modules/browser';\nimport HitSender from './modules/HitSender';\nimport { hasMessage, storeMessage } from './modules/storage';\n/**\n * Parse stack trace lines - store mentioned \"/[name].js\" files\n */\nexport const _parseStackLines = (stack) => {\n    return typeof stack === 'string'\n        ? stack\n            .split('\\n')\n            .map((stackLine) => {\n            return stackLine.match(new RegExp('/[a-zA-Z0-9_\\\\.-]+\\\\.js(\\\\?szn_loader=1)?', 'gi'));\n        })\n            .filter(Boolean)\n        : [];\n};\n/**\n * Handler error - parse stack - validate - send\n */\nexport const _errorHandler = (errorEvent, configuration) => {\n    const { error } = errorEvent;\n    if (!error || !error.stack || !error.message) {\n        return;\n    }\n    const { message, stack } = error;\n    const { scriptName, baseUrl, endpoint } = configuration;\n    // every script can log any error only once\n    const storageMessage = `${scriptName}-${message}`;\n    if (hasMessage(storageMessage)) {\n        // This error has already been sent\n        return;\n    }\n    const stackLinesParsed = _parseStackLines(stack);\n    const linesLimit = 3;\n    const scriptsMentionedFlat = stackLinesParsed.splice(0, linesLimit).reduce((acc, item) => {\n        return (acc = [...acc, ...item]);\n    }, []);\n    if (scriptsMentionedFlat.find((script) => {\n        return (~script.indexOf(`/${scriptName}`) &&\n            // if loader redirect -> do not catch \"real\" loaded lib\n            (endpoint !== 'loader-script' || !~script.indexOf('szn_loader=1')));\n    })) {\n        new HitSender(endpoint, baseUrl)\n            .appendValue('msg', message)\n            .appendValue('script', scriptName)\n            .appendValue('href', window.location.href)\n            .appendValue('referrer', document.referrer)\n            .appendValue('stack', stack)\n            .send();\n        storeMessage(storageMessage);\n    }\n};\n/**\n * Attach error listener (only once for each script)\n */\nexport const startErrorHandling = (config) => {\n    const { scriptName } = config;\n    const initMessage = `${scriptName}-init`;\n    if (hasMessage(initMessage)) {\n        // Prevent multiple listeners in SPA\n        return;\n    }\n    if (!browserAllowed(window.navigator.userAgent)) {\n        // browser blacklist check\n        return;\n    }\n    storeMessage(initMessage);\n    window.addEventListener('error', (errorEvent) => _errorHandler(errorEvent, config));\n};\n","// Polyfills\nimport './modules/polyfills/polyfills';\n// Types\nimport './types/globals';\nimport { DOT } from './classes/dot.class';\nimport { KeyValuePairs } from './types/common';\n// Methods\nimport { syncSid } from './modules/sid/sync';\nimport { addLinkdecoration } from './modules/linkdecoration/linkdecoration';\nimport { runMarker } from './modules/marker/marker';\nimport { configure, _fireAfterCfgEvent } from './modules/config/config';\nimport { handleImpress } from './modules/impress/impress';\nimport { initIframeBridge } from './modules/utils/html/iframe';\n// Constants\nimport { SERVICE_VARIANT } from './constants/index';\n\n// IVA npm library\nimport '@iva/refresher';\nimport { startErrorHandling } from '@iva/error-reporter';\nimport { SID_UTILS } from '@iva/utils';\n\nstartErrorHandling({\n  endpoint: 'dot-static',\n  scriptName: 'dot-nano.js',\n});\n\nSID_UTILS.removeInvalidSidCookie();\n\nclass DOT_NANO extends DOT {\n  constructor() {\n    super(SERVICE_VARIANT.NANO);\n    runMarker(this);\n    syncSid(this);\n\n    /* Include all additional modules */\n    addLinkdecoration(this);\n  }\n\n  /**\n   * Returns new DOT_NANO instance\n   */\n  public getNewInstance(): DOT_NANO {\n    return new DOT_NANO();\n  }\n\n  /**\n   * Configures DOT instance\n   *\n   * @param customConfig config data object\n   * @param impressCallback called when impress is sent\n   */\n  public cfg(customConfig: KeyValuePairs<unknown>, impressCallback?: () => void): void {\n    configure(this, customConfig);\n\n    if (this._cfg.impress) {\n      handleImpress(this, impressCallback);\n    }\n\n    if (this.configured) {\n      return;\n    }\n    this.configured = true;\n\n    _fireAfterCfgEvent(this);\n\n    initIframeBridge(this);\n  }\n}\n\nwindow.DOT = new DOT_NANO();\n","export const SID = 'sid';\n"],"names":["CryptoJS","module","exports","Math","C","C_lib","lib","WordArray","Hasher","C_algo","algo","H","K","isPrime","n","sqrtN","sqrt","factor","getFractionalBits","nPrime","pow","W","SHA256","extend","_doReset","this","_hash","init","slice","_doProcessBlock","M","offset","words","a","b","c","d","e","f","g","h","i","gamma0x","gamma0","gamma1x","gamma1","maj","sigma0","t1","_doFinalize","data","_data","dataWords","nBitsTotal","_nDataBytes","nBitsLeft","sigBytes","floor","length","_process","clone","call","_createHelper","HmacSHA256","_createHmacHelper","undefined","crypto","window","self","globalThis","msCrypto","err","cryptoSecureRandomInt","getRandomValues","Uint32Array","randomBytes","readInt32LE","Error","create","Object","F","obj","subtype","prototype","Base","overrides","mixIn","hasOwnProperty","$super","apply","arguments","instance","properties","propertyName","toString","encoder","Hex","stringify","concat","wordArray","thisWords","thatWords","thisSigBytes","thatSigBytes","clamp","thatByte","j","ceil","random","nBytes","push","C_enc","enc","hexChars","bite","join","parse","hexStr","hexStrLength","parseInt","substr","Latin1","latin1Chars","String","fromCharCode","latin1Str","latin1StrLength","charCodeAt","Utf8","decodeURIComponent","escape","utf8Str","unescape","encodeURIComponent","BufferedBlockAlgorithm","reset","_append","doFlush","processedWords","dataSigBytes","blockSize","nBlocksReady","nWordsReady","max","_minBufferSize","nBytesReady","min","splice","cfg","update","messageUpdate","finalize","hasher","message","key","HMAC","HASH_UNDEFINED","MAX_SAFE_INTEGER","argsTag","arrayTag","boolTag","dateTag","errorTag","funcTag","mapTag","numberTag","objectTag","promiseTag","regexpTag","setTag","stringTag","symbolTag","weakMapTag","arrayBufferTag","dataViewTag","reIsHostCtor","reIsUint","typedArrayTags","freeGlobal","freeSelf","root","Function","freeExports","nodeType","freeModule","moduleExports","freeProcess","process","nodeUtil","binding","nodeIsTypedArray","isTypedArray","arraySome","array","predicate","index","mapToArray","map","result","Array","size","forEach","value","setToArray","set","uid","func","transform","arrayProto","funcProto","objectProto","coreJsData","funcToString","maskSrcKey","exec","keys","IE_PROTO","nativeObjectToString","reIsNative","RegExp","replace","Buffer","Symbol","Uint8Array","propertyIsEnumerable","symToStringTag","toStringTag","nativeGetSymbols","getOwnPropertySymbols","nativeIsBuffer","isBuffer","nativeKeys","arg","DataView","getNative","Map","Promise","Set","WeakMap","nativeCreate","dataViewCtorString","toSource","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","symbolProto","symbolValueOf","valueOf","Hash","entries","clear","entry","ListCache","MapCache","SetCache","values","__data__","add","Stack","arrayLikeKeys","inherited","isArr","isArray","isArg","isArguments","isBuff","isType","skipIndexes","iteratee","baseTimes","isIndex","assocIndexOf","eq","baseGetTag","isOwn","tag","unmasked","getRawTag","objectToString","baseIsArguments","isObjectLike","baseIsEqual","other","bitmask","customizer","stack","object","equalFunc","objIsArr","othIsArr","objTag","getTag","othTag","objIsObj","othIsObj","isSameTag","equalArrays","byteLength","byteOffset","buffer","name","convert","isPartial","stacked","get","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","objProps","getAllKeys","objLength","othProps","othLength","skipCtor","objValue","othValue","compared","objCtor","constructor","othCtor","equalObjects","baseIsEqualDeep","baseIsNative","isObject","isMasked","isFunction","test","baseKeys","Ctor","proto","arrLength","seen","arrValue","othIndex","has","keysFunc","symbolsFunc","arrayPush","baseGetAllKeys","getSymbols","getMapData","type","getValue","pop","pairs","LARGE_ARRAY_SIZE","resIndex","arrayFilter","symbol","ArrayBuffer","resolve","ctorString","isLength","baseUnary","genTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reFlags","cloneableTags","addMapEntry","pair","addSetEntry","arrayReduce","accumulator","initAccum","isHostObject","overArg","getPrototype","getPrototypeOf","objectCreate","isArrayLike","isArrayLikeObject","assignValue","baseClone","isDeep","isFull","input","initCloneArray","source","copyArray","isFunc","copy","cloneBuffer","isPrototype","initCloneObject","copyObject","copySymbols","baseAssign","cloneFunc","cloneArrayBuffer","dataView","cloneDataView","typedArray","cloneTypedArray","cloneMap","regexp","lastIndex","cloneRegExp","cloneSet","initCloneByTag","props","arrayEach","subValue","arrayBuffer","newValue","cache","_arrayLikeToArray","r","_assertThisInitialized","ReferenceError","_callSuper","t","o","_getPrototypeOf","_possibleConstructorReturn","_isNativeReflectConstruct","Reflect","construct","_classCallCheck","TypeError","_defineProperties","enumerable","configurable","writable","defineProperty","_toPropertyKey","_createClass","_createForOfIteratorHelper","iterator","_unsupportedIterableToArray","s","done","u","next","return","_get","bind","p","_superPropBase","getOwnPropertyDescriptor","setPrototypeOf","__proto__","_inherits","_setPrototypeOf","Boolean","_superPropGet","_toPrimitive","toPrimitive","Number","from","createAbortEvent","reason","event","Event","document","createEvent","initEvent","createEventObject","bubbles","cancelable","normalizeAbortReason","DOMException","AbortSignal","AbortController","Emitter","callback","options","listeners","l","_this","stackToCall","_loop","listener","then","once","removeEventListener","defaultPrevented","_Emitter","_this2","aborted","onabort","_this$reason","time","controller","setTimeout","abort","signal","iterable","clean","_step","_iterator","_step2","_iterator2","addEventListener","signalReason","dispatchEvent","polyfillNeeded","__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL","console","log","Request","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","id","loaded","__webpack_modules__","getter","__esModule","definition","prop","nmd","paths","children","CustomEvent","params","detail","evt","initCustomEvent","SERVICE_VARIANT","BASE","TV","FULLTEXT","NANO","PARTNER","SMALL","PROTOCOL","REGEX_IMEDIA_HOST","REGEX_DEV_OR_TEST_HOST","SPENTTIME_MIN_DURATION","LAST_SESSION_KEY","CDL_KEY","EVENTS","IS_TABLE_KEYS_SPECIAL","rusId","said","premium","loginState","IS_TABLE_LOGIN_STATE","green","red","orange","PROPAGATE_HITS_BLACKLIST","CW_REFERRER_COOKIE_NAME","CW_REFERRER_CURRENT_COOKIE_NAME","SSP_ALLOWED_SOURCES","_sanitizeParamName","_getParamValueByRegExp","haystack","needle","results","getParameterFromURLQuery","url","regExp","location","href","getParameterFromURLHash","hash","replaceImedia","getDotSource","variant","filename","_getScriptFilename","dotScript","querySelectorAll","item","getAttribute","getAPIHost","dotSource","_getAPIHostFromDotSourceParam","match","_getTestAPIHostFromUrl","getDocumentUrl","wlocation","includes","substring","indexOf","getZnStringFromLocationSearch","dot","URLSearchParams","search","znstring","decodedParamKey","decodedParamValue","history","replaceState","REDIRECT_SID","getDomainLevel","hostname","level","leadingDot","availableLevels","separators","split","multipliers","seconds","minutes","hours","days","cookieDefaults","expires","path","secure","sameSite","domain","_getCookieString","cookieData","remove","cookieValues","expireTime","Date","toUTCString","expirationArray","units","multipliersKeys","unitIndex","findIndex","unit","multiArray","k","reduce","acc","current","date","setTime","getTime","_getExpireTime","filter","el","getCookie","requestedCookieName","cookie","cookieString","separatorIndex","trim","_getCookieKeyValuePair","getSidCookie","setCookie","setCookieAndReport","COOKIE_EVENT","removeCookie","updateIdentitiesFromConfig","customConfig","sznIVA","IS","identitiesSpecial","identityKey","loginValue","updateIdentities","updateSidIdentity","sid","isSznAdmin","login","getIdentity","adminName","validateConfig","NumberRusId","isNaN","_validateRusId","spenttimeDuration","duration","_validateSpenttimeDuration","getConfig","config","host","thirdPartyCookieUrl","delay","query","service","lsid","version","spa","pageViewId","impress","abtest","serviceVariant","hitTimeout","u_agrm","spenttimeSpaReset","forceBeacon","dopParamCleanup","propagateHits","badge","mousedown","mousedownDataDotData","serverSideRefresher","load","error","lazyLoadingEnabled","_fireAfterCfgEvent","fireEventAfterCfg","AFTER_CFG_EVENT","enableAfterCfgEvent","configure","_cfg","isInstanceConfigured","configured","isLocalStorageAvailable","localStorage","setItem","removeItem","setToLocalStorage","getFromLocalStorage","getItem","removeParam","sourceURL","paramName","matches","stringToReplace","getGeometry","dataElms","body","geometry","dimensions","x","documentElement","scrollLeft","y","scrollTop","w","clientWidth","clientHeight","page","offsetWidth","offsetHeight","scrn","screen","width","height","colorDepth","scroll","port","visible","_getVisibleDataElm","elm","left","top","offsetLeft","offsetTop","offsetParent","clearSpenttimeInterval","spenttimeState","intervalId","clearTimeout","clearVisibilitychangeEvent","spenttimeConfigured","visibilitychangeListener","IDENTITY_STATE","VALUES_TYPES","IDENTITIES_KEYS","IDENTITIES_KEYS_SPECIAL","IDENTITIES_VALUES_TYPES","ADDRESS","PHONE","DOT_CONFIG_PROPERTIES","LS_KEY_CACHE","EVENT_NAME","EVENT_FROM_TOP_NAME","EVENT_TO_TOP_NAME","TIMEOUT","TIMEOUT_PREMATURE_LOGIN","DEFAULT_GET_RULES","rich","justSettled","cacheEnough","subName","messages","fColor","bColor","style","messagesCopy","v","table","ENABLER","EVENT_PREFIX","DEFAULTS","isTopLevel","win","Cypress","frameElement","getGlobalDebuggerObject","_a","debugger","upsertGlobalDebuggerObject","windowObject","assign","getParamValue","param","queryString","paramRegex","getDebuggerRule","paramValue","topFrameRule","getTopFrameRule","localStorageRule","getInternalConfig","JSON","__rest","_b","_c","postMessage","rule","targetOrigin","iframeBridgeNotified","handlerFromChildMessage","handlerFromTopMessage","referrer","initIframeBridge","debugFactory","lastValue","permanentEnabler","args","types","argsCount","shouldLog","welcomeNotified","toLowerCase","findNameInValue","getShouldLog","firstArg","state","logArgs","EVENT_TYPE","dotInstance","dotLog","DOT","getNewInstance","hit","sendToConfessor","msg","msgType","navigator","sendBeacon","isStorageSupported","setCache","identities","setLocalStorageValue","getCache","getLocalStorageValue","encodeString","content","btoa","codeUnits","Uint16Array","charCodes","_toBinary","decodeString","binary","bytes","_fromBinary","atob","Base64Url","static","repeatStr","str","count","res","encode","padding","LCM","BASIS","DICT","decode","strByte","strBits","REVERSE_DICT","CONSENT_COOKIE_NAME","CONSENT_GOOGLE_COOKIE_NAME","CONSENT_COOKIE_NAMES","extractConsentString","cookieName","cookieValue","hasPurposeOne","consentString","encodedTCString","segments","coreSegment","bitField","purposeOneBit","decodePurposeOne","getResult","euconsentString","purposeOne","receivedTCFData","listeningTCFApi","receiverCallbackList","tcCallback","tcData","success","eventStatus","tcString","receiverCallback","hasTCFApi","__tcfapi","listenToTCFApi","getConsentFromCookieList","isRedirectPage","startsWith","sidLegalStoreCheck","callbackOk","callbackNotOk","timeout","timeoutOk","check","fn","purposeConsents","timer","consentCallback","consentResult","getIS","getISconfig","ISConfig","isValidSHA256String","isValidUUID","getHostname","getGlobalConfig","isAvailable","identificator","availables","available","isCrossFrameBridgeActive","bridgeConfig","framesBridge","pullInitialIdentities","initIdentities","__SZN_IS_INITIAL_STATE__","output","frames","randomWordArray","m_w","_m_w","_m_z","mask","rcache","_r","super","Int8Array","Uint8ClampedArray","Int16Array","Int32Array","Float32Array","Float64Array","typedArrayByteLength","_words","m_data","SubHasher","_hasher","_key","hasherBlockSize","hasherBlockSizeBytes","oKey","_oKey","iKey","_iKey","oKeyWords","iKeyWords","innerHash","X32WordArray","X64Word","high","low","X64WordArray","toX32","x64Words","x64WordsLength","x32Words","x64Word","wordsLength","parseLoop","base64Str","base64StrLength","reverseMap","bitsCombined","Base64","_map","base64Chars","triplet","charAt","paddingChar","_reverseMap","paddingIndex","T","abs","sin","FF","GG","HH","II","MD5Algo","_M","offset_i","M_offset_i","M_offset_0","M_offset_1","M_offset_2","M_offset_3","M_offset_4","M_offset_5","M_offset_6","M_offset_7","M_offset_8","M_offset_9","M_offset_10","M_offset_11","M_offset_12","M_offset_13","M_offset_14","M_offset_15","nBitsTotalH","nBitsTotalL","H_i","MD5","HmacMD5","EvpKDFAlgo","keySize","iterations","compute","password","salt","block","derivedKey","derivedKeyWords","Cipher","xformMode","_xformMode","createEncryptor","_ENC_XFORM_MODE","createDecryptor","_DEC_XFORM_MODE","SubCipher","selectCipherStrategy","PasswordBasedCipher","SerializableCipher","encrypt","decrypt","ciphertext","dataUpdate","ivSize","StreamCipher","BlockCipherMode","cipher","iv","_cipher","_iv","Encryptor","Decryptor","xorBlock","_prevBlock","CBC","processBlock","encryptBlock","thisBlock","decryptBlock","Pkcs7","pad","blockSizeBytes","nPaddingBytes","paddingWord","paddingWords","unpad","BlockCipher","mode","modeCreator","_mode","__creator","finalProcessedBlocks","CipherParams","cipherParams","formatter","OpenSSLFormatter","openSSLStr","ciphertextWords","encryptor","cipherCfg","algorithm","format","_ciphertext","_parse","OpenSSLKdf","execute","_salt","derivedParams","kdf","swapEndian","word","Utf16BE","utf16Chars","codePoint","utf16Str","utf16StrLength","Utf16","Utf16LE","Base64url","urlSafe","_safeMap","SHA1Algo","SHA1","HmacSHA1","SHA256Algo","_H","SHA224Algo","SHA224","HmacSHA224","SHA512Algo","H0","H1","H2","H3","H4","H5","H6","H7","H0h","H0l","H1h","H1l","H2h","H2l","H3h","H3l","H4h","H4l","H5h","H5l","H6h","H6l","H7h","H7l","ah","al","bh","bl","ch","cl","dh","dl","eh","fh","fl","gh","gl","hh","hl","Wil","Wih","Wi","gamma0xh","gamma0xl","gamma0h","gamma0l","gamma1xh","gamma1xl","gamma1h","gamma1l","Wi7","Wi7h","Wi7l","Wi16","Wi16h","Wi16l","chh","chl","majh","majl","sigma0h","sigma0l","sigma1h","sigma1l","Ki","Kih","Kil","t1l","t1h","t2l","SHA512","HmacSHA512","SHA384Algo","SHA384","HmacSHA384","RHO_OFFSETS","PI_INDEXES","ROUND_CONSTANTS","_x","_y","newY","LFSR","roundConstantMsw","roundConstantLsw","bitPosition","SHA3Algo","outputLength","_state","nBlockSizeLanes","M2i","M2i1","lane","round","tMsw","tLsw","Tx","Tx4","Tx1","Tx1Msw","Tx1Lsw","laneIndex","laneMsw","laneLsw","rhoOffset","TPiLane","T0","state0","TLane","Tx1Lane","Tx2Lane","roundConstant","blockSizeBits","outputLengthBytes","outputLengthLanes","hashWords","SHA3","HmacSHA3","_zl","_zr","_sl","_sr","_hl","_hr","f1","z","f2","f3","f4","f5","rotl","RIPEMD160Algo","hr","zl","zr","sl","sr","ar","br","cr","dr","er","RIPEMD160","HmacRIPEMD160","PBKDF2Algo","hmac","blockIndex","blockIndexWords","blockWords","blockWordsLength","intermediate","intermediateWords","_SBOX","INV_SBOX","_SUB_MIX_0","_SUB_MIX_1","_SUB_MIX_2","_SUB_MIX_3","INV_SUB_MIX_0","INV_SUB_MIX_1","INV_SUB_MIX_2","INV_SUB_MIX_3","xi","sx","x2","x4","x8","RCON","AESAlgo","_nRounds","_keyPriorReset","keyWords","ksRows","_keySchedule","keySchedule","ksRow","_invKeySchedule","invKeySchedule","invKsRow","_doCryptBlock","SUB_MIX_0","SUB_MIX_1","SUB_MIX_2","SUB_MIX_3","SBOX","nRounds","s0","s1","s2","s3","t0","t2","t3","AES","PC1","PC2","BIT_SHIFTS","SBOX_P","SBOX_MASK","exchangeLR","_lBlock","_rBlock","exchangeRL","DESAlgo","keyBits","keyBitPos","_subKeys","subKeys","nSubKey","subKey","bitShift","_invSubKeys","invSubKeys","lBlock","rBlock","DES","TripleDESAlgo","key1","key2","key3","_des1","_des2","_des3","TripleDES","S","C_","G","nextState","X","_X","_C","gx","ga","gb","RabbitAlgo","IV","IV_0","IV_1","i0","i2","i1","i3","Rabbit","RabbitLegacyAlgo","RabbitLegacy","generateKeystreamWord","_S","_i","_j","keystreamWord","RC4Algo","keySigBytes","keyByteIndex","keyByte","RC4","RC4DropAlgo","drop","RC4Drop","N","ORIG_P","ORIG_S","blowfishCtx","pbox","sbox","ctx","blowfishEncrypt","right","temp","Xl","Xr","BlowfishAlgo","keysize","Row","Col","keyIndex","data1","data2","blowfishInit","blowfishDecrypt","Blowfish","generateKeystreamAndEncrypt","keystream","CFB","CTR","counter","_counter","incWord","_word","b1","b2","b3","CTRGladman","incCounter","ECB","OFB","_keystream","AnsiX923","lastBytePos","Iso10126","ZeroPadding","Iso97971","NoPadding","HexFormatter","x64","Word","PBKDF2","EvpKDF","OpenSSL","isPrototypeOf","digestMessage","inputArray","digestArray","RULES","reg","city","street","houseNumber","postalCode","CHAR_MAP","CHAR_PATTERN","_normalize","addressKey","normalizedValue","strWithSpecialChars","addressKeyRules","val","AREA_CODES","createPhoneObject","phoneNumber","digest","phoneObj","normalizedPhoneNumber","parsed","_includesAreaCode","code","areaCode","createHash","encodeURI","invalidUpdates","storeInvalidUpdates","newInvalidUpdates","isIdentityObject","created","updated","settled","validateIdentificator","handleOkValue","ok","handleInvalidValue","identity","timestamp","now","pvid","sssp","getPageViewId","handleCastedValue","castedValue","validateValueType","expectedType","integer","string","boolean","casted","castBoolean","addressObject","validatedAddress","address","normalizedObject","hashedAddressObj","normalizedAddressPart","hashedObject","fromEntries","phone","validatedPhone","email","validatedEmail","isHashBlacklisted","_isValidPlaintextEmail","createEmailHash","secid","hashString","createIdentityObject","storageItem","fresh","identityOutput","isOK","isStateValid","_parseLoginConsent","loginIdentity","getLoginConsentString","getLoginConsentFormatedResult","getLoginByPriority","getExtendedLoginFromWindowObject","getLoginObject","hasLoginId","some","isLoginForgotten","loginCopy","others","loginCurrent","advert_uid","euconsent","parsedConsentString","loginConsent","v2","encodedCookie","loginConsentString","_getConsentFromCookieOrTcfApi","cb","configuration","updatedCookie","optionKey","optionValue","_getUdidFromCookie","isValidSid","_getSidFromCookie","topLevelInfo","hasLoginBadge","feedChildFrames","_childFramesToFeed","topLevelData","initCrossFramesCommunication","updater","origin","interval","attempts","maxAttempts","badgeLoop","setInterval","hasLogin","clearInterval","loginBadgeCheck","destination","parent","_d","_e","__awaiter","thisArg","_arguments","P","generator","reject","fulfilled","step","rejected","_instance","servicesDisallowed","services","_isBlacklistedService","_isWhitelistedService","_canPropagateID5ToIS","consent","fetchId5","handler","ID5","identifier","markLoaded","element","getElementById","classList","contains","script","createElement","_reportAndReject","src","onload","onerror","head","appendChild","loadScript","partnerId","cmpApi","onAvailable","onUpdate","_getInstance","status","newId5","getUserId","id5","changes","pullExternalsSync","loginObject","getConsent","getIdentityObject","getLogin","udid","getUdid","getSid","pullExternalsAsync","initObject","getterSpecified","existsInStorage","tcfApiHooked","consentTimer","tfcInterval","timeouts","hookTFC","sendToHandler","consentSyncCheck","listenToCmpDialogEvents","loginTimeoutExceeded","newUid","oldUid","loginTimer","listenToBadge","udidTimer","listenToMarker","sidTimer","listenToSidEvents","prematureSettling","getCfgValue","sendEvent","eventName","_subscribers","runSubscribers","justValues","identityItem","getIdentitiesValues","prepareIdentityStorageObject","mergeData","composeIS","cacheAndNotify","encoded","getValueLevel","identityValue","subSplit","parsedValue","isValueObject","isRich","createValuesObjects","createValueForSpecial","specials","keyHandled","valueHandled","sanitizeIdentities","storage","newIdentities","sanitedIdentities","identityObject","valueValidated","valueObject","rulesDefaults","rules","rulesDefaultsAll","rulesGranular","_decodeStorage","toDecode","decoding","_storage","_encodeStorage","dryRun","initStorage","force","mergeToInit","inited","cacheDecoded","cacheValidKeys","cacheObject","getStorage","updateStorage","getStorageItem","mainIdentificatorPart","awaitStorageItem","doNotTimeout","satisfiedBy","logTimeouts","action","prematureTimeout","clearTimeouts","prematureIdentity","sanitizedIdentities","newKeys","notEqualKeys","sKey","newIdentity","currentIdentity","obj1","obj2","newStorage","newStorageCleaned","oldIdentities","_canStoreSpecial","sbr","whiteList","eid","tid","number","aid","_terminator","_prepareInit","OUTPUT","_init","mergeInit","getIdentitySettled","getIdentities","nullable","rls","getNullableObject","clearIdentities","IDENTITY_KEY","clearStorage","subscribeIdentities","subscribe","prepareIdsForBe","includeMetadata","isIdentityObjectFull","requiredKeys","every","isIdentitiesSimplifiedObject","_invalids","currentPvid","isStub","invalidUpdatesForBe","loginTimeout","getInvalidUpdatesForBe","accIdentities","whiteListItem","accSingleIdentity","identityValueKey","_validateIdentityKeys","includeOnlyWhitelisted","_metadata","_version","getViableLoginIdentity","getInvalidUpdatesLog","ids","serializeHit","addUserAgreement","getCWSession","decoded","ri","getCommon","lses","lastSession","cwses","cdl","cookieDeprecationLabel","ab","ptitle","title","shouldLazyHit","addToHitQueue","queue","hitToSave","shouldPostponeHits","cookieRequestDone","udidRequestDone","addToPostponedQueue","postponedQueue","sendPostponedHits","useFetch","_clearPostponedHits","getDataDotData","dataD","node","dataset","valueDotData","dotData","dataDot","parentNode","getDataDot","arr","unshift","getTopWindow","GET_INFO_EVENT","site","fromTopHandler","info","getInfo","topConfig","GET_INFO_COMPLETE","pingTop","_getSPAReferrer","SPAReferrer","_getSspUtmSource","sspUtmSource","setImpressBeforeAdload","impressBeforeAdloadSent","sendImpress","impressData","q","referer","setWindowNameWithId","_addImpressData","dataObject","firstImpressSent","FIRST_IMPRESS_SENT","handleImpress","impressHandler","cookieRequest","_isItFinalSpenttimeHit","_xhr","XMLHttpRequest","configUrl","xhr","sender","senderVersion","callbackCalled","timeoutId","callCallback","argument","open","setRequestHeader","UAData","model","platformVersion","withCredentials","send","sendHit","isPageOpenfromLocalFile","protocol","instanceId","extendHitWithSharedData","sharedData","actions","sharedHitData","lazyHittingStatus","hitQueue","PROPAGATE_HIT_MESSAGE","_beaconApi","device_info","platform_version","hitWithDeviceInfo","blob","Blob","fetch","async","method","keepalive","priority","credentials","headers","_fetch","browser","isSafari","userAgent","isSbrowser","getHighEntropyValues","userAgentData","catch","getCDLValue","setUAData","localStorageValue","apiValue","CDL_DONE","setCookieDeprecationLabel","cwReferrer","ref","ts","propagatedHitData","extendedPath","contentWindow","addPropagatedHitsListener","delayed","_sendDelayed","placeholder","moduleName","methodName","DEBUG_CONFIG","dotDebugFactory","getRandomHexdec","padStart","_variant","_ts","_lastSession","_dataElms","_delayed","_configured","_SPAReferrer","_lastFCP","_hitQueue","_lazyHittingStatus","_postponedQueue","_synced","_cookieRequestDone","_cookieRequest","_udidRequestDone","_firstImpressSent","_impressBeforeAdloadSent","_fireEventAfterCfg","_sentBeforeUnload","_config","_info","_UAData","_cookieDeprecationLabel","_instanceId","_instanceColor","getRandomColor","_log","_sharedHitData","lastFCP","synced","sentBeforeUnload","_spenttimeState","_spenttimeConfigured","impressCallback","cfgFromTopFrame","cancel","isConfigured","setAfterCfgEvent","getCfg","hitAsync","sendHitAsync","_delay","_getSspAllowedSources","_len","spenttime","cancelSpenttime","handleSid","runLinkdecoration","_handleSid","_len2","_key2","getSharedHitData","clearSharedHitData","cleanStoredSharedData","setSharedHitData","merge","submited","handleSubmitedSharedData","shouldUseRedirect","majorVersion","rawUserAgent","parseUserAgent","saveSidIntoBrowser","isSeznamDomain","endsWith","setSidIntoSeznamDomain","sidCookie","setSidIntoForeignDomain","sendRequestAfterAdditionalConsent","sidXhr","requestBody","iterationCount","finishInterval","trySendRequest","consentCookie","CONSENT","SCMP_CONSENT_SET","scmpHandler","periodicalCheck","createCookieRequest","_createRequestBody","SID_UTILS","onreadystatechange","readyState","responseText","_handleCookieRequestResponse","response","resolveConsent","allowed","shouldDisableCookieRefresh","sidCookieData","splitParams","paramKey","_parseCookieValue","te","_getTimeSinceCookieUpdate","hasAlreadySetSid","linkdec","_","m","O","A","I","$","E","V","R","B","L","U","D","J","Q","Y","Z","ee","ne","re","oe","ie","ae","se","ce","ue","le","de","fe","pe","Me","ge","ve","he","we","be","ye","Le","me","je","Oe","Se","Ae","Ie","xe","ze","Ce","$e","Ue","Ee","Ve","Xe","De","Te","He","Ne","Fe","Pe","We","ke","Re","Ge","delete","Be","qe","default","androidSid","dsid","namespace","sbrowser","webkit","messageHandlers","sidHandler","VERSION","PARAM_NAMES","COOKIE_NAMES","ACTIONS","NOT_STORED","SAME","DIFFERENT","HIT_ACTIONS","SCMP_SSP_EVENT","CONSENT_DETECTION_INTERVAL","CONSENT_BLACKLIST","SID_BLACKLIST","RUN","DO_NOT_RUN","UNCERTAIN","getShouldRunFromWindow","cmpone","rc","internal","decodeClid","sznclid","padded","padEnd","char","isValid","cutParamFromUrl","clearURL","dotConfig","customData","hitData","hasConsent","getConsentDate","setMonth","getMonth","setDate","getDate","getSidDate","getSznaiidDate","commonCookieOptions","handleMissingSid","regex","storeSznaiid","sznaiid","localSznaiidCookie","storeConsent","shouldStore","cmpDataObject","startDate","showDialog","finish","handleCallback","consentTimeout","getSznaiid","szntime","getSzntime","currTime","diff","isSzntimeValid","handleConsent","shouldRun","consentTimeoutOk","maxIterations","CONSENT_DETECTION_TIMEOUT","clearAndRun","_shouldRun","handleRCEvent","detectShouldRun","localSidCookie","ld_sid","storeSid","syncSid","sbrowserSyncCalled","_handleSbrowserPostmessage","SID_STORE_CHECK","handleSbrowserSid","sidValue","tcParameter","setAttribute","addLinkdecoration","COOKIE","STATES","isTld","getDomain","setUdidAndDispatchEvent","udidEndpoint","marker","forceCookie","markerCookie","payload","request_id","json","fetchUdid","setUdidCookieAndReport","markerCalled","_1gif","Image","blacklist","WINDOW_IVA_NAMESPACE","ERROR_STORAGE_NAME","HitSender","endpoint","baseUrl","target","isFirst","maxLength","delimiter","append","addition","newTarget","appendValue","storeMessage","hasMessage","_errorHandler","errorEvent","scriptName","storageMessage","stackLinesParsed","stackLine","_parseStackLines","find","initMessage","startErrorHandling","DOT_NANO","finally","runMarker"],"sourceRoot":""}