{"version":3,"sources":["webpack:///./node_modules/unique-slug/index.js","webpack:///./node_modules/imurmurhash/imurmurhash.js","webpack:///../src/tags.js","webpack:///../src/attrs.js","webpack:///../src/utils.js","webpack:///../src/regexp.js","webpack:///../src/purify.js","webpack:///./node_modules/text-clipper/dist/index.js"],"names":["MurmurHash3","require","module","exports","uniq","result","toString","substr","Math","random","cache","key","seed","m","this","reset","length","hash","prototype","h1","k1","i","top","len","rem","charCodeAt","freeze","Object","x","html","svg","svgFilters","mathMl","text","xml","hasOwnProperty","setPrototypeOf","apply","Reflect","addToSet","set","array","l","element","lcElement","toLowerCase","clone","object","newObject","property","apply$1","fun","thisValue","args","seal","MUSTACHE_EXPR","ERB_EXPR","DATA_ATTR","ARIA_ATTR","IS_ALLOWED_URI","IS_SCRIPT_OR_DATA","ATTR_WHITESPACE","arraySlice","Array","slice","getGlobal","window","_createTrustedTypesPolicy","trustedTypes","document","_typeof","createPolicy","suffix","policyName","html$$1","error","warn","createDOMPurify","arguments","undefined","DOMPurify","root","version","removed","isSupported","originalDocument","useDOMParser","removeTitle","DocumentFragment","HTMLTemplateElement","Node","NodeFilter","NamedNodeMap","_window$NamedNodeMap","MozNamedAttrMap","Text","Comment","DOMParser","TrustedTypes","template","ownerDocument","trustedTypesPolicy","emptyHTML","implementation","_document","createNodeIterator","getElementsByTagName","createDocumentFragment","importNode","hooks","createHTMLDocument","ALLOWED_TAGS","DEFAULT_ALLOWED_TAGS","ALLOWED_ATTR","DEFAULT_ALLOWED_ATTR","FORBID_TAGS","FORBID_ATTR","ALLOW_ARIA_ATTR","ALLOW_DATA_ATTR","ALLOW_UNKNOWN_PROTOCOLS","SAFE_FOR_JQUERY","SAFE_FOR_TEMPLATES","WHOLE_DOCUMENT","SET_CONFIG","FORCE_BODY","RETURN_DOM","RETURN_DOM_FRAGMENT","RETURN_DOM_IMPORT","SANITIZE_DOM","KEEP_CONTENT","IN_PLACE","USE_PROFILES","FORBID_CONTENTS","DATA_URI_TAGS","URI_SAFE_ATTRIBUTES","DEFAULT_URI_SAFE_ATTRIBUTES","CONFIG","formElement","_parseConfig","cfg","ADD_URI_SAFE_ATTR","IS_ALLOWED_URI$$1","html$1","svg$1","mathMl$1","ADD_TAGS","ADD_ATTR","table","_forceRemove","node","push","parentNode","removeChild","outerHTML","_removeAttribute","name","removeAttribute","_initDocument","dirty","doc","leadingWhitespace","matches","parseFromString","documentElement","body","firstElementChild","insertBefore","_createIterator","call","SHOW_TEXT","FILTER_ACCEPT","_isNode","obj","nodeType","nodeName","_executeHook","entryPoint","currentNode","data","forEach","hook","_sanitizeElements","content","elm","textContent","setAttribute","_isClobbered","tagName","insertAdjacentHTML","htmlToInsert","innerHTML","test","cloneNode","_isValidAttribute","lcTag","lcName","value","_sanitizeAttributes","attr","idAttr","attributes","hookEvent","_attr","namespaceURI","trim","attrName","attrValue","keepAttr","id","setAttributeNS","pop","_sanitizeShadowDOM","fragment","shadowNode","shadowIterator","nextNode","sanitize","importedNode","oldNode","returnNode","TypeError","toStaticHTML","appendChild","firstChild","nodeIterator","serializedHTML","setConfig","clearConfig","isValidAttribute","tag","addHook","hookFunction","removeHook","removeHooks","removeAllHooks","defineProperty","VOID_ELEMENTS","BLOCK_ELEMENTS","NEWLINE_CHAR_CODE","EXCLAMATION_CHAR_CODE","DOUBLE_QUOTE_CHAR_CODE","AMPERSAND_CHAR_CODE","SINGLE_QUOTE_CHAR_CODE","FORWARD_SLASH_CHAR_CODE","SEMICOLON_CHAR_CODE","TAG_OPEN_CHAR_CODE","EQUAL_SIGN_CHAR_CODE","TAG_CLOSE_CHAR_CODE","CHAR_OF_INTEREST_REGEX","SIMPLIFY_WHITESPACE_REGEX","indexOfWhiteSpace","string","fromIndex","isWhiteSpace","isCharacterReferenceCharacter","charCode","isLineBreak","index","firstCharCode","newlineElements","join","RegExp","shouldSimplifyWhiteSpace","tagStack","simplifyWhiteSpace","replace","takeCharAt","nextCharCode","String","fromCharCode","default","maxLength","options","_a","imageWeight","_b","indicator","_c","maxLines","Infinity","numChars","numLines","isUnbreakableContent","rest","nextIndex","search","nextBlockSize","max","isSpecialTag","commentEndIndex","indexOf","cdataEndIndex","attributeQuoteCharCode","endIndex","isAttributeValue","Error","charCode_1","firstAttributeCharCode","isEndTag","tagNameStartIndex","tagNameEndIndex","min","currentTagName","includes","isCharacterReference","charCode_2","nextChar","char","takeHtmlCharAt","peekIndex","nextPeekIndex","charAt","tagEndIndex","breakWords","j","clipHtml","clipPlainText"],"mappings":"ymBACA,IAAIA,EAAcC,EAAQ,MAE1BC,EAAOC,QAAU,SAAUC,GACzB,OAAIA,GAEM,WADG,IAAIJ,EAAYI,GACDC,SAASC,SAAS,KAAKC,QAAQ,IAEjDC,KAAKC,SAASH,SAAS,IAAM,WAAWC,OAAO,EAAG;;;;;;;;;;;;CCG7D,WACG,IAAIG,EAQJ,SAASV,EAAYW,EAAKC,GACtB,IAAIC,EAAIC,gBAAgBd,EAAcc,KAAOJ,EAM7C,GALAG,EAAEE,MAAMH,GACW,iBAARD,GAAoBA,EAAIK,OAAS,GACxCH,EAAEI,KAAKN,GAGPE,IAAMC,KACN,OAAOD,EAQfb,EAAYkB,UAAUD,KAAO,SAASN,GAClC,IAAIQ,EAAIC,EAAIC,EAAGC,EAAKC,EAOpB,OALAA,EAAMZ,EAAIK,OACVF,KAAKS,KAAOA,EAEZH,EAAKN,KAAKM,GACVC,EAAI,EACIP,KAAKU,KACT,KAAK,EAAGJ,GAAMG,EAAMF,EAA2B,MAAtBV,EAAIc,WAAWJ,KAAiB,EACzD,KAAK,EAAGD,GAAMG,EAAMF,GAA2B,MAAtBV,EAAIc,WAAWJ,OAAkB,EAAI,EAC9D,KAAK,EAAGD,GAAMG,EAAMF,GAA2B,MAAtBV,EAAIc,WAAWJ,OAAkB,GAAK,EAC/D,KAAK,EACDD,GAAMG,EAAMF,GAAyB,IAApBV,EAAIc,WAAWJ,KAAc,GAAK,EACnDD,GAAMG,EAAMF,GAA2B,MAAtBV,EAAIc,WAAWJ,OAAkB,EAAI,EAK9D,GAFAP,KAAKU,IAAOD,EAAMT,KAAKU,IAAO,GAC9BD,GAAOT,KAAKU,KACF,EAAG,CAET,IADAL,EAAKL,KAAKK,GAQNA,EAAW,GADXA,GADAA,GAFAC,EAAW,OADXA,GADAA,EAAW,MAALA,EAA8B,YAAV,MAALA,GAA6B,aACtC,GAAOA,IAAO,IACU,WAAV,MAALA,GAA6B,aAGtC,GAAOD,IAAO,IACX,WAAc,aAEzBE,GAAKE,IAITH,EAA6B,MAAtBT,EAAIc,WAAWJ,MACO,MAAtBV,EAAIc,WAAWJ,OAAkB,GACX,MAAtBV,EAAIc,WAAWJ,OAAkB,GAExCD,IAAc,KADdE,EAAMX,EAAIc,WAAWJ,QACE,IACT,MAANC,IAAiB,EAI7B,OADAF,EAAK,EACGN,KAAKU,KACT,KAAK,EAAGJ,IAA+B,MAAxBT,EAAIc,WAAWJ,EAAI,KAAgB,GAClD,KAAK,EAAGD,IAA+B,MAAxBT,EAAIc,WAAWJ,EAAI,KAAgB,EAClD,KAAK,EAAGD,GAA2B,MAApBT,EAAIc,WAAWJ,GAGlCP,KAAKK,GAAKA,EAId,OADAL,KAAKM,GAAKA,EACHN,MAMXd,EAAYkB,UAAUb,OAAS,WAC3B,IAAIe,EAAID,EAoBR,OAlBAC,EAAKN,KAAKM,GACVD,EAAKL,KAAKK,GAENC,EAAK,IAILD,GADAC,EAAW,OADXA,GADAA,EAAW,MAALA,EAA8B,YAAV,MAALA,GAA6B,aACtC,GAAOA,IAAO,IACU,WAAV,MAALA,GAA6B,YAItDD,GAAML,KAAKS,IAGXJ,EAAW,OADXA,GAAMA,IAAO,IACuB,YAAV,MAALA,GAA6B,WAElDA,EAAW,OADXA,GAAMA,IAAO,IACuB,YAAV,MAALA,GAA6B,YAClDA,GAAMA,IAAO,MAEC,GAMlBnB,EAAYkB,UAAUH,MAAQ,SAASH,GAGnC,OAFAE,KAAKK,GAAqB,iBAATP,EAAoBA,EAAO,EAC5CE,KAAKU,IAAMV,KAAKM,GAAKN,KAAKS,IAAM,EACzBT,MAKXJ,EAAQ,IAAIV,EAGRE,EAAOC,QAAUH,EA1HxB,0bCXD,IAAM0B,EACJC,eACA,SAAAC,UACEA,GAGSC,EAAOH,GAAO,20BAApB,QAuHMI,EAAMJ,GAAO,0aAAnB,UAiDMK,EAAaL,GAAO,0TAA1B,iBA0BMM,EAASN,GAAO,2OAAtB,eAgCMO,EAAOP,GAAb,UCxODA,EACJC,eACA,SAAAC,UACEA,GAGSC,EAAOH,GAAO,uyBAApB,UA6FMI,EAAMJ,GAAO,y/DAAnB,eAqLMM,EAASN,GAAO,qkBAAtB,UAuDMQ,EAAMR,GAAO,gDAAnB,gBC/UCS,EAAmCR,OAAnCQ,eAAgBC,EAAmBT,OAAnBS,eAClBC,GAAU,oBAAAC,SAAkCA,SAA5CD,MASC,SAAAE,EAAAC,EAAAC,GACLL,KAIEI,EAAA,cAGEE,EAAID,EAARzB,OACO0B,KAAK,KACNC,EAAUF,EAAdC,MACA,iBAAIC,EAA6B,KACzBC,EAAYD,EAAlBE,cACID,IAAJD,IAEOhB,gBAALc,OACEC,GAAAE,KAGFA,KAIJD,IAAA,SAGFH,EAIK,SAAAM,EAAAC,OACCC,KAEFC,aACJA,KAAAF,EACMV,OAAJY,QACEA,GAAsBF,EAAtBE,WAIJD,EA/CFE,MACU,SAAAC,EAAAC,EAAAC,UACCF,UAAPE,KCLJ,IAAMC,EACJ3B,aACA,SAAAC,UACEA,GAGS2B,EAAgBD,EAAtB,6BACME,EAAWF,EAAjB,yBACMG,EAAYH,EAAlB,8BACMI,EAAYJ,EAAlB,kBACMK,EAAiBL,2FAGjBM,EAAoBN,EAA1B,yBACMO,EAAkBP,0XCd/B,IAKMjB,GAAU,oBAAAC,SAAkCA,SAA5CD,MACSyB,EAAeC,MAAM7C,UAA5B8C,MACAtC,EAAWC,OAAXD,OACFuC,EAAY,iBAAO,oBAAAC,OAAA,KAAPA,QAElB7B,MACU,SAAAc,EAAAC,EAAAC,UACCF,UAAPE,KAYJ,IAAMc,EAA4B,SAAAC,EAAAC,MAE9B,qBAAAD,EAAA,YAAAE,EAAAF,KADF,mBAESA,EAAPG,oBAEA,SAMEC,EAAJ,KAGEH,iBACAA,6BAHF,6BAKWA,6BALX,8BAQMI,EAAa,aAAeD,EAAS,IAATA,EAAlC,eAGSJ,EAAAG,aAAAE,cAAsC,SAAAC,UAEzCA,KAGJ,MAAAC,kBAIAC,KACE,uBAAAH,EADF,0BAGA,cAIJ,SAAAI,QAAyBX,EAAsBY,UAAA9D,OAAA,QAAA+D,IAAAD,UAAA,GAAAA,UAAA,GAAbb,IAC1Be,EAAY,SAAAC,UAAQJ,EAARI,SAMlBC,QAAA,WAMAC,YAEIjB,IAAYA,EAAZG,UAAJ,IAAmCH,6BAGjCkB,aAAA,EAEAJ,MAGIK,EAAmBnB,EAAzBG,SACIiB,GAAJ,EACIC,GAAJ,EAEMlB,EAAaH,EA3B0BG,SA6B3CmB,EASEtB,EAtCyCsB,iBA8B3CC,EAQEvB,EAtCyCuB,oBA+B3CC,EAOExB,EAtCyCwB,KAgC3CC,EAMEzB,EAtCyCyB,aAsCzCzB,EAtCyC0B,aAiC3CA,OAjC2Cb,IAAAc,EAiC5B3B,gBAAuBA,EAjCK4B,gBAAAD,EAkC3CE,EAIE7B,EAtCyC6B,KAmC3CC,EAGE9B,EAtCyC8B,QAoC3CC,EAEE/B,EAtCyC+B,UAqC3CC,EACEhC,EAtCyCgC,gBA8C7C,mBAAIT,EAA2C,KACvCU,EAAW9B,gBAAjB,YACI8B,WAAoBA,UAAxBC,kBACaD,UAAXC,mBAIEC,EAAqBlC,IAA3BkB,GAIMiB,EAAYD,EAAqBA,aAArBA,IAAlB,KAzD6ChC,EA4D3CkC,EA5D2CC,EAAAD,eA6D3CE,EA7D2CD,EAAAC,mBA8D3CC,EA9D2CF,EAAAE,qBA+D3CC,EA/D2CH,EAAAG,uBAiErCC,EAAevB,EAjEsBuB,WAmEzCC,OAKJzB,YACEmB,YACOA,EAAPO,oBAFF,IAGEzC,mBAGAd,EA9E2CA,EA+E3CC,EA/E2CA,EAgF3CC,GAhF2CA,EAiF3CC,GAjF2CA,EAkF3CE,GAlF2CA,EAmF3CC,GAnF2CA,EAsFvCF,GAtFuCA,EA6FzCoD,GAAJ,KACMC,GAAuBzE,qCAA7BN,KASIgF,GAAJ,KACMC,GAAuB3E,gCAA7BL,KAQIiF,GAAJ,KAGIC,GAAJ,KAGIC,IAAJ,EAGIC,IAAJ,EAGIC,IAAJ,EAGIC,IAAJ,EAKIC,IAAJ,EAGIC,IAAJ,EAGIC,IAAJ,EAIIC,IAAJ,EAMIC,IAAJ,EAIIC,IAAJ,EAMIC,IAAJ,EAGIC,IAAJ,EAGIC,IAAJ,EAIIC,IAAJ,EAGIC,MAGEC,GAAkB7F,MAAa,wDAArC,UAYM8F,GAAgB9F,MAAa,+BAAnC,UASI+F,GAAJ,KACMC,GAA8BhG,MAAa,kGAAjD,UAiBIiG,GAAJ,KAKMC,GAAcpE,gBAApB,QAQMqE,GAAe,SAAAC,GACfH,IAAUA,KAAdG,IAKIA,GAAJ,iBAAY,IAAAA,EAAA,YAAArE,EAAAqE,eAMV,iBAAAA,EACIpG,KAAaoG,EADjB5B,cADFC,MAKE,iBAAA2B,EACIpG,KAAaoG,EADjB1B,cADFC,MAKE,sBAAAyB,EACIpG,KAAaoG,EADjBC,mBADFL,MAIc,gBAAAI,EAAuBpG,KAAaoG,EAApCxB,mBACA,gBAAAwB,EAAuBpG,KAAaoG,EAApCvB,mBACC,iBAAAuB,GAAwBA,EAAxBR,iBAzBkB,IA0BfQ,sBA1Be,IA2BfA,qBACQA,4BA5BO,KA6BfA,oBA7Be,KA8BZA,uBA9BY,KA+BhBA,mBA/BgB,KAgCpBA,eAhCoB,KAiCXA,wBAjCW,KAkCbA,sBAlCa,KAmCpBA,eAnCoB,UAoClBA,mBApCkB,IAqClBA,kBACJA,aAtCsB,KAwChBA,sBAAjBE,GAEApB,SACE,GAGFK,SACE,GAIFK,QACiB5F,iBAAfN,YAEA,IAAIkG,YACFpB,GAAAlF,KACAoF,GAAA6B,KAGF,IAAIX,WACFpB,GAAAjF,KACAmF,GAAA8B,KACA9B,GAAA/E,KAGF,IAAIiG,kBACFpB,GAAAhF,KACAkF,GAAA8B,KACA9B,GAAA/E,KAGF,IAAIiG,cACFpB,GAAA/E,KACAiF,GAAA+B,KACA/B,GAAA/E,KAKAyG,EAAJM,WACMlC,KAAJC,QACiBlE,EAAfiE,OAGFA,GAAuB4B,EAAvBM,WAGEN,EAAJO,WACMjC,KAAJC,QACiBpE,EAAfmE,OAGFA,GAAuB0B,EAAvBO,WAGEP,EAAJC,qBACEN,GAA8BK,EAA9BC,mBAIFX,QACE,aAIFP,MACEX,IAAuB,cAAvB,SAIEA,GAAJoC,SACEpC,IAAA,UAKFrF,KACEiH,MAGFA,IAQIS,GAAe,SAAAC,KACnBlE,QAAAmE,MAAyB3G,QAAzB0G,UAEEE,WAAAC,YAAAH,GACA,MAAA1E,KACA8E,UAAAnD,IAUEoD,GAAmB,SAAAC,EAAAN,SAErBlE,QAAAmE,gBACaD,mBADUM,QAEfN,IAER,MAAA1E,KACAQ,QAAAmE,gBAAuB,UAEfD,MAIVO,gBAAAD,IASIE,GAAgB,SAAAC,OAEhBC,SACAC,YAEJpC,KACU,oBAARkC,MACK,KAECG,EAAUH,QAAhB,aACoBG,GAAWA,EAA/B,QAEUH,QAAYE,EAApBhJ,YAKJsE,SAEU,IAAAW,GAAAiE,gBAAAJ,EAAN,aACA,MAAAnF,OAIJY,KACE4B,IAAA,WAKE4C,IAASA,EAAbI,gBAAkC,KAExBC,KADF7D,qBAAN,KADgC6D,OAGhCb,WAAAC,YAA4BY,aAA5BC,qBACAZ,UAAiBpD,EACbA,aADaA,GAAjByD,SAKFE,KACEI,KAAAE,aACEjG,iBADF2F,GAEED,sBAFF,MAOKrD,SAA+BgB,UAA/BhB,QAAP,IAYE1B,EAAJI,6BAGkByE,GAAZ,6DAGIE,cAAJ,gBACE,GAEF,MAAApF,uBAKYkF,GAAZ,wCACIE,uCAAJ,iBACE,GAEF,MAAApF,aAUA4F,GAAkB,SAAAtF,UACfwB,EAAA+D,KACLvF,iBADKA,IAGLU,eAA0BA,EAA1BA,aAAoDA,EAH/C8E,UAIL,kBACS9E,EAAP+E,gBALJ,IA0CIC,GAAU,SAAAC,SACP,qBAAAlF,EAAA,YAAApB,EAAAoB,IACHkF,aADGlF,EAEHkF,oBACE,IAAAA,EAAA,YAAAtG,EAAAsG,KADFA,iBAESA,EAAPC,UAJN,iBAKaD,EAAPE,UAWFC,GAAe,SAAAC,EAAAC,EAAAC,GACdrE,EAALmE,MAIAA,GAAAG,QAA0B,SAAAC,KACxBZ,KAAAxF,EAAAiG,EAAAC,EAAA1C,OAeE6C,GAAoB,SAAAJ,OACpBK,eAGJ,yBAAAL,EAAA,MAnEmB,SAAAM,WACfA,gBAAuBA,aAA3BvF,GAKE,iBAAOuF,EAAPT,UAAA,iBACOS,EAAPC,aADA,mBAEOD,EAAP/B,aACE+B,wBAHF3F,GAAA,mBAIO2F,EAAP3B,iBALF,mBAMS2B,EAAPE,cA2DEC,CAAJT,aACEA,IACA,MAIIU,EAAUV,WAAhBpI,oBAGA,sBAAAoI,WAAiDU,cAElC5E,MAIVA,GAAD4E,IAA0BxE,GAA9BwE,GAAoD,IAGhD1D,KACCG,GADDH,IADF,mBAGSgD,EAAPW,2BAGQC,EAAeZ,EAArBa,YACAF,mBAAA,WAEEvF,EACIA,aADJA,GAFFwF,GAMA,MAAAlH,cAGJsG,IACA,QAIEU,gBAA0BV,kBAA9B,oBACEA,IACA,GAGEU,eAAyBV,kBAA7B,mBACEA,IACA,KAKAzD,IACCyD,EADDzD,mBAEEyD,EAADK,SAAyBL,UAF1BzD,oBAGA,KAAAuE,KAAUd,EAJZO,iBAMErG,QAAAmE,MAAyB3G,QAASsI,EAAlCe,cACIf,EAAJa,YACEA,UAAwBb,yBAAxB,UAEAa,UAAwBb,2BAAxB,SAKAxD,IAAJ,IAA0BwD,qBAEdA,EAAVO,aACUF,UAAV,MACUA,UAAV,KACIL,gBAAJK,MACEnG,QAAAmE,MAAyB3G,QAASsI,EAAlCe,gBACAR,YAAAF,OAKJ,wBAAAL,EAAA,OAEA,IAYIgB,GAAoB,SAAAC,EAAAC,EAAAC,MAGtBpE,KACCmE,UADDnE,SACoBmE,KACnBC,QAAqBA,KAHxB3D,WAKE,KAOEnB,IAAmB7D,QAAvB0I,SAEO,GAAI9E,IAAmB3D,QAAvByI,QAGA,KAAKlF,GAADkF,IAAyB/E,GAA7B+E,UACL,EAGK,GAAI7D,GAAJ6D,SAIA,GAAIxI,QAAoByI,aAAxB,WAIA,GACJD,WAAD,eAAqBA,GAArB,WACAD,GADA,IAEAE,qBACA/D,GAJK6D,GAUA,GACL3E,KACC3D,QAAuBwI,aAFnB,WAOA,GAAAA,SAIL,SAGF,GAaIC,GAAsB,SAAApB,OACtBqB,SACAF,SACAD,SACAI,SACA7J,YAEJ,2BAAAuI,EAAA,UAEMuB,EAAevB,EAT2BuB,cAYhDA,OAIMC,YAAY,8CAIGxF,UAEjBuF,EAAJxL,OAGO0B,KAAK,SACH8J,EAAP9J,GACQiH,EAFE+C,EAAA/C,KAEIgD,EAFJD,EAAAC,kBAGFL,QAARM,SACSjD,EAAT9G,gBAGAgK,SAAAV,IACAW,UAAAV,IACAW,UAAA,KACA,wBAAA9B,EAAAwB,KACQA,EAARK,UAOEX,oBACAlB,YACAuB,EAHFQ,KAKWR,EAATQ,KACa3K,aACb,KAAA4I,MACAtB,EAAAsB,GACIuB,aAAJ9J,KACE+I,aAAA,KAA+Bc,EAA/BH,WAEG,IAGL,YAAAtB,UAAA,SACAqB,GADA,SAEAC,GACAK,EAHAM,WAIC9F,QAAyBG,GAPrB+E,aAcL,OAAIxC,KACF8B,aAAA9B,EAAA,OAGFA,EAAAsB,MAIGwB,EAALM,UAKAtF,UACU2E,YAAR,MACQA,UAAR,UAIIF,EAAQjB,WAAdpI,iBACKoJ,OAALG,OAMEO,IACEM,eAAAN,EAAAhD,EAAAyC,KAGAX,aAAA9B,EAAAyC,KAGFjH,QAAA+H,MACA,MAAAvI,SAIJ,0BAAAsG,EAAA,QAQIkC,GAAqB,SAArBA,EAAqBC,OACrBC,SACEC,EAAiB/C,GAAvB6C,UAGA,0BAAAA,EAAA,MAEQC,EAAaC,EAArBC,eAEE,yBAAAF,EAAA,MAGIhC,GAAJgC,KAKIA,qBAAJ7H,KACqB6H,EAAnB/B,YAIF+B,OAIF,yBAAAD,EAAA,gBAWFI,SAAqB,SAAA1D,EAAAnB,OACfyB,SACAqD,SACAxC,SACAyC,SACAC,YAIJ7D,MACE,eAIE,iBAAAA,IAA8Ba,GAAlCb,GAAkD,IAEhD,mBAAWA,EAAPxJ,eACI,IAAAsN,UAAN,iCAGA,mBADQ9D,EAARxJ,kBAEQ,IAAAsN,UAAN,uCAMD5I,EAALI,YAA4B,IAExB,WAAAd,EAAOJ,EAAP2J,eADF,mBAES3J,EAAP2J,aACA,IACA,iBAAI/D,SACK5F,eAAP4F,MAGEa,GAAJb,UACS5F,eAAoB4F,EAA3BL,kBAIJK,KAIFnC,OACEgB,KAIFxD,WAEA+C,SAEO,GAAI4B,aAAJpE,EAKD+H,UAFG5D,GAAP,gBACeO,4BAAf,IACIqD,UAAJ,SAAmCA,aAEjCA,EACK,SAAIA,aACTA,IAGAK,YAAAL,OAEG,KAGH5F,KAAAJ,KAAAC,KADF,IAIEoC,sBAEOzD,EACHA,aADGA,GAAPyD,SAMKD,GAAPC,WAISjC,QAAPvB,EAKA8D,GAAJxC,OACewC,EAAb2D,oBAIIC,EAAezD,GAAgBrC,KAArCkC,GAGQa,EAAc+C,EAAtBT,YAEMtC,gBAA8BA,IAAlCyC,GAKIrC,GAAJJ,KAKIA,qBAAJzF,MACqByF,EAAnBK,YAIFL,KAEAA,QAGF,KAGA/C,UACE4B,KAIFjC,GAAgB,IACdC,SACenB,OAA4ByD,EAAzChE,eAEOgE,EAAP2D,cAEED,YAAuB1D,EAAvB2D,mBAGF3D,SAGFrC,OAMenB,YAAb,IAGF+G,MAGEM,EAAiBvG,GAAiB0C,EAAjB1C,UAAkC0C,EAAvD0B,iBAGArE,UACmBwG,YAAjB,MACiBA,UAAjB,MAGK5H,EACHA,aADGA,GAAP4H,KAWFC,UAAsB,SAAAvF,MACpBA,OACA,KAQFwF,YAAwB,cACtB,SACA,KAaFC,iBAA6B,SAAAC,EAAA/B,EAAAF,GAE3B5D,eAIM0D,EAAQmC,EAAdxL,cACMsJ,EAASG,EAAfzJ,qBACOoJ,OAAPG,MAUFkC,QAAoB,SAAAtD,EAAAuD,GAClB,mBAAIA,MAIJvD,GAAoBnE,WACpBmE,GAAA1B,KAAAiF,OAUFC,WAAuB,SAAAxD,GACjBnE,EAAJmE,MACEA,GAAAkC,SAUJuB,YAAwB,SAAAzD,GAClBnE,EAAJmE,OACEA,UASJ0D,eAA2B,iBAI3B1J,EAGaH,wCC9qCflD,OAAOgN,eAAexO,EAAS,cAAgBiM,OAAO,IAItD,IAAIwC,GACA,OACA,OACA,KACA,MACA,UACA,QACA,KACA,MACA,QACA,SACA,OACA,OACA,QACA,SACA,QACA,OAIAC,GACA,UACA,UACA,QACA,aACA,SACA,KACA,MACA,KACA,KACA,WACA,aACA,SACA,SACA,OACA,KACA,KACA,KACA,KACA,KACA,KACA,SACA,SACA,KACA,KACA,OACA,MACA,WACA,KACA,SACA,IACA,MACA,UACA,QACA,QACA,QACA,QACA,KACA,KACA,SAEAC,EAAoB,GACpBC,EAAwB,GACxBC,EAAyB,GACzBC,EAAsB,GACtBC,EAAyB,GACzBC,EAA0B,GAC1BC,EAAsB,GACtBC,EAAqB,GACrBC,EAAuB,GACvBC,EAAsB,GACtBC,EAAyB,sBACzBC,EAA4B,UAkYhC,SAASC,EAAkBC,EAAQC,GAE/B,IADA,IAAI5O,EAAS2O,EAAO3O,OACXK,EAAIuO,EAAWvO,EAAIL,EAAQK,IAChC,GAAIwO,EAAaF,EAAOlO,WAAWJ,IAC/B,OAAOA,EAKf,OAAOL,EAEX,SAAS8O,EAA8BC,GACnC,OAASA,GAAY,IAAMA,GAAY,IAClCA,GAAY,IAAMA,GAAY,IAC9BA,GAAY,IAAMA,GAAY,IAEvC,SAASC,EAAYL,EAAQM,GACzB,IAAIC,EAAgBP,EAAOlO,WAAWwO,GACtC,GAAIC,IAAkBpB,EAClB,OAAO,EAEN,GAAIoB,IAAkBb,EAAoB,CAC3C,IAAIc,EAAkB,IAAMtB,EAAeuB,KAAK,KAAO,OAEvD,OADoB,IAAIC,OAAO,KAAOF,EAAkB,kBAAmB,KACtDpE,KAAK4D,EAAO3L,MAAMiM,IAGvC,OAAO,EAGf,SAASJ,EAAaE,GAClB,OAAqB,IAAbA,GAA+B,KAAbA,GAAgC,KAAbA,GAAgC,KAAbA,GAAgC,KAAbA,EAMvF,SAASO,EAAyBC,GAC9B,IAAK,IAAIlP,EAAIkP,EAASvP,OAAS,EAAGK,GAAK,EAAGA,IAAK,CAC3C,IAAIsK,EAAU4E,EAASlP,GACvB,GAAgB,OAAZsK,GAAgC,OAAZA,EACpB,OAAO,EAEX,GAAgB,OAAZA,GAAgC,UAAZA,GAAmC,OAAZA,EAC3C,OAAO,EAGf,OAAO,EAEX,SAAS6E,EAAmBb,GACxB,OAAOA,EAAO/C,OAAO6D,QAAQhB,EAA2B,KAE5D,SAASiB,EAAWf,EAAQM,GACxB,IAAIF,EAAWJ,EAAOlO,WAAWwO,GACjC,GAA4B,QAAZ,MAAXF,GAA+B,CAEhC,IAAIY,EAAehB,EAAOlO,WAAWwO,EAAQ,GAC7C,GAAgC,QAAZ,MAAfU,GACD,OAAOC,OAAOC,aAAad,EAAUY,GAG7C,OAAOC,OAAOC,aAAad,GA7Z/B5P,EAAQ2Q,QAVR,SAAcnB,EAAQoB,EAAWC,GAE7B,YADgB,IAAZA,IAAsBA,MACrBrB,GAGLA,EAASA,EAAOrP,WACT0Q,EAAQnP,KAKnB,SAAkB8N,EAAQoB,EAAWC,GAQjC,IAPA,IAAIC,EAAKD,EAAQE,YAAaA,OAAqB,IAAPD,EAAgB,EAAIA,EAAIE,EAAKH,EAAQI,UAAWA,OAAmB,IAAPD,EAAgB,IAAWA,EAAIE,EAAKL,EAAQM,SAAUA,OAAkB,IAAPD,EAAgBE,IAAWF,EAChMG,EAAWJ,EAAUpQ,OACrByQ,EAAW,EACXpQ,EAAI,EACJqQ,GAAuB,EACvBnB,KACAvP,EAAS2O,EAAO3O,OACbK,EAAIL,EAAQK,IAAK,CACpB,IAAIsQ,EAAOtQ,EAAIsO,EAAO3L,MAAM3C,GAAKsO,EAC7BiC,EAAYD,EAAKE,OAAOrC,GACxBsC,EAAgBF,GAAa,EAAIA,EAAYD,EAAK3Q,OAEtD,GADAK,GAAKyQ,GACAJ,EACD,GAAIpB,EAAyBC,IAEzB,IADAiB,GAAYhB,EAAmBsB,IAAkBH,EAAK3Q,OAAS2Q,EAAOA,EAAK3N,MAAM,EAAG4N,IAAY5Q,QACjF+P,EAAW,CACtB1P,GAAKyQ,EACL,YAKJ,IADAN,GAAYM,GACGf,EAAW,CACtB1P,EAAIb,KAAKuR,IAAI1Q,EAAImQ,EAAWT,EAAW,GACvC,MAIZ,IAAmB,IAAfa,EACA,MAEJ,IAAI7B,EAAWJ,EAAOlO,WAAWJ,GACjC,GAAI0O,IAAaV,EAAoB,CACjC,IAAIsB,EAAehB,EAAOlO,WAAWJ,EAAI,GACrC2Q,EAAerB,IAAiB5B,EACpC,GAAIiD,GAA4C,OAA5BrC,EAAOpP,OAAOc,EAAI,EAAG,GAAa,CAClD,IAAI4Q,EAAkBtC,EAAOuC,QAAQ,SAAO7Q,EAAI,GAAK,EACrDA,EAAI4Q,EAAkB,OAErB,GAAID,GAA4C,YAA5BrC,EAAOpP,OAAOc,EAAI,EAAG,GAAkB,CAC5D,IAAI8Q,EAAgBxC,EAAOuC,QAAQ,MAAO7Q,EAAI,GAAK,EACnDA,EAAI8Q,EAAgB,MAInB,CAED,GAAIX,IAAaT,GACbpB,EAAOlO,WAAWJ,EAAI,KAAO8N,EAAyB,CACtDqC,IACA,MAKJ,IAHA,IAAIY,EAAyB,EACzBC,EAAWhR,EACXiR,GAAmB,IACgB,CAEnC,KADAD,GACgBrR,EACZ,MAAM,IAAIuR,MAAM,iBAAmB5C,GAEvC,IAAI6C,EAAa7C,EAAOlO,WAAW4Q,GACnC,GAAIC,EACIF,EACII,IAAeJ,IACfE,GAAmB,GAInBzC,EAAa2C,GACbF,GAAmB,EAEdE,IAAejD,IACpB+C,GAAmB,EACnBD,UAIP,GAAIG,IAAelD,EAAsB,CAC1C,KAAOO,EAAaF,EAAOlO,WAAW4Q,EAAW,KAC7CA,IAEJC,GAAmB,EACnB,IAAIG,EAAyB9C,EAAOlO,WAAW4Q,EAAW,GACtDI,IAA2BzD,GAC3ByD,IAA2BvD,GAC3BkD,EAAyBK,EACzBJ,KAGAD,EAAyB,OAG5B,GAAII,IAAejD,EAAqB,CACzC,IAAImD,EAAW/C,EAAOlO,WAAWJ,EAAI,KAAO8N,EACxCwD,EAAoBtR,GAAKqR,EAAW,EAAI,GACxCE,EAAkBpS,KAAKqS,IAAInD,EAAkBC,EAAQgD,GAAoBN,GACzE1G,EAAUgE,EACT3L,MAAM2O,EAAmBC,GACzB/P,cAKL,GAJI8I,EAAQlK,WAAWkK,EAAQ3K,OAAS,KAAOmO,IAE3CxD,EAAUA,EAAQ3H,MAAM,EAAG2H,EAAQ3K,OAAS,IAE5C0R,EAAU,CACV,IAAII,EAAiBvC,EAASrD,MAC9B,GAAI4F,IAAmBnH,EACnB,MAAM,IAAI4G,MAAM,iBAAmB5C,GAEvC,IAAgB,SAAZhE,GAAkC,QAAZA,MACtB+F,EACInB,EAASwC,SAAS,SAAWxC,EAASwC,SAAS,UAE/CvB,GAAYN,GACGH,EACX,MAIZ,GAAIlC,EAAekE,SAASpH,KAGnB+F,KACDD,EACeH,EAAU,CAIrBf,EAASjH,KAAKqC,GACd,YAKX,GAAIiD,EAAcmE,SAASpH,IAC5BgE,EAAOlO,WAAW4Q,EAAW,KAAOlD,GACpC,GAAgB,OAAZxD,GAEA,KADA8F,EACeH,EACX,WAGH,GAAgB,QAAZ3F,IACL6F,GAAYN,GACGH,EACX,WAKRR,EAASjH,KAAKqC,GACE,SAAZA,GAAkC,QAAZA,IACtB+F,GAAuB,GAG/BrQ,EAAIgR,EACJ,OAGR,GAAIb,EAAWT,GAAaU,EAAWH,EACnC,YAIP,GAAIvB,IAAad,EAAqB,CAGvC,IAFA,IAAIoD,EAAWhR,EAAI,EACf2R,GAAuB,IACY,CACnC,IAAIC,GAAatD,EAAOlO,WAAW4Q,GACnC,IAAIvC,EAA8BmD,IAG7B,IAAIA,KAAe7D,EACpB,MAGA4D,GAAuB,EACvB,MAPAX,IAUR,IAAKX,KACDF,EACeT,EACX,MAGJiC,IACA3R,EAAIgR,QAGP,GAAItC,IAAajB,GAClB,IAAK4C,IAAyBpB,EAAyBC,GAAW,CAE9D,KADAiB,EACeT,EACX,MAGJ,KADAU,EACeH,EACX,WAIP,CACD,IAAKI,KACDF,EACeT,EACX,MAIR,IAAIJ,EAAehB,EAAOlO,WAAWJ,EAAI,GACT,QAAZ,MAAfsP,IACDtP,KAIZ,GAAImQ,EAAWT,EAAW,CACtB,IAAImC,GAqMZ,SAAwBvD,EAAQM,GAC5B,IAAIkD,EAAOzC,EAAWf,EAAQM,GAC9B,GAAa,MAATkD,EACA,OAAuC,CACnClD,IACA,IAAIU,EAAehB,EAAOlO,WAAWwO,GACrC,IAAIH,EAA8Ba,GAG7B,IAAIA,IAAiBvB,EAAqB,CAC3C+D,GAAQvC,OAAOC,aAAaF,GAC5B,MAGA,MAPAwC,GAAQvC,OAAOC,aAAaF,GAWxC,OAAOwC,EAvNYC,CAAezD,EAAQtO,GACtC,GAAI+P,EAAW,CAEX,IADA,IAAIiC,GAAYhS,EAAI6R,GAASlS,OACtB2O,EAAOlO,WAAW4R,MAAehE,GACpCM,EAAOlO,WAAW4R,GAAY,KAAOlE,GAAyB,CAC9D,IAAImE,GAAgB3D,EAAOuC,QAAQ,IAAKmB,GAAY,GAAK,EACzD,IAAIC,GAIA,MAHAD,GAAYC,GAMhBD,KAAcA,KAAc1D,EAAO3O,QAAUgP,EAAYL,EAAQ0D,OAIjEhS,GAAK6R,GAASlS,OACdkS,GAAWvD,EAAO4D,OAAOlS,IAKjC,KAAoB,MAAb6R,IAAoBvD,EAAOlO,WAAWJ,EAAI,KAAO8N,GAAyB,CAC7E,IAAIxD,EAAU4E,EAASrD,MACnBsG,GAAc7H,EAAUgE,EAAOuC,QAAQ,IAAK7Q,EAAI,IAAM,EAC1D,IAAqB,IAAjBmS,IAAsB7D,EAAO3L,MAAM3C,EAAI,EAAGmS,IAAa5G,SAAWjB,EAClE,MAAM,IAAI4G,MAAM,iBAAmB5C,GAEvCtO,EAAImS,GAAc,EAClBN,GAAWvD,EAAO4D,OAAOlS,GAE7B,GAAIA,EAAIsO,EAAO3O,OAAQ,CACnB,IAAKgQ,EAAQyC,WAET,IAAK,IAAIC,GAAIrS,EAAI+P,EAAUpQ,OAAQ0S,IAAK,EAAGA,KAAK,CAC5C,IAAI3D,EAAWJ,EAAOlO,WAAWiS,IACjC,GAAI3D,IAAaR,GAAuBQ,IAAaX,EAKjD,MAEC,GAAIW,IAAajB,GAAqBiB,IAAaV,EAAoB,CACxEhO,EAAIqS,GACJ,MAEC,GAAI7D,EAAaE,GAAW,CAC7B1O,EAAIqS,IAAKtC,EAAY,EAAI,GACzB,OAIZ,IAAI/Q,GAASsP,EAAO3L,MAAM,EAAG3C,GAI7B,IAHK2O,EAAYL,EAAQtO,KACrBhB,IAAU+Q,GAEPb,EAASvP,QAAQ,CACpB,IAAI2K,EAAU4E,EAASrD,MACvB7M,IAAU,KAAOsL,EAAU,IAE/B,OAAOtL,SAGV,GAAIoR,EAAWH,EAAU,CAE1B,IADA,IAAIjR,GAASsP,EAAO3L,MAAM,EAAG3C,GACtBkP,EAASvP,QAAQ,CACpB,IAAI2K,EAAU4E,EAASrD,MACvB7M,IAAU,KAAOsL,EAAU,IAE/B,OAAOtL,GAEX,OAAOsP,EAtSDgE,CAAShE,EAAQoB,EAAWC,GAwStC,SAAuBrB,EAAQoB,EAAWC,GAMtC,IALA,IAAIC,EAAKD,EAAQI,UAAWA,OAAmB,IAAPH,EAAgB,IAAWA,EAAIE,EAAKH,EAAQM,SAAUA,OAAkB,IAAPH,EAAgBI,IAAWJ,EAChIK,EAAWJ,EAAUpQ,OACrByQ,EAAW,EACXpQ,EAAI,EACJL,EAAS2O,EAAO3O,OACbK,EAAIL,OACPwQ,EACeT,GAFA1P,IAAK,CAKpB,IAAI0O,EAAWJ,EAAOlO,WAAWJ,GACjC,GAAI0O,IAAajB,GAEb,KADA2C,EACeH,EACX,WAGH,GAA4B,QAAZ,MAAXvB,GAA+B,CAErC,IAAIY,EAAehB,EAAOlO,WAAWJ,EAAI,GACT,QAAZ,MAAfsP,IACDtP,KAIZ,GAAImQ,EAAWT,EAAW,CACtB,IAAImC,EAAWxC,EAAWf,EAAQtO,GAClC,GAAI+P,EAAW,CACX,IAAIiC,EAAYhS,EAAI6R,EAASlS,OAC7B,GAAIqS,IAAc1D,EAAO3O,OACrB,OAAO2O,EAEN,GAAIA,EAAOlO,WAAW4R,KAAevE,EACtC,OAAOa,EAAO3L,MAAM,EAAG3C,EAAI6R,EAASlS,QAG5C,IAAKgQ,EAAQyC,WAET,IAAK,IAAIC,EAAIrS,EAAI+P,EAAUpQ,OAAQ0S,GAAK,EAAGA,IAAK,CAC5C,IAAI3D,EAAWJ,EAAOlO,WAAWiS,GACjC,GAAI3D,IAAajB,EAAmB,CAChCzN,EAAIqS,EACJR,EAAW,KACX,MAEC,GAAIrD,EAAaE,GAAW,CAC7B1O,EAAIqS,GAAKtC,EAAY,EAAI,GACzB,OAIZ,OAAOzB,EAAO3L,MAAM,EAAG3C,IAAmB,OAAb6R,EAAoB,GAAK9B,GAErD,OAAIK,EAAWH,EACT3B,EAAO3L,MAAM,EAAG3C,GAEpBsO,EAhWDiE,CAAcjE,EAAQoB,EAAWC,IAL5B","file":"vendor~product.bundle.1f48b7b1c3dbd8b20ca1.js","sourcesContent":["'use strict'\nvar MurmurHash3 = require('imurmurhash')\n\nmodule.exports = function (uniq) {\n if (uniq) {\n var hash = new MurmurHash3(uniq)\n return ('00000000' + hash.result().toString(16)).substr(-8)\n } else {\n return (Math.random().toString(16) + '0000000').substr(2, 8)\n }\n}\n","/**\n * @preserve\n * JS Implementation of incremental MurmurHash3 (r150) (as of May 10, 2013)\n *\n * @author <a href=\"mailto:jensyt@gmail.com\">Jens Taylor</a>\n * @see http://github.com/homebrewing/brauhaus-diff\n * @author <a href=\"mailto:gary.court@gmail.com\">Gary Court</a>\n * @see http://github.com/garycourt/murmurhash-js\n * @author <a href=\"mailto:aappleby@gmail.com\">Austin Appleby</a>\n * @see http://sites.google.com/site/murmurhash/\n */\n(function(){\n var cache;\n\n // Call this function without `new` to use the cached object (good for\n // single-threaded environments), or with `new` to create a new object.\n //\n // @param {string} key A UTF-16 or ASCII string\n // @param {number} seed An optional positive integer\n // @return {object} A MurmurHash3 object for incremental hashing\n function MurmurHash3(key, seed) {\n var m = this instanceof MurmurHash3 ? this : cache;\n m.reset(seed)\n if (typeof key === 'string' && key.length > 0) {\n m.hash(key);\n }\n\n if (m !== this) {\n return m;\n }\n };\n\n // Incrementally add a string to this hash\n //\n // @param {string} key A UTF-16 or ASCII string\n // @return {object} this\n MurmurHash3.prototype.hash = function(key) {\n var h1, k1, i, top, len;\n\n len = key.length;\n this.len += len;\n\n k1 = this.k1;\n i = 0;\n switch (this.rem) {\n case 0: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) : 0;\n case 1: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) << 8 : 0;\n case 2: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) << 16 : 0;\n case 3:\n k1 ^= len > i ? (key.charCodeAt(i) & 0xff) << 24 : 0;\n k1 ^= len > i ? (key.charCodeAt(i++) & 0xff00) >> 8 : 0;\n }\n\n this.rem = (len + this.rem) & 3; // & 3 is same as % 4\n len -= this.rem;\n if (len > 0) {\n h1 = this.h1;\n while (1) {\n k1 = (k1 * 0x2d51 + (k1 & 0xffff) * 0xcc9e0000) & 0xffffffff;\n k1 = (k1 << 15) | (k1 >>> 17);\n k1 = (k1 * 0x3593 + (k1 & 0xffff) * 0x1b870000) & 0xffffffff;\n\n h1 ^= k1;\n h1 = (h1 << 13) | (h1 >>> 19);\n h1 = (h1 * 5 + 0xe6546b64) & 0xffffffff;\n\n if (i >= len) {\n break;\n }\n\n k1 = ((key.charCodeAt(i++) & 0xffff)) ^\n ((key.charCodeAt(i++) & 0xffff) << 8) ^\n ((key.charCodeAt(i++) & 0xffff) << 16);\n top = key.charCodeAt(i++);\n k1 ^= ((top & 0xff) << 24) ^\n ((top & 0xff00) >> 8);\n }\n\n k1 = 0;\n switch (this.rem) {\n case 3: k1 ^= (key.charCodeAt(i + 2) & 0xffff) << 16;\n case 2: k1 ^= (key.charCodeAt(i + 1) & 0xffff) << 8;\n case 1: k1 ^= (key.charCodeAt(i) & 0xffff);\n }\n\n this.h1 = h1;\n }\n\n this.k1 = k1;\n return this;\n };\n\n // Get the result of this hash\n //\n // @return {number} The 32-bit hash\n MurmurHash3.prototype.result = function() {\n var k1, h1;\n \n k1 = this.k1;\n h1 = this.h1;\n\n if (k1 > 0) {\n k1 = (k1 * 0x2d51 + (k1 & 0xffff) * 0xcc9e0000) & 0xffffffff;\n k1 = (k1 << 15) | (k1 >>> 17);\n k1 = (k1 * 0x3593 + (k1 & 0xffff) * 0x1b870000) & 0xffffffff;\n h1 ^= k1;\n }\n\n h1 ^= this.len;\n\n h1 ^= h1 >>> 16;\n h1 = (h1 * 0xca6b + (h1 & 0xffff) * 0x85eb0000) & 0xffffffff;\n h1 ^= h1 >>> 13;\n h1 = (h1 * 0xae35 + (h1 & 0xffff) * 0xc2b20000) & 0xffffffff;\n h1 ^= h1 >>> 16;\n\n return h1 >>> 0;\n };\n\n // Reset the hash object for reuse\n //\n // @param {number} seed An optional positive integer\n MurmurHash3.prototype.reset = function(seed) {\n this.h1 = typeof seed === 'number' ? seed : 0;\n this.rem = this.k1 = this.len = 0;\n return this;\n };\n\n // A cached object to use. This can be safely used if you're in a single-\n // threaded environment, otherwise you need to create new hashes to use.\n cache = new MurmurHash3();\n\n if (typeof(module) != 'undefined') {\n module.exports = MurmurHash3;\n } else {\n this.MurmurHash3 = MurmurHash3;\n }\n}());\n","const freeze =\n Object.freeze ||\n function(x) {\n return x;\n };\n\nexport const html = freeze([\n 'a',\n 'abbr',\n 'acronym',\n 'address',\n 'area',\n 'article',\n 'aside',\n 'audio',\n 'b',\n 'bdi',\n 'bdo',\n 'big',\n 'blink',\n 'blockquote',\n 'body',\n 'br',\n 'button',\n 'canvas',\n 'caption',\n 'center',\n 'cite',\n 'code',\n 'col',\n 'colgroup',\n 'content',\n 'data',\n 'datalist',\n 'dd',\n 'decorator',\n 'del',\n 'details',\n 'dfn',\n 'dir',\n 'div',\n 'dl',\n 'dt',\n 'element',\n 'em',\n 'fieldset',\n 'figcaption',\n 'figure',\n 'font',\n 'footer',\n 'form',\n 'h1',\n 'h2',\n 'h3',\n 'h4',\n 'h5',\n 'h6',\n 'head',\n 'header',\n 'hgroup',\n 'hr',\n 'html',\n 'i',\n 'img',\n 'input',\n 'ins',\n 'kbd',\n 'label',\n 'legend',\n 'li',\n 'main',\n 'map',\n 'mark',\n 'marquee',\n 'menu',\n 'menuitem',\n 'meter',\n 'nav',\n 'nobr',\n 'ol',\n 'optgroup',\n 'option',\n 'output',\n 'p',\n 'pre',\n 'progress',\n 'q',\n 'rp',\n 'rt',\n 'ruby',\n 's',\n 'samp',\n 'section',\n 'select',\n 'shadow',\n 'small',\n 'source',\n 'spacer',\n 'span',\n 'strike',\n 'strong',\n 'style',\n 'sub',\n 'summary',\n 'sup',\n 'table',\n 'tbody',\n 'td',\n 'template',\n 'textarea',\n 'tfoot',\n 'th',\n 'thead',\n 'time',\n 'tr',\n 'track',\n 'tt',\n 'u',\n 'ul',\n 'var',\n 'video',\n 'wbr',\n]);\n\n// SVG\nexport const svg = freeze([\n 'svg',\n 'a',\n 'altglyph',\n 'altglyphdef',\n 'altglyphitem',\n 'animatecolor',\n 'animatemotion',\n 'animatetransform',\n 'audio',\n 'canvas',\n 'circle',\n 'clippath',\n 'defs',\n 'desc',\n 'ellipse',\n 'filter',\n 'font',\n 'g',\n 'glyph',\n 'glyphref',\n 'hkern',\n 'image',\n 'line',\n 'lineargradient',\n 'marker',\n 'mask',\n 'metadata',\n 'mpath',\n 'path',\n 'pattern',\n 'polygon',\n 'polyline',\n 'radialgradient',\n 'rect',\n 'stop',\n 'style',\n 'switch',\n 'symbol',\n 'text',\n 'textpath',\n 'title',\n 'tref',\n 'tspan',\n 'video',\n 'view',\n 'vkern',\n]);\n\nexport const svgFilters = freeze([\n 'feBlend',\n 'feColorMatrix',\n 'feComponentTransfer',\n 'feComposite',\n 'feConvolveMatrix',\n 'feDiffuseLighting',\n 'feDisplacementMap',\n 'feDistantLight',\n 'feFlood',\n 'feFuncA',\n 'feFuncB',\n 'feFuncG',\n 'feFuncR',\n 'feGaussianBlur',\n 'feMerge',\n 'feMergeNode',\n 'feMorphology',\n 'feOffset',\n 'fePointLight',\n 'feSpecularLighting',\n 'feSpotLight',\n 'feTile',\n 'feTurbulence',\n]);\n\nexport const mathMl = freeze([\n 'math',\n 'menclose',\n 'merror',\n 'mfenced',\n 'mfrac',\n 'mglyph',\n 'mi',\n 'mlabeledtr',\n 'mmultiscripts',\n 'mn',\n 'mo',\n 'mover',\n 'mpadded',\n 'mphantom',\n 'mroot',\n 'mrow',\n 'ms',\n 'mspace',\n 'msqrt',\n 'mstyle',\n 'msub',\n 'msup',\n 'msubsup',\n 'mtable',\n 'mtd',\n 'mtext',\n 'mtr',\n 'munder',\n 'munderover',\n]);\n\nexport const text = freeze(['#text']);\n","const freeze =\n Object.freeze ||\n function(x) {\n return x;\n };\n\nexport const html = freeze([\n 'accept',\n 'action',\n 'align',\n 'alt',\n 'autocomplete',\n 'background',\n 'bgcolor',\n 'border',\n 'cellpadding',\n 'cellspacing',\n 'checked',\n 'cite',\n 'class',\n 'clear',\n 'color',\n 'cols',\n 'colspan',\n 'controls',\n 'coords',\n 'crossorigin',\n 'datetime',\n 'default',\n 'dir',\n 'disabled',\n 'download',\n 'enctype',\n 'face',\n 'for',\n 'headers',\n 'height',\n 'hidden',\n 'high',\n 'href',\n 'hreflang',\n 'id',\n 'integrity',\n 'ismap',\n 'label',\n 'lang',\n 'list',\n 'loop',\n 'low',\n 'max',\n 'maxlength',\n 'media',\n 'method',\n 'min',\n 'multiple',\n 'name',\n 'noshade',\n 'novalidate',\n 'nowrap',\n 'open',\n 'optimum',\n 'pattern',\n 'placeholder',\n 'poster',\n 'preload',\n 'pubdate',\n 'radiogroup',\n 'readonly',\n 'rel',\n 'required',\n 'rev',\n 'reversed',\n 'role',\n 'rows',\n 'rowspan',\n 'spellcheck',\n 'scope',\n 'selected',\n 'shape',\n 'size',\n 'sizes',\n 'span',\n 'srclang',\n 'start',\n 'src',\n 'srcset',\n 'step',\n 'style',\n 'summary',\n 'tabindex',\n 'title',\n 'type',\n 'usemap',\n 'valign',\n 'value',\n 'width',\n 'xmlns',\n]);\n\nexport const svg = freeze([\n 'accent-height',\n 'accumulate',\n 'additive',\n 'alignment-baseline',\n 'ascent',\n 'attributename',\n 'attributetype',\n 'azimuth',\n 'basefrequency',\n 'baseline-shift',\n 'begin',\n 'bias',\n 'by',\n 'class',\n 'clip',\n 'clip-path',\n 'clip-rule',\n 'color',\n 'color-interpolation',\n 'color-interpolation-filters',\n 'color-profile',\n 'color-rendering',\n 'cx',\n 'cy',\n 'd',\n 'dx',\n 'dy',\n 'diffuseconstant',\n 'direction',\n 'display',\n 'divisor',\n 'dur',\n 'edgemode',\n 'elevation',\n 'end',\n 'fill',\n 'fill-opacity',\n 'fill-rule',\n 'filter',\n 'filterunits',\n 'flood-color',\n 'flood-opacity',\n 'font-family',\n 'font-size',\n 'font-size-adjust',\n 'font-stretch',\n 'font-style',\n 'font-variant',\n 'font-weight',\n 'fx',\n 'fy',\n 'g1',\n 'g2',\n 'glyph-name',\n 'glyphref',\n 'gradientunits',\n 'gradienttransform',\n 'height',\n 'href',\n 'id',\n 'image-rendering',\n 'in',\n 'in2',\n 'k',\n 'k1',\n 'k2',\n 'k3',\n 'k4',\n 'kerning',\n 'keypoints',\n 'keysplines',\n 'keytimes',\n 'lang',\n 'lengthadjust',\n 'letter-spacing',\n 'kernelmatrix',\n 'kernelunitlength',\n 'lighting-color',\n 'local',\n 'marker-end',\n 'marker-mid',\n 'marker-start',\n 'markerheight',\n 'markerunits',\n 'markerwidth',\n 'maskcontentunits',\n 'maskunits',\n 'max',\n 'mask',\n 'media',\n 'method',\n 'mode',\n 'min',\n 'name',\n 'numoctaves',\n 'offset',\n 'operator',\n 'opacity',\n 'order',\n 'orient',\n 'orientation',\n 'origin',\n 'overflow',\n 'paint-order',\n 'path',\n 'pathlength',\n 'patterncontentunits',\n 'patterntransform',\n 'patternunits',\n 'points',\n 'preservealpha',\n 'preserveaspectratio',\n 'primitiveunits',\n 'r',\n 'rx',\n 'ry',\n 'radius',\n 'refx',\n 'refy',\n 'repeatcount',\n 'repeatdur',\n 'restart',\n 'result',\n 'rotate',\n 'scale',\n 'seed',\n 'shape-rendering',\n 'specularconstant',\n 'specularexponent',\n 'spreadmethod',\n 'stddeviation',\n 'stitchtiles',\n 'stop-color',\n 'stop-opacity',\n 'stroke-dasharray',\n 'stroke-dashoffset',\n 'stroke-linecap',\n 'stroke-linejoin',\n 'stroke-miterlimit',\n 'stroke-opacity',\n 'stroke',\n 'stroke-width',\n 'style',\n 'surfacescale',\n 'tabindex',\n 'targetx',\n 'targety',\n 'transform',\n 'text-anchor',\n 'text-decoration',\n 'text-rendering',\n 'textlength',\n 'type',\n 'u1',\n 'u2',\n 'unicode',\n 'values',\n 'viewbox',\n 'visibility',\n 'version',\n 'vert-adv-y',\n 'vert-origin-x',\n 'vert-origin-y',\n 'width',\n 'word-spacing',\n 'wrap',\n 'writing-mode',\n 'xchannelselector',\n 'ychannelselector',\n 'x',\n 'x1',\n 'x2',\n 'xmlns',\n 'y',\n 'y1',\n 'y2',\n 'z',\n 'zoomandpan',\n]);\n\nexport const mathMl = freeze([\n 'accent',\n 'accentunder',\n 'align',\n 'bevelled',\n 'close',\n 'columnsalign',\n 'columnlines',\n 'columnspan',\n 'denomalign',\n 'depth',\n 'dir',\n 'display',\n 'displaystyle',\n 'fence',\n 'frame',\n 'height',\n 'href',\n 'id',\n 'largeop',\n 'length',\n 'linethickness',\n 'lspace',\n 'lquote',\n 'mathbackground',\n 'mathcolor',\n 'mathsize',\n 'mathvariant',\n 'maxsize',\n 'minsize',\n 'movablelimits',\n 'notation',\n 'numalign',\n 'open',\n 'rowalign',\n 'rowlines',\n 'rowspacing',\n 'rowspan',\n 'rspace',\n 'rquote',\n 'scriptlevel',\n 'scriptminsize',\n 'scriptsizemultiplier',\n 'selection',\n 'separator',\n 'separators',\n 'stretchy',\n 'subscriptshift',\n 'supscriptshift',\n 'symmetric',\n 'voffset',\n 'width',\n 'xmlns',\n]);\n\nexport const xml = freeze([\n 'xlink:href',\n 'xml:id',\n 'xlink:title',\n 'xml:space',\n 'xmlns:xlink',\n]);\n","const { hasOwnProperty, setPrototypeOf } = Object;\nlet { apply } = typeof Reflect !== 'undefined' && Reflect;\n\nif (!apply) {\n apply = function(fun, thisValue, args) {\n return fun.apply(thisValue, args);\n };\n}\n\n/* Add properties to a lookup table */\nexport function addToSet(set, array) {\n if (setPrototypeOf) {\n // Make 'in' and truthy checks like Boolean(set.constructor)\n // independent of any properties defined on Object.prototype.\n // Prevent prototype setters from intercepting set as a this value.\n setPrototypeOf(set, null);\n }\n\n let l = array.length;\n while (l--) {\n let element = array[l];\n if (typeof element === 'string') {\n const lcElement = element.toLowerCase();\n if (lcElement !== element) {\n // Config presets (e.g. tags.js, attrs.js) are immutable.\n if (!Object.isFrozen(array)) {\n array[l] = lcElement;\n }\n\n element = lcElement;\n }\n }\n\n set[element] = true;\n }\n\n return set;\n}\n\n/* Shallow clone an object */\nexport function clone(object) {\n const newObject = {};\n\n let property;\n for (property in object) {\n if (apply(hasOwnProperty, object, [property])) {\n newObject[property] = object[property];\n }\n }\n\n return newObject;\n}\n","const seal =\n Object.seal ||\n function(x) {\n return x;\n };\n\nexport const MUSTACHE_EXPR = seal(/\\{\\{[\\s\\S]*|[\\s\\S]*\\}\\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode\nexport const ERB_EXPR = seal(/<%[\\s\\S]*|[\\s\\S]*%>/gm);\nexport const DATA_ATTR = seal(/^data-[\\-\\w.\\u00B7-\\uFFFF]/); // eslint-disable-line no-useless-escape\nexport const ARIA_ATTR = seal(/^aria-[\\-\\w]+$/); // eslint-disable-line no-useless-escape\nexport const IS_ALLOWED_URI = seal(\n /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\\-]+(?:[^a-z+.\\-:]|$))/i // eslint-disable-line no-useless-escape\n);\nexport const IS_SCRIPT_OR_DATA = seal(/^(?:\\w+script|data):/i);\nexport const ATTR_WHITESPACE = seal(\n /[\\u0000-\\u0020\\u00A0\\u1680\\u180E\\u2000-\\u2029\\u205f\\u3000]/g // eslint-disable-line no-control-regex\n);\n","import * as TAGS from './tags';\nimport * as ATTRS from './attrs';\nimport { addToSet, clone } from './utils';\nimport * as EXPRESSIONS from './regexp';\n\nlet { apply } = typeof Reflect !== 'undefined' && Reflect;\nconst { slice: arraySlice } = Array.prototype;\nconst { freeze } = Object;\nconst getGlobal = () => (typeof window === 'undefined' ? null : window);\n\nif (!apply) {\n apply = function(fun, thisValue, args) {\n return fun.apply(thisValue, args);\n };\n}\n\n/**\n * Creates a no-op policy for internal use only.\n * Don't export this function outside this module!\n * @param {?TrustedTypePolicyFactory} trustedTypes The policy factory.\n * @param {Document} document The document object (to determine policy name suffix)\n * @return {?TrustedTypePolicy} The policy created (or null, if Trusted Types\n * are not supported).\n */\nconst _createTrustedTypesPolicy = function(trustedTypes, document) {\n if (\n typeof trustedTypes !== 'object' ||\n typeof trustedTypes.createPolicy !== 'function'\n ) {\n return null;\n }\n\n // Allow the callers to control the unique policy name\n // by adding a data-tt-policy-suffix to the script element with the DOMPurify.\n // Policy creation with duplicate names throws in Trusted Types.\n let suffix = null;\n const ATTR_NAME = 'data-tt-policy-suffix';\n if (\n document.currentScript &&\n document.currentScript.hasAttribute(ATTR_NAME)\n ) {\n suffix = document.currentScript.getAttribute(ATTR_NAME);\n }\n\n const policyName = 'dompurify' + (suffix ? '#' + suffix : '');\n\n try {\n return trustedTypes.createPolicy(policyName, {\n createHTML(html) {\n return html;\n },\n });\n } catch (error) {\n // Policy creation failed (most likely another DOMPurify script has\n // already run). Skip creating the policy, as this will only cause errors\n // if TT are enforced.\n console.warn(\n 'TrustedTypes policy ' + policyName + ' could not be created.'\n );\n return null;\n }\n};\n\nfunction createDOMPurify(window = getGlobal()) {\n const DOMPurify = root => createDOMPurify(root);\n\n /**\n * Version label, exposed for easier checks\n * if DOMPurify is up to date or not\n */\n DOMPurify.version = VERSION;\n\n /**\n * Array of elements that DOMPurify removed during sanitation.\n * Empty if nothing was removed.\n */\n DOMPurify.removed = [];\n\n if (!window || !window.document || window.document.nodeType !== 9) {\n // Not running in a browser, provide a factory function\n // so that you can pass your own Window\n DOMPurify.isSupported = false;\n\n return DOMPurify;\n }\n\n const originalDocument = window.document;\n let useDOMParser = false;\n let removeTitle = false;\n\n let { document } = window;\n const {\n DocumentFragment,\n HTMLTemplateElement,\n Node,\n NodeFilter,\n NamedNodeMap = window.NamedNodeMap || window.MozNamedAttrMap,\n Text,\n Comment,\n DOMParser,\n TrustedTypes,\n } = window;\n\n // As per issue #47, the web-components registry is inherited by a\n // new document created via createHTMLDocument. As per the spec\n // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)\n // a new empty registry is used when creating a template contents owner\n // document, so we use that as our parent document to ensure nothing\n // is inherited.\n if (typeof HTMLTemplateElement === 'function') {\n const template = document.createElement('template');\n if (template.content && template.content.ownerDocument) {\n document = template.content.ownerDocument;\n }\n }\n\n const trustedTypesPolicy = _createTrustedTypesPolicy(\n TrustedTypes,\n originalDocument\n );\n const emptyHTML = trustedTypesPolicy ? trustedTypesPolicy.createHTML('') : '';\n\n const {\n implementation,\n createNodeIterator,\n getElementsByTagName,\n createDocumentFragment,\n } = document;\n const { importNode } = originalDocument;\n\n let hooks = {};\n\n /**\n * Expose whether this browser supports running the full DOMPurify.\n */\n DOMPurify.isSupported =\n implementation &&\n typeof implementation.createHTMLDocument !== 'undefined' &&\n document.documentMode !== 9;\n\n const {\n MUSTACHE_EXPR,\n ERB_EXPR,\n DATA_ATTR,\n ARIA_ATTR,\n IS_SCRIPT_OR_DATA,\n ATTR_WHITESPACE,\n } = EXPRESSIONS;\n\n let { IS_ALLOWED_URI } = EXPRESSIONS;\n /**\n * We consider the elements and attributes below to be safe. Ideally\n * don't add any new ones but feel free to remove unwanted ones.\n */\n\n /* allowed element names */\n let ALLOWED_TAGS = null;\n const DEFAULT_ALLOWED_TAGS = addToSet({}, [\n ...TAGS.html,\n ...TAGS.svg,\n ...TAGS.svgFilters,\n ...TAGS.mathMl,\n ...TAGS.text,\n ]);\n\n /* Allowed attribute names */\n let ALLOWED_ATTR = null;\n const DEFAULT_ALLOWED_ATTR = addToSet({}, [\n ...ATTRS.html,\n ...ATTRS.svg,\n ...ATTRS.mathMl,\n ...ATTRS.xml,\n ]);\n\n /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */\n let FORBID_TAGS = null;\n\n /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */\n let FORBID_ATTR = null;\n\n /* Decide if ARIA attributes are okay */\n let ALLOW_ARIA_ATTR = true;\n\n /* Decide if custom data attributes are okay */\n let ALLOW_DATA_ATTR = true;\n\n /* Decide if unknown protocols are okay */\n let ALLOW_UNKNOWN_PROTOCOLS = false;\n\n /* Output should be safe for jQuery's $() factory? */\n let SAFE_FOR_JQUERY = false;\n\n /* Output should be safe for common template engines.\n * This means, DOMPurify removes data attributes, mustaches and ERB\n */\n let SAFE_FOR_TEMPLATES = false;\n\n /* Decide if document with <html>... should be returned */\n let WHOLE_DOCUMENT = false;\n\n /* Track whether config is already set on this instance of DOMPurify. */\n let SET_CONFIG = false;\n\n /* Decide if all elements (e.g. style, script) must be children of\n * document.body. By default, browsers might move them to document.head */\n let FORCE_BODY = false;\n\n /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html\n * string (or a TrustedHTML object if Trusted Types are supported).\n * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead\n */\n let RETURN_DOM = false;\n\n /* Decide if a DOM `DocumentFragment` should be returned, instead of a html\n * string (or a TrustedHTML object if Trusted Types are supported) */\n let RETURN_DOM_FRAGMENT = false;\n\n /* If `RETURN_DOM` or `RETURN_DOM_FRAGMENT` is enabled, decide if the returned DOM\n * `Node` is imported into the current `Document`. If this flag is not enabled the\n * `Node` will belong (its ownerDocument) to a fresh `HTMLDocument`, created by\n * DOMPurify. */\n let RETURN_DOM_IMPORT = false;\n\n /* Output should be free from DOM clobbering attacks? */\n let SANITIZE_DOM = true;\n\n /* Keep element content when removing element? */\n let KEEP_CONTENT = true;\n\n /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead\n * of importing it into a new Document and returning a sanitized copy */\n let IN_PLACE = false;\n\n /* Allow usage of profiles like html, svg and mathMl */\n let USE_PROFILES = {};\n\n /* Tags to ignore content of when KEEP_CONTENT is true */\n const FORBID_CONTENTS = addToSet({}, [\n 'audio',\n 'head',\n 'math',\n 'script',\n 'style',\n 'template',\n 'svg',\n 'video',\n ]);\n\n /* Tags that are safe for data: URIs */\n const DATA_URI_TAGS = addToSet({}, [\n 'audio',\n 'video',\n 'img',\n 'source',\n 'image',\n ]);\n\n /* Attributes safe for values like \"javascript:\" */\n let URI_SAFE_ATTRIBUTES = null;\n const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, [\n 'alt',\n 'class',\n 'for',\n 'id',\n 'label',\n 'name',\n 'pattern',\n 'placeholder',\n 'summary',\n 'title',\n 'value',\n 'style',\n 'xmlns',\n ]);\n\n /* Keep a reference to config to pass to hooks */\n let CONFIG = null;\n\n /* Ideally, do not touch anything below this line */\n /* ______________________________________________ */\n\n const formElement = document.createElement('form');\n\n /**\n * _parseConfig\n *\n * @param {Object} cfg optional config literal\n */\n // eslint-disable-next-line complexity\n const _parseConfig = function(cfg) {\n if (CONFIG && CONFIG === cfg) {\n return;\n }\n\n /* Shield configuration object from tampering */\n if (!cfg || typeof cfg !== 'object') {\n cfg = {};\n }\n\n /* Set configuration parameters */\n ALLOWED_TAGS =\n 'ALLOWED_TAGS' in cfg\n ? addToSet({}, cfg.ALLOWED_TAGS)\n : DEFAULT_ALLOWED_TAGS;\n ALLOWED_ATTR =\n 'ALLOWED_ATTR' in cfg\n ? addToSet({}, cfg.ALLOWED_ATTR)\n : DEFAULT_ALLOWED_ATTR;\n URI_SAFE_ATTRIBUTES =\n 'ADD_URI_SAFE_ATTR' in cfg\n ? addToSet({}, cfg.ADD_URI_SAFE_ATTR)\n : DEFAULT_URI_SAFE_ATTRIBUTES;\n FORBID_TAGS = 'FORBID_TAGS' in cfg ? addToSet({}, cfg.FORBID_TAGS) : {};\n FORBID_ATTR = 'FORBID_ATTR' in cfg ? addToSet({}, cfg.FORBID_ATTR) : {};\n USE_PROFILES = 'USE_PROFILES' in cfg ? cfg.USE_PROFILES : false;\n ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true\n ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true\n ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false\n SAFE_FOR_JQUERY = cfg.SAFE_FOR_JQUERY || false; // Default false\n SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false\n WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false\n RETURN_DOM = cfg.RETURN_DOM || false; // Default false\n RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false\n RETURN_DOM_IMPORT = cfg.RETURN_DOM_IMPORT || false; // Default false\n FORCE_BODY = cfg.FORCE_BODY || false; // Default false\n SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true\n KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true\n IN_PLACE = cfg.IN_PLACE || false; // Default false\n\n IS_ALLOWED_URI = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;\n\n if (SAFE_FOR_TEMPLATES) {\n ALLOW_DATA_ATTR = false;\n }\n\n if (RETURN_DOM_FRAGMENT) {\n RETURN_DOM = true;\n }\n\n /* Parse profile info */\n if (USE_PROFILES) {\n ALLOWED_TAGS = addToSet({}, [...TAGS.text]);\n ALLOWED_ATTR = [];\n if (USE_PROFILES.html === true) {\n addToSet(ALLOWED_TAGS, TAGS.html);\n addToSet(ALLOWED_ATTR, ATTRS.html);\n }\n\n if (USE_PROFILES.svg === true) {\n addToSet(ALLOWED_TAGS, TAGS.svg);\n addToSet(ALLOWED_ATTR, ATTRS.svg);\n addToSet(ALLOWED_ATTR, ATTRS.xml);\n }\n\n if (USE_PROFILES.svgFilters === true) {\n addToSet(ALLOWED_TAGS, TAGS.svgFilters);\n addToSet(ALLOWED_ATTR, ATTRS.svg);\n addToSet(ALLOWED_ATTR, ATTRS.xml);\n }\n\n if (USE_PROFILES.mathMl === true) {\n addToSet(ALLOWED_TAGS, TAGS.mathMl);\n addToSet(ALLOWED_ATTR, ATTRS.mathMl);\n addToSet(ALLOWED_ATTR, ATTRS.xml);\n }\n }\n\n /* Merge configuration parameters */\n if (cfg.ADD_TAGS) {\n if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {\n ALLOWED_TAGS = clone(ALLOWED_TAGS);\n }\n\n addToSet(ALLOWED_TAGS, cfg.ADD_TAGS);\n }\n\n if (cfg.ADD_ATTR) {\n if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {\n ALLOWED_ATTR = clone(ALLOWED_ATTR);\n }\n\n addToSet(ALLOWED_ATTR, cfg.ADD_ATTR);\n }\n\n if (cfg.ADD_URI_SAFE_ATTR) {\n addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR);\n }\n\n /* Add #text in case KEEP_CONTENT is set to true */\n if (KEEP_CONTENT) {\n ALLOWED_TAGS['#text'] = true;\n }\n\n /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */\n if (WHOLE_DOCUMENT) {\n addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);\n }\n\n /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286 */\n if (ALLOWED_TAGS.table) {\n addToSet(ALLOWED_TAGS, ['tbody']);\n }\n\n // Prevent further manipulation of configuration.\n // Not available in IE8, Safari 5, etc.\n if (freeze) {\n freeze(cfg);\n }\n\n CONFIG = cfg;\n };\n\n /**\n * _forceRemove\n *\n * @param {Node} node a DOM node\n */\n const _forceRemove = function(node) {\n DOMPurify.removed.push({ element: node });\n try {\n node.parentNode.removeChild(node);\n } catch (error) {\n node.outerHTML = emptyHTML;\n }\n };\n\n /**\n * _removeAttribute\n *\n * @param {String} name an Attribute name\n * @param {Node} node a DOM node\n */\n const _removeAttribute = function(name, node) {\n try {\n DOMPurify.removed.push({\n attribute: node.getAttributeNode(name),\n from: node,\n });\n } catch (error) {\n DOMPurify.removed.push({\n attribute: null,\n from: node,\n });\n }\n\n node.removeAttribute(name);\n };\n\n /**\n * _initDocument\n *\n * @param {String} dirty a string of dirty markup\n * @return {Document} a DOM, filled with the dirty markup\n */\n const _initDocument = function(dirty) {\n /* Create a HTML document */\n let doc;\n let leadingWhitespace;\n\n if (FORCE_BODY) {\n dirty = '<remove></remove>' + dirty;\n } else {\n /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */\n const matches = dirty.match(/^[\\s]+/);\n leadingWhitespace = matches && matches[0];\n if (leadingWhitespace) {\n dirty = dirty.slice(leadingWhitespace.length);\n }\n }\n\n /* Use DOMParser to workaround Firefox bug (see comment below) */\n if (useDOMParser) {\n try {\n doc = new DOMParser().parseFromString(dirty, 'text/html');\n } catch (error) {}\n }\n\n /* Remove title to fix a mXSS bug in older MS Edge */\n if (removeTitle) {\n addToSet(FORBID_TAGS, ['title']);\n }\n\n /* Otherwise use createHTMLDocument, because DOMParser is unsafe in\n Safari (see comment below) */\n if (!doc || !doc.documentElement) {\n doc = implementation.createHTMLDocument('');\n const { body } = doc;\n body.parentNode.removeChild(body.parentNode.firstElementChild);\n body.outerHTML = trustedTypesPolicy\n ? trustedTypesPolicy.createHTML(dirty)\n : dirty;\n }\n\n if (leadingWhitespace) {\n doc.body.insertBefore(\n document.createTextNode(leadingWhitespace),\n doc.body.childNodes[0] || null\n );\n }\n\n /* Work on whole document or just its body */\n return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];\n };\n\n // Firefox uses a different parser for innerHTML rather than\n // DOMParser (see https://bugzilla.mozilla.org/show_bug.cgi?id=1205631)\n // which means that you *must* use DOMParser, otherwise the output may\n // not be safe if used in a document.write context later.\n //\n // So we feature detect the Firefox bug and use the DOMParser if necessary.\n //\n // MS Edge, in older versions, is affected by an mXSS behavior. The second\n // check tests for the behavior and fixes it if necessary.\n if (DOMPurify.isSupported) {\n (function() {\n try {\n const doc = _initDocument(\n '<svg><p><style><img src=\"</style><img src=x onerror=1//\">'\n );\n if (doc.querySelector('svg img')) {\n useDOMParser = true;\n }\n } catch (error) {}\n })();\n\n (function() {\n try {\n const doc = _initDocument('<x/><title></title><img>');\n if (doc.querySelector('title').innerHTML.match(/<\\/title/)) {\n removeTitle = true;\n }\n } catch (error) {}\n })();\n }\n\n /**\n * _createIterator\n *\n * @param {Document} root document/fragment to create iterator for\n * @return {Iterator} iterator instance\n */\n const _createIterator = function(root) {\n return createNodeIterator.call(\n root.ownerDocument || root,\n root,\n NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT,\n () => {\n return NodeFilter.FILTER_ACCEPT;\n },\n false\n );\n };\n\n /**\n * _isClobbered\n *\n * @param {Node} elm element to check for clobbering attacks\n * @return {Boolean} true if clobbered, false if safe\n */\n const _isClobbered = function(elm) {\n if (elm instanceof Text || elm instanceof Comment) {\n return false;\n }\n\n if (\n typeof elm.nodeName !== 'string' ||\n typeof elm.textContent !== 'string' ||\n typeof elm.removeChild !== 'function' ||\n !(elm.attributes instanceof NamedNodeMap) ||\n typeof elm.removeAttribute !== 'function' ||\n typeof elm.setAttribute !== 'function'\n ) {\n return true;\n }\n\n return false;\n };\n\n /**\n * _isNode\n *\n * @param {Node} obj object to check whether it's a DOM node\n * @return {Boolean} true is object is a DOM node\n */\n const _isNode = function(obj) {\n return typeof Node === 'object'\n ? obj instanceof Node\n : obj &&\n typeof obj === 'object' &&\n typeof obj.nodeType === 'number' &&\n typeof obj.nodeName === 'string';\n };\n\n /**\n * _executeHook\n * Execute user configurable hooks\n *\n * @param {String} entryPoint Name of the hook's entry point\n * @param {Node} currentNode node to work on with the hook\n * @param {Object} data additional hook parameters\n */\n const _executeHook = function(entryPoint, currentNode, data) {\n if (!hooks[entryPoint]) {\n return;\n }\n\n hooks[entryPoint].forEach(hook => {\n hook.call(DOMPurify, currentNode, data, CONFIG);\n });\n };\n\n /**\n * _sanitizeElements\n *\n * @protect nodeName\n * @protect textContent\n * @protect removeChild\n *\n * @param {Node} currentNode to check for permission to exist\n * @return {Boolean} true if node was killed, false if left alive\n */\n // eslint-disable-next-line complexity\n const _sanitizeElements = function(currentNode) {\n let content;\n\n /* Execute a hook if present */\n _executeHook('beforeSanitizeElements', currentNode, null);\n\n /* Check if element is clobbered or can clobber */\n if (_isClobbered(currentNode)) {\n _forceRemove(currentNode);\n return true;\n }\n\n /* Now let's check the element's type and name */\n const tagName = currentNode.nodeName.toLowerCase();\n\n /* Execute a hook if present */\n _executeHook('uponSanitizeElement', currentNode, {\n tagName,\n allowedTags: ALLOWED_TAGS,\n });\n\n /* Remove element if anything forbids its presence */\n if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {\n /* Keep content except for black-listed elements */\n if (\n KEEP_CONTENT &&\n !FORBID_CONTENTS[tagName] &&\n typeof currentNode.insertAdjacentHTML === 'function'\n ) {\n try {\n const htmlToInsert = currentNode.innerHTML;\n currentNode.insertAdjacentHTML(\n 'AfterEnd',\n trustedTypesPolicy\n ? trustedTypesPolicy.createHTML(htmlToInsert)\n : htmlToInsert\n );\n } catch (error) {}\n }\n\n _forceRemove(currentNode);\n return true;\n }\n\n /* Remove in case a noscript/noembed XSS is suspected */\n if (tagName === 'noscript' && currentNode.innerHTML.match(/<\\/noscript/i)) {\n _forceRemove(currentNode);\n return true;\n }\n\n if (tagName === 'noembed' && currentNode.innerHTML.match(/<\\/noembed/i)) {\n _forceRemove(currentNode);\n return true;\n }\n\n /* Convert markup to cover jQuery behavior */\n if (\n SAFE_FOR_JQUERY &&\n !currentNode.firstElementChild &&\n (!currentNode.content || !currentNode.content.firstElementChild) &&\n /</g.test(currentNode.textContent)\n ) {\n DOMPurify.removed.push({ element: currentNode.cloneNode() });\n if (currentNode.innerHTML) {\n currentNode.innerHTML = currentNode.innerHTML.replace(/</g, '<');\n } else {\n currentNode.innerHTML = currentNode.textContent.replace(/</g, '<');\n }\n }\n\n /* Sanitize element content to be template-safe */\n if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) {\n /* Get the element's text content */\n content = currentNode.textContent;\n content = content.replace(MUSTACHE_EXPR, ' ');\n content = content.replace(ERB_EXPR, ' ');\n if (currentNode.textContent !== content) {\n DOMPurify.removed.push({ element: currentNode.cloneNode() });\n currentNode.textContent = content;\n }\n }\n\n /* Execute a hook if present */\n _executeHook('afterSanitizeElements', currentNode, null);\n\n return false;\n };\n\n /**\n * _isValidAttribute\n *\n * @param {string} lcTag Lowercase tag name of containing element.\n * @param {string} lcName Lowercase attribute name.\n * @param {string} value Attribute value.\n * @return {Boolean} Returns true if `value` is valid, otherwise false.\n */\n // eslint-disable-next-line complexity\n const _isValidAttribute = function(lcTag, lcName, value) {\n /* Make sure attribute cannot clobber */\n if (\n SANITIZE_DOM &&\n (lcName === 'id' || lcName === 'name') &&\n (value in document || value in formElement)\n ) {\n return false;\n }\n\n /* Allow valid data-* attributes: At least one character after \"-\"\n (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)\n XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)\n We don't need to check the value; it's always URI safe. */\n if (ALLOW_DATA_ATTR && DATA_ATTR.test(lcName)) {\n // This attribute is safe\n } else if (ALLOW_ARIA_ATTR && ARIA_ATTR.test(lcName)) {\n // This attribute is safe\n /* Otherwise, check the name is permitted */\n } else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {\n return false;\n\n /* Check value is safe. First, is attr inert? If so, is safe */\n } else if (URI_SAFE_ATTRIBUTES[lcName]) {\n // This attribute is safe\n /* Check no script, data or unknown possibly unsafe URI\n unless we know URI values are safe for that attribute */\n } else if (IS_ALLOWED_URI.test(value.replace(ATTR_WHITESPACE, ''))) {\n // This attribute is safe\n /* Keep image data URIs alive if src/xlink:href is allowed */\n /* Further prevent gadget XSS for dynamically built script tags */\n } else if (\n (lcName === 'src' || lcName === 'xlink:href') &&\n lcTag !== 'script' &&\n value.indexOf('data:') === 0 &&\n DATA_URI_TAGS[lcTag]\n ) {\n // This attribute is safe\n /* Allow unknown protocols: This provides support for links that\n are handled by protocol handlers which may be unknown ahead of\n time, e.g. fb:, spotify: */\n } else if (\n ALLOW_UNKNOWN_PROTOCOLS &&\n !IS_SCRIPT_OR_DATA.test(value.replace(ATTR_WHITESPACE, ''))\n ) {\n // This attribute is safe\n /* Check for binary attributes */\n // eslint-disable-next-line no-negated-condition\n } else if (!value) {\n // Binary attributes are safe at this point\n /* Anything else, presume unsafe, do not add it back */\n } else {\n return false;\n }\n\n return true;\n };\n\n /**\n * _sanitizeAttributes\n *\n * @protect attributes\n * @protect nodeName\n * @protect removeAttribute\n * @protect setAttribute\n *\n * @param {Node} currentNode to sanitize\n */\n const _sanitizeAttributes = function(currentNode) {\n let attr;\n let value;\n let lcName;\n let idAttr;\n let l;\n /* Execute a hook if present */\n _executeHook('beforeSanitizeAttributes', currentNode, null);\n\n let { attributes } = currentNode;\n\n /* Check if we have attributes; if not we might have a text node */\n if (!attributes) {\n return;\n }\n\n const hookEvent = {\n attrName: '',\n attrValue: '',\n keepAttr: true,\n allowedAttributes: ALLOWED_ATTR,\n };\n l = attributes.length;\n\n /* Go backwards over all attributes; safely remove bad ones */\n while (l--) {\n attr = attributes[l];\n const { name, namespaceURI } = attr;\n value = attr.value.trim();\n lcName = name.toLowerCase();\n\n /* Execute a hook if present */\n hookEvent.attrName = lcName;\n hookEvent.attrValue = value;\n hookEvent.keepAttr = true;\n _executeHook('uponSanitizeAttribute', currentNode, hookEvent);\n value = hookEvent.attrValue;\n\n /* Remove attribute */\n // Safari (iOS + Mac), last tested v8.0.5, crashes if you try to\n // remove a \"name\" attribute from an <img> tag that has an \"id\"\n // attribute at the time.\n if (\n lcName === 'name' &&\n currentNode.nodeName === 'IMG' &&\n attributes.id\n ) {\n idAttr = attributes.id;\n attributes = apply(arraySlice, attributes, []);\n _removeAttribute('id', currentNode);\n _removeAttribute(name, currentNode);\n if (attributes.indexOf(idAttr) > l) {\n currentNode.setAttribute('id', idAttr.value);\n }\n } else if (\n // This works around a bug in Safari, where input[type=file]\n // cannot be dynamically set after type has been removed\n currentNode.nodeName === 'INPUT' &&\n lcName === 'type' &&\n value === 'file' &&\n hookEvent.keepAttr &&\n (ALLOWED_ATTR[lcName] || !FORBID_ATTR[lcName])\n ) {\n continue;\n } else {\n // This avoids a crash in Safari v9.0 with double-ids.\n // The trick is to first set the id to be empty and then to\n // remove the attribute\n if (name === 'id') {\n currentNode.setAttribute(name, '');\n }\n\n _removeAttribute(name, currentNode);\n }\n\n /* Did the hooks approve of the attribute? */\n if (!hookEvent.keepAttr) {\n continue;\n }\n\n /* Sanitize attribute content to be template-safe */\n if (SAFE_FOR_TEMPLATES) {\n value = value.replace(MUSTACHE_EXPR, ' ');\n value = value.replace(ERB_EXPR, ' ');\n }\n\n /* Is `value` valid for this attribute? */\n const lcTag = currentNode.nodeName.toLowerCase();\n if (!_isValidAttribute(lcTag, lcName, value)) {\n continue;\n }\n\n /* Handle invalid data-* attribute set by try-catching it */\n try {\n if (namespaceURI) {\n currentNode.setAttributeNS(namespaceURI, name, value);\n } else {\n /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. \"x-schema\". */\n currentNode.setAttribute(name, value);\n }\n\n DOMPurify.removed.pop();\n } catch (error) {}\n }\n\n /* Execute a hook if present */\n _executeHook('afterSanitizeAttributes', currentNode, null);\n };\n\n /**\n * _sanitizeShadowDOM\n *\n * @param {DocumentFragment} fragment to iterate over recursively\n */\n const _sanitizeShadowDOM = function(fragment) {\n let shadowNode;\n const shadowIterator = _createIterator(fragment);\n\n /* Execute a hook if present */\n _executeHook('beforeSanitizeShadowDOM', fragment, null);\n\n while ((shadowNode = shadowIterator.nextNode())) {\n /* Execute a hook if present */\n _executeHook('uponSanitizeShadowNode', shadowNode, null);\n\n /* Sanitize tags and elements */\n if (_sanitizeElements(shadowNode)) {\n continue;\n }\n\n /* Deep shadow DOM detected */\n if (shadowNode.content instanceof DocumentFragment) {\n _sanitizeShadowDOM(shadowNode.content);\n }\n\n /* Check attributes, sanitize if necessary */\n _sanitizeAttributes(shadowNode);\n }\n\n /* Execute a hook if present */\n _executeHook('afterSanitizeShadowDOM', fragment, null);\n };\n\n /**\n * Sanitize\n * Public method providing core sanitation functionality\n *\n * @param {String|Node} dirty string or DOM node\n * @param {Object} configuration object\n */\n // eslint-disable-next-line complexity\n DOMPurify.sanitize = function(dirty, cfg) {\n let body;\n let importedNode;\n let currentNode;\n let oldNode;\n let returnNode;\n /* Make sure we have a string to sanitize.\n DO NOT return early, as this will return the wrong type if\n the user has requested a DOM object rather than a string */\n if (!dirty) {\n dirty = '<!-->';\n }\n\n /* Stringify, in case dirty is an object */\n if (typeof dirty !== 'string' && !_isNode(dirty)) {\n // eslint-disable-next-line no-negated-condition\n if (typeof dirty.toString !== 'function') {\n throw new TypeError('toString is not a function');\n } else {\n dirty = dirty.toString();\n if (typeof dirty !== 'string') {\n throw new TypeError('dirty is not a string, aborting');\n }\n }\n }\n\n /* Check we can run. Otherwise fall back or ignore */\n if (!DOMPurify.isSupported) {\n if (\n typeof window.toStaticHTML === 'object' ||\n typeof window.toStaticHTML === 'function'\n ) {\n if (typeof dirty === 'string') {\n return window.toStaticHTML(dirty);\n }\n\n if (_isNode(dirty)) {\n return window.toStaticHTML(dirty.outerHTML);\n }\n }\n\n return dirty;\n }\n\n /* Assign config vars */\n if (!SET_CONFIG) {\n _parseConfig(cfg);\n }\n\n /* Clean up removed elements */\n DOMPurify.removed = [];\n\n if (IN_PLACE) {\n /* No special handling necessary for in-place sanitization */\n } else if (dirty instanceof Node) {\n /* If dirty is a DOM element, append to an empty document to avoid\n elements being stripped by the parser */\n body = _initDocument('<!-->');\n importedNode = body.ownerDocument.importNode(dirty, true);\n if (importedNode.nodeType === 1 && importedNode.nodeName === 'BODY') {\n /* Node is already a body, use as is */\n body = importedNode;\n } else if (importedNode.nodeName === 'HTML') {\n body = importedNode;\n } else {\n // eslint-disable-next-line unicorn/prefer-node-append\n body.appendChild(importedNode);\n }\n } else {\n /* Exit directly if we have nothing to do */\n if (\n !RETURN_DOM &&\n !SAFE_FOR_TEMPLATES &&\n !WHOLE_DOCUMENT &&\n dirty.indexOf('<') === -1\n ) {\n return trustedTypesPolicy\n ? trustedTypesPolicy.createHTML(dirty)\n : dirty;\n }\n\n /* Initialize the document to work on */\n body = _initDocument(dirty);\n\n /* Check we have a DOM node from the data */\n if (!body) {\n return RETURN_DOM ? null : emptyHTML;\n }\n }\n\n /* Remove first element node (ours) if FORCE_BODY is set */\n if (body && FORCE_BODY) {\n _forceRemove(body.firstChild);\n }\n\n /* Get node iterator */\n const nodeIterator = _createIterator(IN_PLACE ? dirty : body);\n\n /* Now start iterating over the created document */\n while ((currentNode = nodeIterator.nextNode())) {\n /* Fix IE's strange behavior with manipulated textNodes #89 */\n if (currentNode.nodeType === 3 && currentNode === oldNode) {\n continue;\n }\n\n /* Sanitize tags and elements */\n if (_sanitizeElements(currentNode)) {\n continue;\n }\n\n /* Shadow DOM detected, sanitize it */\n if (currentNode.content instanceof DocumentFragment) {\n _sanitizeShadowDOM(currentNode.content);\n }\n\n /* Check attributes, sanitize if necessary */\n _sanitizeAttributes(currentNode);\n\n oldNode = currentNode;\n }\n\n oldNode = null;\n\n /* If we sanitized `dirty` in-place, return it. */\n if (IN_PLACE) {\n return dirty;\n }\n\n /* Return sanitized string or DOM */\n if (RETURN_DOM) {\n if (RETURN_DOM_FRAGMENT) {\n returnNode = createDocumentFragment.call(body.ownerDocument);\n\n while (body.firstChild) {\n // eslint-disable-next-line unicorn/prefer-node-append\n returnNode.appendChild(body.firstChild);\n }\n } else {\n returnNode = body;\n }\n\n if (RETURN_DOM_IMPORT) {\n /* AdoptNode() is not used because internal state is not reset\n (e.g. the past names map of a HTMLFormElement), this is safe\n in theory but we would rather not risk another attack vector.\n The state that is cloned by importNode() is explicitly defined\n by the specs. */\n returnNode = importNode.call(originalDocument, returnNode, true);\n }\n\n return returnNode;\n }\n\n let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;\n\n /* Sanitize final string template-safe */\n if (SAFE_FOR_TEMPLATES) {\n serializedHTML = serializedHTML.replace(MUSTACHE_EXPR, ' ');\n serializedHTML = serializedHTML.replace(ERB_EXPR, ' ');\n }\n\n return trustedTypesPolicy\n ? trustedTypesPolicy.createHTML(serializedHTML)\n : serializedHTML;\n };\n\n /**\n * Public method to set the configuration once\n * setConfig\n *\n * @param {Object} cfg configuration object\n */\n DOMPurify.setConfig = function(cfg) {\n _parseConfig(cfg);\n SET_CONFIG = true;\n };\n\n /**\n * Public method to remove the configuration\n * clearConfig\n *\n */\n DOMPurify.clearConfig = function() {\n CONFIG = null;\n SET_CONFIG = false;\n };\n\n /**\n * Public method to check if an attribute value is valid.\n * Uses last set config, if any. Otherwise, uses config defaults.\n * isValidAttribute\n *\n * @param {string} tag Tag name of containing element.\n * @param {string} attr Attribute name.\n * @param {string} value Attribute value.\n * @return {Boolean} Returns true if `value` is valid. Otherwise, returns false.\n */\n DOMPurify.isValidAttribute = function(tag, attr, value) {\n /* Initialize shared config vars if necessary. */\n if (!CONFIG) {\n _parseConfig({});\n }\n\n const lcTag = tag.toLowerCase();\n const lcName = attr.toLowerCase();\n return _isValidAttribute(lcTag, lcName, value);\n };\n\n /**\n * AddHook\n * Public method to add DOMPurify hooks\n *\n * @param {String} entryPoint entry point for the hook to add\n * @param {Function} hookFunction function to execute\n */\n DOMPurify.addHook = function(entryPoint, hookFunction) {\n if (typeof hookFunction !== 'function') {\n return;\n }\n\n hooks[entryPoint] = hooks[entryPoint] || [];\n hooks[entryPoint].push(hookFunction);\n };\n\n /**\n * RemoveHook\n * Public method to remove a DOMPurify hook at a given entryPoint\n * (pops it from the stack of hooks if more are present)\n *\n * @param {String} entryPoint entry point for the hook to remove\n */\n DOMPurify.removeHook = function(entryPoint) {\n if (hooks[entryPoint]) {\n hooks[entryPoint].pop();\n }\n };\n\n /**\n * RemoveHooks\n * Public method to remove all DOMPurify hooks at a given entryPoint\n *\n * @param {String} entryPoint entry point for the hooks to remove\n */\n DOMPurify.removeHooks = function(entryPoint) {\n if (hooks[entryPoint]) {\n hooks[entryPoint] = [];\n }\n };\n\n /**\n * RemoveAllHooks\n * Public method to remove all DOMPurify hooks\n *\n */\n DOMPurify.removeAllHooks = function() {\n hooks = {};\n };\n\n return DOMPurify;\n}\n\nexport default createDOMPurify();\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// Void elements are elements without inner content,\n// which close themselves regardless of trailing slash.\n// E.g. both <br> and <br /> are self-closing.\nvar VOID_ELEMENTS = [\n \"area\",\n \"base\",\n \"br\",\n \"col\",\n \"command\",\n \"embed\",\n \"hr\",\n \"img\",\n \"input\",\n \"keygen\",\n \"link\",\n \"meta\",\n \"param\",\n \"source\",\n \"track\",\n \"wbr\",\n];\n// Block elements trigger newlines where they're inserted,\n// and are always safe places for truncation.\nvar BLOCK_ELEMENTS = [\n \"address\",\n \"article\",\n \"aside\",\n \"blockquote\",\n \"canvas\",\n \"dd\",\n \"div\",\n \"dl\",\n \"dt\",\n \"fieldset\",\n \"figcaption\",\n \"figure\",\n \"footer\",\n \"form\",\n \"h1\",\n \"h2\",\n \"h3\",\n \"h4\",\n \"h5\",\n \"h6\",\n \"header\",\n \"hgroup\",\n \"hr\",\n \"li\",\n \"main\",\n \"nav\",\n \"noscript\",\n \"ol\",\n \"output\",\n \"p\",\n \"pre\",\n \"section\",\n \"table\",\n \"tbody\",\n \"tfoot\",\n \"thead\",\n \"tr\",\n \"ul\",\n \"video\",\n];\nvar NEWLINE_CHAR_CODE = 10; // '\\n'\nvar EXCLAMATION_CHAR_CODE = 33; // '!'\nvar DOUBLE_QUOTE_CHAR_CODE = 34; // '\"'\nvar AMPERSAND_CHAR_CODE = 38; // '&'\nvar SINGLE_QUOTE_CHAR_CODE = 39; // '\\''\nvar FORWARD_SLASH_CHAR_CODE = 47; // '/'\nvar SEMICOLON_CHAR_CODE = 59; // ';'\nvar TAG_OPEN_CHAR_CODE = 60; // '<'\nvar EQUAL_SIGN_CHAR_CODE = 61; // '='\nvar TAG_CLOSE_CHAR_CODE = 62; // '>'\nvar CHAR_OF_INTEREST_REGEX = /[<&\\n\\ud800-\\udbff]/;\nvar SIMPLIFY_WHITESPACE_REGEX = /\\s{2,}/g;\n/**\n * Clips a string to a maximum length. If the string exceeds the length, it is truncated and an\n * indicator (an ellipsis, by default) is appended.\n *\n * In detail, the clipping rules are as follows:\n * - The resulting clipped string may never contain more than maxLength characters. Examples:\n * - clip(\"foo\", 3) => \"foo\"\n * - clip(\"foo\", 2) => \"f…\"\n * - The indicator is inserted if and only if the string is clipped at any place other than a\n * newline. Examples:\n * - clip(\"foo bar\", 5) => \"foo …\"\n * - clip(\"foo\\nbar\", 5) => \"foo\"\n * - If the html option is true and valid HTML is inserted, the clipped output *must* also be valid\n * HTML. If the input is not valid HTML, the result is undefined (not to be confused with JS'\n * \"undefined\" type; some errors might be detected and result in an exception, but this is not\n * guaranteed).\n *\n * @param string The string to clip.\n * @param maxLength The maximum length of the clipped string in number of characters.\n * @param options Optional options object.\n *\n * @return The clipped string.\n */\nfunction clip(string, maxLength, options) {\n if (options === void 0) { options = {}; }\n if (!string) {\n return \"\";\n }\n string = string.toString();\n return options.html\n ? clipHtml(string, maxLength, options)\n : clipPlainText(string, maxLength, options);\n}\nexports.default = clip;\nfunction clipHtml(string, maxLength, options) {\n var _a = options.imageWeight, imageWeight = _a === void 0 ? 2 : _a, _b = options.indicator, indicator = _b === void 0 ? \"\\u2026\" : _b, _c = options.maxLines, maxLines = _c === void 0 ? Infinity : _c;\n var numChars = indicator.length;\n var numLines = 1;\n var i = 0;\n var isUnbreakableContent = false;\n var tagStack = []; // Stack of currently open HTML tags.\n var length = string.length;\n for (; i < length; i++) {\n var rest = i ? string.slice(i) : string;\n var nextIndex = rest.search(CHAR_OF_INTEREST_REGEX);\n var nextBlockSize = nextIndex > -1 ? nextIndex : rest.length;\n i += nextBlockSize;\n if (!isUnbreakableContent) {\n if (shouldSimplifyWhiteSpace(tagStack)) {\n numChars += simplifyWhiteSpace(nextBlockSize === rest.length ? rest : rest.slice(0, nextIndex)).length;\n if (numChars > maxLength) {\n i -= nextBlockSize; // We just cut off the entire incorrectly placed text...\n break;\n }\n }\n else {\n numChars += nextBlockSize;\n if (numChars > maxLength) {\n i = Math.max(i - numChars + maxLength, 0);\n break;\n }\n }\n }\n if (nextIndex === -1) {\n break;\n }\n var charCode = string.charCodeAt(i);\n if (charCode === TAG_OPEN_CHAR_CODE) {\n var nextCharCode = string.charCodeAt(i + 1);\n var isSpecialTag = nextCharCode === EXCLAMATION_CHAR_CODE;\n if (isSpecialTag && string.substr(i + 2, 2) === \"--\") {\n var commentEndIndex = string.indexOf(\"-->\", i + 4) + 3;\n i = commentEndIndex - 1; // - 1 because the outer for loop will increment it\n }\n else if (isSpecialTag && string.substr(i + 2, 7) === \"[CDATA[\") {\n var cdataEndIndex = string.indexOf(\"]]>\", i + 9) + 3;\n i = cdataEndIndex - 1; // - 1 because the outer for loop will increment it\n // note we don't count CDATA text for our character limit because it is only\n // allowed within SVG and MathML content, both of which we don't clip\n }\n else {\n // don't open new tags if we are currently at the limit\n if (numChars === maxLength &&\n string.charCodeAt(i + 1) !== FORWARD_SLASH_CHAR_CODE) {\n numChars++;\n break;\n }\n var attributeQuoteCharCode = 0;\n var endIndex = i;\n var isAttributeValue = false;\n while (true /* eslint-disable-line */) {\n endIndex++;\n if (endIndex >= length) {\n throw new Error(\"Invalid HTML: \" + string);\n }\n var charCode_1 = string.charCodeAt(endIndex);\n if (isAttributeValue) {\n if (attributeQuoteCharCode) {\n if (charCode_1 === attributeQuoteCharCode) {\n isAttributeValue = false;\n }\n }\n else {\n if (isWhiteSpace(charCode_1)) {\n isAttributeValue = false;\n }\n else if (charCode_1 === TAG_CLOSE_CHAR_CODE) {\n isAttributeValue = false;\n endIndex--; // re-evaluate this character\n }\n }\n }\n else if (charCode_1 === EQUAL_SIGN_CHAR_CODE) {\n while (isWhiteSpace(string.charCodeAt(endIndex + 1))) {\n endIndex++; // skip whitespace\n }\n isAttributeValue = true;\n var firstAttributeCharCode = string.charCodeAt(endIndex + 1);\n if (firstAttributeCharCode === DOUBLE_QUOTE_CHAR_CODE ||\n firstAttributeCharCode === SINGLE_QUOTE_CHAR_CODE) {\n attributeQuoteCharCode = firstAttributeCharCode;\n endIndex++;\n }\n else {\n attributeQuoteCharCode = 0;\n }\n }\n else if (charCode_1 === TAG_CLOSE_CHAR_CODE) {\n var isEndTag = string.charCodeAt(i + 1) === FORWARD_SLASH_CHAR_CODE;\n var tagNameStartIndex = i + (isEndTag ? 2 : 1);\n var tagNameEndIndex = Math.min(indexOfWhiteSpace(string, tagNameStartIndex), endIndex);\n var tagName = string\n .slice(tagNameStartIndex, tagNameEndIndex)\n .toLowerCase();\n if (tagName.charCodeAt(tagName.length - 1) === FORWARD_SLASH_CHAR_CODE) {\n // Remove trailing slash for self-closing tag names like <br/>\n tagName = tagName.slice(0, tagName.length - 1);\n }\n if (isEndTag) {\n var currentTagName = tagStack.pop();\n if (currentTagName !== tagName) {\n throw new Error(\"Invalid HTML: \" + string);\n }\n if (tagName === \"math\" || tagName === \"svg\") {\n isUnbreakableContent =\n tagStack.includes(\"math\") || tagStack.includes(\"svg\");\n if (!isUnbreakableContent) {\n numChars += imageWeight;\n if (numChars > maxLength) {\n break;\n }\n }\n }\n if (BLOCK_ELEMENTS.includes(tagName)) {\n // All block level elements should trigger a new line\n // when truncating\n if (!isUnbreakableContent) {\n numLines++;\n if (numLines > maxLines) {\n // If we exceed the max lines, push the tag back onto the\n // stack so that it will be added back correctly after\n // truncation\n tagStack.push(tagName);\n break;\n }\n }\n }\n }\n else if (VOID_ELEMENTS.includes(tagName) ||\n string.charCodeAt(endIndex - 1) === FORWARD_SLASH_CHAR_CODE) {\n if (tagName === \"br\") {\n numLines++;\n if (numLines > maxLines) {\n break;\n }\n }\n else if (tagName === \"img\") {\n numChars += imageWeight;\n if (numChars > maxLength) {\n break;\n }\n }\n }\n else {\n tagStack.push(tagName);\n if (tagName === \"math\" || tagName === \"svg\") {\n isUnbreakableContent = true;\n }\n }\n i = endIndex;\n break;\n }\n }\n if (numChars > maxLength || numLines > maxLines) {\n break;\n }\n }\n }\n else if (charCode === AMPERSAND_CHAR_CODE) {\n var endIndex = i + 1;\n var isCharacterReference = true;\n while (true /* eslint-disable-line */) {\n var charCode_2 = string.charCodeAt(endIndex);\n if (isCharacterReferenceCharacter(charCode_2)) {\n endIndex++;\n }\n else if (charCode_2 === SEMICOLON_CHAR_CODE) {\n break;\n }\n else {\n isCharacterReference = false;\n break;\n }\n }\n if (!isUnbreakableContent) {\n numChars++;\n if (numChars > maxLength) {\n break;\n }\n }\n if (isCharacterReference) {\n i = endIndex;\n }\n }\n else if (charCode === NEWLINE_CHAR_CODE) {\n if (!isUnbreakableContent && !shouldSimplifyWhiteSpace(tagStack)) {\n numChars++;\n if (numChars > maxLength) {\n break;\n }\n numLines++;\n if (numLines > maxLines) {\n break;\n }\n }\n }\n else {\n if (!isUnbreakableContent) {\n numChars++;\n if (numChars > maxLength) {\n break;\n }\n }\n // high Unicode surrogate should never be separated from its matching low surrogate\n var nextCharCode = string.charCodeAt(i + 1);\n if ((nextCharCode & 0xfc00) === 0xdc00) {\n i++;\n }\n }\n }\n if (numChars > maxLength) {\n var nextChar = takeHtmlCharAt(string, i);\n if (indicator) {\n var peekIndex = i + nextChar.length;\n while (string.charCodeAt(peekIndex) === TAG_OPEN_CHAR_CODE &&\n string.charCodeAt(peekIndex + 1) === FORWARD_SLASH_CHAR_CODE) {\n var nextPeekIndex = string.indexOf(\">\", peekIndex + 2) + 1;\n if (nextPeekIndex) {\n peekIndex = nextPeekIndex;\n }\n else {\n break;\n }\n }\n if (peekIndex && (peekIndex === string.length || isLineBreak(string, peekIndex))) {\n // if there's only a single character remaining in the input string, or the next\n // character is followed by a line-break, we can include it instead of the clipping\n // indicator (provided it's not a special HTML character)\n i += nextChar.length;\n nextChar = string.charAt(i);\n }\n }\n // include closing tags before adding the clipping indicator if that's where they\n // are in the input string\n while (nextChar === \"<\" && string.charCodeAt(i + 1) === FORWARD_SLASH_CHAR_CODE) {\n var tagName = tagStack.pop();\n var tagEndIndex = tagName ? string.indexOf(\">\", i + 2) : -1;\n if (tagEndIndex === -1 || string.slice(i + 2, tagEndIndex).trim() !== tagName) {\n throw new Error(\"Invalid HTML: \" + string);\n }\n i = tagEndIndex + 1;\n nextChar = string.charAt(i);\n }\n if (i < string.length) {\n if (!options.breakWords) {\n // try to clip at word boundaries, if desired\n for (var j = i - indicator.length; j >= 0; j--) {\n var charCode = string.charCodeAt(j);\n if (charCode === TAG_CLOSE_CHAR_CODE || charCode === SEMICOLON_CHAR_CODE) {\n // these characters could be just regular characters, so if they occur in\n // the middle of a word, they would \"break\" our attempt to prevent breaking\n // of words, but given this seems highly unlikely and the alternative is\n // doing another full parsing of the preceding text, this seems acceptable.\n break;\n }\n else if (charCode === NEWLINE_CHAR_CODE || charCode === TAG_OPEN_CHAR_CODE) {\n i = j;\n break;\n }\n else if (isWhiteSpace(charCode)) {\n i = j + (indicator ? 1 : 0);\n break;\n }\n }\n }\n var result = string.slice(0, i);\n if (!isLineBreak(string, i)) {\n result += indicator;\n }\n while (tagStack.length) {\n var tagName = tagStack.pop();\n result += \"</\" + tagName + \">\";\n }\n return result;\n }\n }\n else if (numLines > maxLines) {\n var result = string.slice(0, i);\n while (tagStack.length) {\n var tagName = tagStack.pop();\n result += \"</\" + tagName + \">\";\n }\n return result;\n }\n return string;\n}\nfunction clipPlainText(string, maxLength, options) {\n var _a = options.indicator, indicator = _a === void 0 ? \"\\u2026\" : _a, _b = options.maxLines, maxLines = _b === void 0 ? Infinity : _b;\n var numChars = indicator.length;\n var numLines = 1;\n var i = 0;\n var length = string.length;\n for (; i < length; i++) {\n numChars++;\n if (numChars > maxLength) {\n break;\n }\n var charCode = string.charCodeAt(i);\n if (charCode === NEWLINE_CHAR_CODE) {\n numLines++;\n if (numLines > maxLines) {\n break;\n }\n }\n else if ((charCode & 0xfc00) === 0xd800) {\n // high Unicode surrogate should never be separated from its matching low surrogate\n var nextCharCode = string.charCodeAt(i + 1);\n if ((nextCharCode & 0xfc00) === 0xdc00) {\n i++;\n }\n }\n }\n if (numChars > maxLength) {\n var nextChar = takeCharAt(string, i);\n if (indicator) {\n var peekIndex = i + nextChar.length;\n if (peekIndex === string.length) {\n return string;\n }\n else if (string.charCodeAt(peekIndex) === NEWLINE_CHAR_CODE) {\n return string.slice(0, i + nextChar.length);\n }\n }\n if (!options.breakWords) {\n // try to clip at word boundaries, if desired\n for (var j = i - indicator.length; j >= 0; j--) {\n var charCode = string.charCodeAt(j);\n if (charCode === NEWLINE_CHAR_CODE) {\n i = j;\n nextChar = \"\\n\";\n break;\n }\n else if (isWhiteSpace(charCode)) {\n i = j + (indicator ? 1 : 0);\n break;\n }\n }\n }\n return string.slice(0, i) + (nextChar === \"\\n\" ? \"\" : indicator);\n }\n else if (numLines > maxLines) {\n return string.slice(0, i);\n }\n return string;\n}\nfunction indexOfWhiteSpace(string, fromIndex) {\n var length = string.length;\n for (var i = fromIndex; i < length; i++) {\n if (isWhiteSpace(string.charCodeAt(i))) {\n return i;\n }\n }\n // Rather than -1, this function returns the length of the string if no match is found,\n // so it works well with the Math.min() usage above:\n return length;\n}\nfunction isCharacterReferenceCharacter(charCode) {\n return ((charCode >= 48 && charCode <= 57) ||\n (charCode >= 65 && charCode <= 90) ||\n (charCode >= 97 && charCode <= 122));\n}\nfunction isLineBreak(string, index) {\n var firstCharCode = string.charCodeAt(index);\n if (firstCharCode === NEWLINE_CHAR_CODE) {\n return true;\n }\n else if (firstCharCode === TAG_OPEN_CHAR_CODE) {\n var newlineElements = \"(\" + BLOCK_ELEMENTS.join(\"|\") + \"|br)\";\n var newlineRegExp = new RegExp(\"^<\" + newlineElements + \"[\\t\\n\\f\\r ]*/?>\", \"i\");\n return newlineRegExp.test(string.slice(index));\n }\n else {\n return false;\n }\n}\nfunction isWhiteSpace(charCode) {\n return (charCode === 9 || charCode === 10 || charCode === 12 || charCode === 13 || charCode === 32);\n}\n/**\n * Certain tags don't display their whitespace-only content. In such cases, we\n * should simplify the whitespace before counting it.\n */\nfunction shouldSimplifyWhiteSpace(tagStack) {\n for (var i = tagStack.length - 1; i >= 0; i--) {\n var tagName = tagStack[i];\n if (tagName === \"li\" || tagName === \"td\") {\n return false;\n }\n if (tagName === \"ol\" || tagName === \"table\" || tagName === \"ul\") {\n return true;\n }\n }\n return false;\n}\nfunction simplifyWhiteSpace(string) {\n return string.trim().replace(SIMPLIFY_WHITESPACE_REGEX, \" \");\n}\nfunction takeCharAt(string, index) {\n var charCode = string.charCodeAt(index);\n if ((charCode & 0xfc00) === 0xd800) {\n // high Unicode surrogate should never be separated from its matching low surrogate\n var nextCharCode = string.charCodeAt(index + 1);\n if ((nextCharCode & 0xfc00) === 0xdc00) {\n return String.fromCharCode(charCode, nextCharCode);\n }\n }\n return String.fromCharCode(charCode);\n}\nfunction takeHtmlCharAt(string, index) {\n var char = takeCharAt(string, index);\n if (char === \"&\") {\n while (true /* eslint-disable-line */) {\n index++;\n var nextCharCode = string.charCodeAt(index);\n if (isCharacterReferenceCharacter(nextCharCode)) {\n char += String.fromCharCode(nextCharCode);\n }\n else if (nextCharCode === SEMICOLON_CHAR_CODE) {\n char += String.fromCharCode(nextCharCode);\n break;\n }\n else {\n break;\n }\n }\n }\n return char;\n}\n"],"sourceRoot":""}