{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap 1b946e92f1c7833178ec","webpack:///./src/main/modules/Marklib.js","webpack:///./src/main/Rendering.js","webpack:///./~/babel-runtime/helpers/classCallCheck.js","webpack:///./~/babel-runtime/helpers/createClass.js","webpack:///./~/babel-runtime/core-js/object/define-property.js","webpack:///./~/babel-runtime/~/core-js/library/fn/object/define-property.js","webpack:///./~/babel-runtime/~/core-js/library/modules/es6.object.define-property.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_export.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_global.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_core.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_ctx.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_a-function.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_hide.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_object-dp.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_an-object.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_is-object.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_ie8-dom-define.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_descriptors.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_fails.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_dom-create.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_to-primitive.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_property-desc.js","webpack:///./~/babel-runtime/helpers/possibleConstructorReturn.js","webpack:///./~/babel-runtime/helpers/typeof.js","webpack:///./~/babel-runtime/core-js/symbol/iterator.js","webpack:///./~/babel-runtime/~/core-js/library/fn/symbol/iterator.js","webpack:///./~/babel-runtime/~/core-js/library/modules/es6.string.iterator.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_string-at.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_to-integer.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_defined.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_iter-define.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_library.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_redefine.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_has.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_iterators.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_iter-create.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_object-create.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_object-dps.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_object-keys.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_object-keys-internal.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_to-iobject.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_iobject.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_cof.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_array-includes.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_to-length.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_to-index.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_shared-key.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_shared.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_uid.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_enum-bug-keys.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_html.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_set-to-string-tag.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_wks.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_object-gpo.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_to-object.js","webpack:///./~/babel-runtime/~/core-js/library/modules/web.dom.iterable.js","webpack:///./~/babel-runtime/~/core-js/library/modules/es6.array.iterator.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_add-to-unscopables.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_iter-step.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_wks-ext.js","webpack:///./~/babel-runtime/core-js/symbol.js","webpack:///./~/babel-runtime/~/core-js/library/fn/symbol/index.js","webpack:///./~/babel-runtime/~/core-js/library/modules/es6.symbol.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_meta.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_wks-define.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_keyof.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_enum-keys.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_object-gops.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_object-pie.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_is-array.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_object-gopn-ext.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_object-gopn.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_object-gopd.js","webpack:///./~/babel-runtime/~/core-js/library/modules/es7.symbol.async-iterator.js","webpack:///./~/babel-runtime/~/core-js/library/modules/es7.symbol.observable.js","webpack:///./~/babel-runtime/helpers/inherits.js","webpack:///./~/babel-runtime/core-js/object/set-prototype-of.js","webpack:///./~/babel-runtime/~/core-js/library/fn/object/set-prototype-of.js","webpack:///./~/babel-runtime/~/core-js/library/modules/es6.object.set-prototype-of.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_set-proto.js","webpack:///./~/babel-runtime/core-js/object/create.js","webpack:///./~/babel-runtime/~/core-js/library/fn/object/create.js","webpack:///./~/babel-runtime/~/core-js/library/modules/es6.object.create.js","webpack:///./src/main/RenderResult.js","webpack:///./src/main/RenderingEvents.js","webpack:///./~/babel-runtime/helpers/slicedToArray.js","webpack:///./~/babel-runtime/core-js/is-iterable.js","webpack:///./~/babel-runtime/~/core-js/library/fn/is-iterable.js","webpack:///./~/babel-runtime/~/core-js/library/modules/core.is-iterable.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_classof.js","webpack:///./~/babel-runtime/core-js/get-iterator.js","webpack:///./~/babel-runtime/~/core-js/library/fn/get-iterator.js","webpack:///./~/babel-runtime/~/core-js/library/modules/core.get-iterator.js","webpack:///./~/babel-runtime/~/core-js/library/modules/core.get-iterator-method.js","webpack:///./~/babel-runtime/core-js/set.js","webpack:///./~/babel-runtime/~/core-js/library/fn/set.js","webpack:///./~/babel-runtime/~/core-js/library/modules/es6.set.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_collection-strong.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_redefine-all.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_an-instance.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_for-of.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_iter-call.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_is-array-iter.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_set-species.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_collection.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_array-methods.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_array-species-create.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_array-species-constructor.js","webpack:///./~/babel-runtime/~/core-js/library/modules/es7.set.to-json.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_collection-to-json.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_array-from-iterable.js","webpack:///./~/babel-runtime/core-js/object/assign.js","webpack:///./~/babel-runtime/~/core-js/library/fn/object/assign.js","webpack:///./~/babel-runtime/~/core-js/library/modules/es6.object.assign.js","webpack:///./~/babel-runtime/~/core-js/library/modules/_object-assign.js","webpack:///./~/wolfy87-eventemitter/EventEmitter.js","webpack:///./src/main/util/Util.js"],"names":["Rendering","Util","RenderResult","RenderingEvents","registerEvents","TAG_NAME","ATTR_DATA_ORIGINAL_OFFSET_START","DATA_ORIGINAL_TEXT_NODE_INDEX","ATTR_DATA_START_END","ATTR_DATA_IS_HIGHLIGHT_NODE","ATTR_DATA_ID","DOCUMENT_POSITION_CONTAINED_BY","EVENT_WRAPPED_NODE","document","options","context","id","guid","startContainer","endContainer","_renderResult","getId","setId","wrapperNodes","forEach","node","setAttribute","_createWrapTemplate","omitHighlight","el","createElement","vTrue","className","join","setMarklibInstance","push","_createStartEndWrapTemplate","text","textContent","_createStartOrEndContainer","initialNode","offset","index","wrapper","getIndexParentIfHas","_createWrap","optionalLength","optionalIndex","optionalIsSameNode","originalIndex","calcIndex","offsetLength","getOffsetParentIfHas","wrap","emit","_createSplitContainer","originalElement","walk","start","nextParent","nextParentNode","parentNode","currentParentNode","wrapSiblings","nextSibling","next","found","n","instance","getMarklibInstance","hasAttribute","undefined","wrapIf","nodeIsEmpty","walkIfContained","e","Node","TEXT_NODE","nodeType","walkIfNotContained","currentNext","compareDocumentPosition","walkDom","walkTextNodes","_markTextSameNode","textNode","startIndex","endIndex","initialText","nodeValue","initialIndex","textBefore","slice","insertBefore","createTextNode","previousSibling","length","textAfter","_markTextDifferentNode","startOffset","endOffset","startContainerIndex","endContainerIndex","fullTextStartValue","startT","partTextStartValue","offsetStart","endT","fullTextEndValue","partTextEndValue","offsetParent","_renderWithElements","startContainerP","endContainerP","commonAncestor","endOffsetP","outer","parents","contextContainer","originalStartOffset","findOriginalOffset","originalEndOffset","nextElementSibling","toFindNode","previousElementSibling","endContainerContents","closest","childNodes","r","f","lastChild","parseInt","getAttribute","Error","getPath","_renderSelection","result","indexOf","splice","renderWithPath","startPath","endPath","deserializePath","range","createRange","setStart","setEnd","toString","renderWithRange","renderWithResult","startContainerPath","endContainerPath","commonAncestorContainer","destroy","marklibInstance","removeEvent","_renderingInstance","fromObject","serialize","_text","EVENT_CLICK","EVENT_MOUSEENTER","EVENT_MOUSELEAVE","EVENT_PART_TREE_ENTER","EVENT_PART_TREE_LEAVE","hoverClass","treeClass","split","globalEmitter","staticEventListener","textNodes","lastTextNode","HAS_EVENTS","currentHoverInstances","betweenInstances","checkMarklibInstance","closestInstance","closestCallback","target","thisE","getInstancesBetween","parentsCallback","map","mouseOutClear","thisInstance","clear","findTarget","between","allInstances","unshift","sort","a","b","on","classList","add","remove","global","addEventListener","instanceBetween","ATTR_DATA_ORIGINAL_INDEX","DATA_IS_SELECTION","SERIALIZE_SEPARATOR","Element","prototype","matches","p","matchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","nodeListFilter","nodes","func","Array","filter","call","s4","Math","floor","random","substring","match","optionalList","children","elms","thisElms","NodeList","i","child","cloneNode","parent","sibling","appendChild","calculatedIndex","foundWrapper","thisIndex","maybeIndexOfOriginal","optionalSelector","element","callback","foundElements","selector","outerMostCallback","lastValid","isMarkNode","HTMLElement","path","filterSiblings","thisEl","nodeName","name","outerMostElement","reverse","toLowerCase","siblings","nodeIndex","replace","lengthElement","pSplit","objectIndex","charOffset","container","trim","querySelector","maybeFoundNode","atrOffsetStart","atrIndex","thisOffset"],"mappings":"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;;;;ACAlB;AACA;AACA;AACA;AACA,G;;;;;;ACJA;AACA;AACA,sEAAuE,0CAA0C,E;;;;;;ACFjH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAmE;AACnE;AACA,sFAAqF;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW;AACX,UAAS;AACT;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA,gDAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA,eAAc;AACd,eAAc;AACd,eAAc;AACd,eAAc;AACd,gBAAe;AACf,gBAAe;AACf,gBAAe;AACf,iBAAgB;AAChB,0B;;;;;;AC5DA;AACA;AACA;AACA,wCAAuC,gC;;;;;;ACHvC,8BAA6B;AAC7B,sCAAqC,gC;;;;;;ACDrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,G;;;;;;ACnBA;AACA;AACA;AACA,G;;;;;;ACHA;AACA;AACA;AACA;AACA,EAAC;AACD;AACA;AACA,G;;;;;;ACPA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG,UAAU;AACb;AACA;AACA;AACA,G;;;;;;ACfA;AACA;AACA;AACA;AACA,G;;;;;;ACJA;AACA;AACA,G;;;;;;ACFA;AACA,sEAAsE,gBAAgB,UAAU,GAAG;AACnG,EAAC,E;;;;;;ACFD;AACA;AACA,kCAAiC,QAAQ,gBAAgB,UAAU,GAAG;AACtE,EAAC,E;;;;;;ACHD;AACA;AACA;AACA,IAAG;AACH;AACA;AACA,G;;;;;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA,G;;;;;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,G;;;;;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,G;;;;;;ACPA;;AAEA;;AAEA;;AAEA;;AAEA,uCAAsC,uCAAuC,gBAAgB;;AAE7F;AACA;AACA;AACA;;AAEA;AACA,G;;;;;;AChBA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,kHAAiH,mBAAmB,EAAE,mBAAmB,4JAA4J;;AAErT,uCAAsC,uCAAuC,gBAAgB;;AAE7F;AACA;AACA,EAAC;AACD;AACA,G;;;;;;ACpBA,mBAAkB,wD;;;;;;ACAlB;AACA;AACA,wD;;;;;;ACFA;AACA;;AAEA;AACA;AACA,8BAA6B;AAC7B,eAAc;AACd;AACA,EAAC;AACD;AACA;AACA;AACA,gCAA+B;AAC/B;AACA;AACA,WAAU;AACV,EAAC,E;;;;;;AChBD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,G;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA,G;;;;;;ACLA;AACA;AACA;AACA;AACA,G;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,6BAA4B,aAAa;;AAEzC;AACA;AACA;AACA;AACA;AACA,yCAAwC,oCAAoC;AAC5E,6CAA4C,oCAAoC;AAChF,MAAK,2BAA2B,oCAAoC;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAgB,mBAAmB;AACnC;AACA;AACA,kCAAiC,2BAA2B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA,G;;;;;;ACrEA,uB;;;;;;ACAA,0C;;;;;;ACAA,wBAAuB;AACvB;AACA;AACA,G;;;;;;ACHA,qB;;;;;;ACAA;AACA;AACA;AACA;AACA;;AAEA;AACA,4FAAgF,aAAa,EAAE;;AAE/F;AACA,sDAAqD,0BAA0B;AAC/E;AACA,G;;;;;;ACZA;AACA;AACA;AACA;AACA;AACA,8BAA6B;AAC7B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA6B;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;;;;;;;ACxCA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,G;;;;;;ACZA;AACA;AACA;;AAEA;AACA;AACA,G;;;;;;ACNA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,G;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA,G;;;;;;ACLA;AACA;AACA;AACA;AACA,G;;;;;;ACJA,kBAAiB;;AAEjB;AACA;AACA,G;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK,WAAW,eAAe;AAC/B;AACA,MAAK;AACL;AACA,G;;;;;;ACpBA;AACA;AACA;AACA;AACA,4DAA2D;AAC3D,G;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA,G;;;;;;ACNA;AACA;AACA;AACA;AACA,G;;;;;;ACJA;AACA;AACA,oDAAmD;AACnD;AACA,wCAAuC;AACvC,G;;;;;;ACLA;AACA;AACA;AACA;AACA,G;;;;;;ACJA;AACA;AACA;AACA,c;;;;;;ACHA,8E;;;;;;ACAA;AACA;AACA;;AAEA;AACA,mEAAkE,+BAA+B;AACjG,G;;;;;;ACNA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,wB;;;;;;ACVA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH,G;;;;;;ACZA;AACA;AACA;AACA;AACA,G;;;;;;ACJA;AACA;AACA;AACA;AACA;;AAEA,yGAAwG,OAAO;AAC/G;AACA;AACA;AACA;AACA;AACA,E;;;;;;ACZA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iCAAgC;AAChC,eAAc;AACd,kBAAiB;AACjB;AACA,EAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAC;;AAED;AACA;;AAEA;AACA;AACA,6B;;;;;;ACjCA,6BAA4B,e;;;;;;ACA5B;AACA,WAAU;AACV,G;;;;;;ACFA,qC;;;;;;ACAA,mBAAkB,wD;;;;;;ACAlB;AACA;AACA;AACA;AACA,iD;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,uBAAsB;AACtB,qBAAoB,uBAAuB,SAAS,IAAI;AACxD,IAAG;AACH,EAAC;AACD;AACA;AACA;AACA;AACA,EAAC;;AAED;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,EAAC;AACD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAAyD;AACzD;AACA,MAAK;AACL;AACA,uBAAsB,iCAAiC;AACvD,MAAK;AACL,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA8D,8BAA8B;AAC5F;AACA;AACA;AACA;AACA,IAAG;;AAEH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,2DAA0D,gBAAgB;;AAE1E;AACA;AACA;AACA,qBAAoB,oBAAoB;;AAExC,2CAA0C,oBAAoB;;AAE9D;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA,IAAG;AACH,yBAAwB,eAAe,EAAE;AACzC,yBAAwB,gBAAgB;AACxC,EAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA,qDAAoD,KAAK,QAAQ,iCAAiC;AAClG,EAAC;AACD;AACA,gDAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2C;;;;;;AC1OA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAiD;AACjD,EAAC;AACD;AACA,sBAAqB;AACrB;AACA,UAAS;AACT,KAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,G;;;;;;ACpDA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA0D,sBAAsB;AAChF,iFAAgF,sBAAsB;AACtG,G;;;;;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,G;;;;;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH,G;;;;;;ACdA,0C;;;;;;ACAA,eAAc,sB;;;;;;ACAd;AACA;AACA;AACA;AACA,G;;;;;;ACJA;AACA;AACA;AACA,mBAAkB;;AAElB;AACA;;AAEA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;;;;;;;AClBA;AACA;AACA;;AA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AEA;AACA;AACA,yBAAwB,mEAAmE;AAC3F,EAAC;AACD;AACA;AACA;AACA;AACA,EAAC,U;;;;;;ACXD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,uBAAsB,OAAO;AAC7B;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,8BAA6B;AAC7B,2BAA0B;AAC1B,2BAA0B;AAC1B,sBAAqB;AACrB;AACA,MAAK;AACL;AACA;AACA;AACA;AACA,8DAA6D,OAAO;AACpE;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT,QAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA,MAAK;AACL;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL,IAAG;AACH;AACA;AACA;AACA;AACA;AACA,0BAAyB;AACzB,sBAAqB;AACrB,2BAA0B;AAC1B,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;;AAEL;AACA;AACA;AACA,G;;;;;;AC7IA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH,G;;;;;;ACNA;AACA;AACA;AACA,IAAG;AACH,G;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAqC,iBAAiB,EAAE;AACxD;AACA;AACA;AACA;AACA;AACA,iEAAgE,gBAAgB;AAChF;AACA;AACA,IAAG,2CAA2C,gCAAgC;AAC9E;AACA;AACA;AACA;AACA;AACA,yB;;;;;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA,G;;;;;;ACXA;AACA;AACA;AACA;;AAEA;AACA;AACA,G;;;;;;ACPA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,qBAAoB,aAAa;AACjC,IAAG;AACH,G;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP,MAAK;AACL;AACA;AACA;AACA;AACA,MAAK;AACL;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA,G;;;;;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS,eAAe;AACxB;AACA;AACA;AACA,uCAAsC;AACtC;AACA,+BAA8B;AAC9B,8BAA6B;AAC7B,gCAA+B;AAC/B,oCAAmC;AACnC,UAAS,+BAA+B;AACxC;AACA;AACA;AACA;AACA,G;;;;;;AC3CA;AACA;;AAEA;AACA;AACA,G;;;;;;ACLA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH,G;;;;;;ACfA;AACA;;AAEA,wCAAuC,wCAAgD,E;;;;;;ACHvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,G;;;;;;ACRA;;AAEA;AACA;AACA;AACA;AACA;;;;;;;ACNA,mBAAkB,yD;;;;;;ACAlB;AACA,wD;;;;;;ACDA;AACA;;AAEA,2CAA0C,iCAAoC,E;;;;;;ACH9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAkC,UAAU,EAAE;AAC9C,oBAAmB,sCAAsC;AACzD,EAAC,oCAAoC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH,EAAC,W;;;;;;AChCD;AACA;AACA;AACA;AACA;AACA;;AAEA,EAAC;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,gBAAe,WAAW;AAC1B,gBAAe,SAAS;AACxB,iBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,gBAAe,OAAO;AACtB,iBAAgB,SAAS;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAe,cAAc;AAC7B,iBAAgB,kBAAkB;AAClC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,gBAAe,SAAS;AACxB,iBAAgB,WAAW;AAC3B;AACA;AACA;AACA;;AAEA,oBAAmB,sBAAsB;AACzC;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,gBAAe,cAAc;AAC7B,iBAAgB,OAAO;AACvB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,UAAS;AACT;AACA,UAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAe,cAAc;AAC7B,gBAAe,SAAS;AACxB,iBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,kBAAiB;AACjB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,gBAAe,cAAc;AAC7B,gBAAe,SAAS;AACxB,iBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,gBAAe,OAAO;AACtB,iBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,gBAAe,SAAS;AACxB,iBAAgB,OAAO;AACvB;AACA;AACA,wBAAuB,iBAAiB;AACxC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,gBAAe,cAAc;AAC7B,gBAAe,SAAS;AACxB,iBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAe,qBAAqB;AACpC,gBAAe,WAAW;AAC1B,iBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAe,qBAAqB;AACpC,gBAAe,WAAW;AAC1B,iBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAe,QAAQ;AACvB,gBAAe,qBAAqB;AACpC,gBAAe,WAAW;AAC1B,iBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAe,cAAc;AAC7B,iBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAe,cAAc;AAC7B,gBAAe,MAAM;AACrB,iBAAgB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","file":"js/marklib.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Marklib\"] = factory();\n\telse\n\t\troot[\"Marklib\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"../\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 1b946e92f1c7833178ec","import Rendering from '../Rendering';\nimport Util from '../util/Util';\nimport RenderResult from '../RenderResult';\nimport RenderingEvents, { registerEvents } from '../RenderingEvents';\n\nexport { Rendering, Util, RenderResult, RenderingEvents, registerEvents };\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/modules/Marklib.js","/* global Node */\n\nimport RenderResult from './RenderResult';\nimport RenderingEvents from './RenderingEvents';\nimport Util, { ATTR_DATA_ORIGINAL_INDEX, DATA_IS_SELECTION } from './util/Util';\n\n/**\n * @type {string}\n */\nconst TAG_NAME = 'x-marker';\n/**\n * @type {string}\n */\nexport const ATTR_DATA_ORIGINAL_OFFSET_START = 'data-original-offset-start';\n/**\n * @type {string}\n */\nconst DATA_ORIGINAL_TEXT_NODE_INDEX = 'original-text-node-index';\n/**\n * @type {string}\n */\nconst ATTR_DATA_START_END = 'data-is-start-end';\n/**\n * @type {string}\n */\nconst ATTR_DATA_IS_HIGHLIGHT_NODE = 'data-is-highlight-node';\n/**\n * @type {string}\n */\nconst ATTR_DATA_ID = 'data-selection-id';\n\n/**\n * @see https://developer.mozilla.org/de/docs/Web/API/Node/compareDocumentPosition\n * @type {number}\n */\nconst DOCUMENT_POSITION_CONTAINED_BY = 16;\n\n\n/**\n * @type {string}\n */\nexport const EVENT_WRAPPED_NODE = 'wrapped-node';\n\n/**\n * Manages a single Render\n */\nclass Rendering extends RenderingEvents {\n\n  /**\n   * @param {Document} document\n   * @param {object} options\n   * @param {Node} context\n   */\n  constructor(document, options, context) {\n    super(options, document);\n\n    /**\n     * ID of rendering, will be set on each element that is part of it\n     * @type {String}\n     */\n    this.id = Util.guid();\n\n    /**\n     * StartContainer\n     * @type {Node}\n     */\n    this.startContainer = null;\n\n    /**\n     * EndContainer\n     * @type {Node}\n     */\n    this.endContainer = null;\n\n    /**\n     * @type {Node}\n     */\n    this.context = context || this.document;\n\n    /**\n     * Flag if this instance has been rendered\n     * @type {RenderResult}\n     * @private\n     */\n    this._renderResult = null;\n  }\n\n  /**\n   * @returns {string} id of this rendering\n   */\n  getId() {\n    return this.id;\n  }\n\n  /**\n   * @param {string} id\n   * @returns {Rendering}\n   */\n  setId(id) {\n    this.id = id;\n\n    if (this._renderResult) {\n      this.wrapperNodes.forEach((node) => node.setAttribute(ATTR_DATA_ID, this.id));\n    }\n\n    return this;\n  }\n\n  /**\n   * Creates a Template used as a wrapper and an indication that this is a highlight node\n   * @param {Boolean} [omitHighlight]\n   * @returns {Node}\n   * @private\n   */\n  _createWrapTemplate(omitHighlight) {\n    const el = this.document.createElement(TAG_NAME);\n    const vTrue = \"true\";\n\n    if (!omitHighlight) {\n      el.className = this.options.className.join(' ');\n      // save this marker instance to given node\n      Rendering.setMarklibInstance(el, this);\n      // keep track of highlight nodes\n      this.wrapperNodes.push(el);\n      el.setAttribute(ATTR_DATA_IS_HIGHLIGHT_NODE, vTrue);\n      el.setAttribute(ATTR_DATA_ID, this.getId());\n    }\n    el.setAttribute(DATA_IS_SELECTION, vTrue);\n\n    return el;\n  }\n\n  /**\n   * Creates a Template to use as start and end marks\n   * @param {String} text\n   * @returns {Node}\n   * @private\n   */\n  _createStartEndWrapTemplate(text) {\n    const el = this._createWrapTemplate();\n    el.setAttribute(ATTR_DATA_START_END, 'true');\n    el.textContent = text;\n    return el;\n  }\n\n\n  /**\n   * Creates Start or End Container Element\n   * @param initialNode\n   * @param text\n   * @param offset\n   * @param index\n   * @returns {Node}\n   */\n  _createStartOrEndContainer(initialNode, text, offset, index) {\n    const wrapper = this._createStartEndWrapTemplate(text);\n    wrapper.setAttribute(ATTR_DATA_ORIGINAL_INDEX, Util.getIndexParentIfHas(initialNode, index));\n    wrapper.setAttribute(ATTR_DATA_ORIGINAL_OFFSET_START, offset);\n    wrapper.setAttribute(DATA_ORIGINAL_TEXT_NODE_INDEX, index);\n\n    return wrapper;\n  }\n\n  /**\n   * Wraps given element\n   * @param {Node|HTMLElement} el\n   * @param [optionalLength]\n   * @param [optionalIndex]\n   * @param [optionalIsSameNode]\n   * @param {Boolean} [omitHighlight] set to true to prevent node to be a highlight node\n   * @returns {Node}\n   * @private\n   */\n  _createWrap(el, optionalLength, optionalIndex, optionalIsSameNode, omitHighlight) {\n    const originalIndex = optionalIndex >= 0 ? optionalIndex : Util.calcIndex(el);\n    const wrapper = this._createWrapTemplate(omitHighlight);\n    wrapper.setAttribute(ATTR_DATA_ORIGINAL_INDEX, Util.getIndexParentIfHas(el, originalIndex));\n    const offsetLength = optionalLength >= 0 ? optionalLength : Util.getOffsetParentIfHas(el);\n    wrapper.setAttribute(ATTR_DATA_ORIGINAL_OFFSET_START, offsetLength);\n\n    // Save a reference to original text node in wrapper\n    wrapper.setAttribute(DATA_ORIGINAL_TEXT_NODE_INDEX, originalIndex);\n\n    if (optionalIsSameNode) {\n      wrapper.setAttribute(ATTR_DATA_START_END, ATTR_DATA_START_END);\n    }\n    const wrap = Util.wrap(el, wrapper);\n\n    this.emit(EVENT_WRAPPED_NODE, el, wrap);\n\n    return wrap;\n  }\n\n  /**\n   * Create split container element\n   * @param originalElement {Node} original text node element that is created a wrapper for\n   * @param index\n   * @param offset\n   * @returns {Node}\n   */\n  _createSplitContainer(originalElement, index, offset) {\n    const wrapper = this.document.createElement(TAG_NAME);\n    wrapper.setAttribute(DATA_IS_SELECTION, 'true');\n    wrapper.setAttribute(ATTR_DATA_ORIGINAL_INDEX, Util.getIndexParentIfHas(originalElement, index));\n    wrapper.setAttribute(ATTR_DATA_ORIGINAL_OFFSET_START, offset);\n    wrapper.setAttribute(DATA_ORIGINAL_TEXT_NODE_INDEX, index);\n    return wrapper;\n  }\n\n  /**\n   * Walks the tree\n   * @param start\n   * @param endContainer\n   * @param nextParent\n   */\n  walk(start, endContainer, nextParent) {\n    let nextParentNode = start;\n    while (nextParentNode && nextParentNode !== nextParent.parentNode) {\n      const currentParentNode = nextParentNode;\n      nextParentNode = nextParentNode.parentNode;\n      if (this.wrapSiblings(currentParentNode.nextSibling, endContainer)) {\n        break;\n      }\n    }\n  }\n\n\n  /**\n   * Will Wrap all textNode siblings of a container (start) inside a defined Element (like a span)\n   * If an Element node is found, it will wrap all children of this node inside a element as well.\n   * It will stop if endContainer is found as a node\n   *\n   * @param {Node} start\n   * @param {Node} endContainer\n   * @returns {boolean} (true if endContainer was found)\n   */\n  wrapSiblings(start, endContainer) {\n    let next = start;\n    let found = false;\n\n    // Capsule some logic\n    const wrap = (n) => {\n      const instance = Rendering.getMarklibInstance(n.parentNode);\n      if (n.parentNode.hasAttribute(ATTR_DATA_START_END) &&\n        n.parentNode.hasAttribute(ATTR_DATA_IS_HIGHLIGHT_NODE) &&\n        instance === this) {\n        this._createWrap(n, undefined, undefined, undefined, true);\n      } else {\n        this._createWrap(n);\n      }\n    };\n\n    // helper functions\n\n    const wrapIf = (n) => {\n      if (!Util.nodeIsEmpty(n)) {\n        wrap(n);\n      }\n    };\n\n    const walkIfContained = (e) => {\n      if (e === endContainer) {\n        return false;\n      }\n      if (Node.TEXT_NODE === e.nodeType) {\n        wrapIf(e);\n      }\n      return true;\n    };\n\n    const walkIfNotContained = (el) => {\n      wrapIf(el);\n    };\n\n    while (next !== null && next !== endContainer) {\n      const currentNext = next;\n      next = next.nextSibling;\n      // Found a text node, directly wrap inside a span\n      if (Node.TEXT_NODE === currentNext.nodeType) {\n        wrapIf(currentNext);\n      } else {\n        if ((currentNext.compareDocumentPosition(endContainer) & DOCUMENT_POSITION_CONTAINED_BY)) {\n          Util.walkDom(currentNext, walkIfContained);\n          found = true;\n        } else {\n          Util.walkTextNodes(currentNext, walkIfNotContained);\n        }\n        if (found) {\n          return true;\n        }\n      }\n    }\n    return found;\n  }\n\n  /**\n   * Marks text of the same node\n   * @param {Node} textNode\n   * @param {int} startIndex\n   * @param {int} endIndex\n   * @private\n   */\n  _markTextSameNode(textNode, startIndex, endIndex) {\n    const initialText = textNode.nodeValue;\n    const initialIndex = Util.calcIndex(textNode);\n\n    if (!initialText) {\n      return false;\n    }\n    // If there is an unmarked part in the beginning of the text node,\n    // cut off that part and put it into it's own textnode.\n    if (startIndex > 0) {\n      const textBefore = initialText.slice(0, startIndex);\n      textNode.parentNode.insertBefore(this.document.createTextNode(textBefore), textNode);\n      // wrap cutted text node:\n      Util.wrap(textNode.previousSibling, this._createSplitContainer(textNode,\n        initialIndex, Util.getOffsetParentIfHas(textNode)));\n    }\n    // If there is an unmarked part at the end of the text node,\n    // cut off that part and put it into it's own textnode.\n    if (endIndex < initialText.length) {\n      const textAfter = initialText.slice(endIndex, initialText.length);\n      textNode.parentNode.insertBefore(this.document.createTextNode(textAfter), textNode.nextSibling);\n      Util.wrap(textNode.nextSibling, this._createSplitContainer(textNode,\n        initialIndex, Util.getOffsetParentIfHas(textNode) + endIndex));\n    }\n\n    // Cutoff the unmarked parts and wrap the textnode into a span.\n    textNode.nodeValue = initialText.slice(startIndex, endIndex);\n    this.startContainer = this._createWrap(textNode,\n      Util.getOffsetParentIfHas(textNode) + startIndex, initialIndex, true).parentNode;\n    this.endContainer = this.startContainer;\n    return this.startContainer;\n  }\n\n\n  /**\n   * Marks text of end and start containers if start and end nodes are different\n   * Important: There might be no end container!\n   *\n   * @param {Node} startContainer\n   * @param {Node} endContainer\n   * @param {int} startOffset\n   * @param {int} endOffset\n   * @returns {{startT: (Node), endT: (Node)}}\n   * @private\n   */\n  _markTextDifferentNode(startContainer, endContainer, startOffset, endOffset) {\n    // Get current for both start and end:\n    const startContainerIndex = Util.calcIndex(startContainer);\n    const endContainerIndex = Util.calcIndex(endContainer);\n\n    // Split text\n    const fullTextStartValue = startContainer.nodeValue;\n    // init with startContainer because we may have not a text node here\n    let startT = startContainer;\n\n    if (undefined !== fullTextStartValue) {\n      const partTextStartValue = fullTextStartValue.slice(startOffset, fullTextStartValue.length);\n      // Set new text to start node\n      startContainer.nodeValue = fullTextStartValue.slice(0, startOffset);\n\n      const offsetStart = Util.getOffsetParentIfHas(startContainer);\n      // Create a new node for splitted text, offset is the length of new startContainer.nodeValue:\n      startT = this._createStartOrEndContainer(startContainer, partTextStartValue,\n        offsetStart === startOffset ? offsetStart : offsetStart + startOffset, startContainerIndex);\n      // Append this node after startContainer\n      startContainer.parentNode.insertBefore(startT, startContainer.nextSibling);\n      this.startContainer = startT;\n\n      if (startContainer.nodeValue) {\n        // Wrap start container in detection node, offset is always 0 or parent offset.\n        Util.wrap(startContainer, this._createSplitContainer(startContainer, startContainerIndex,\n          Util.getOffsetParentIfHas(startContainer)));\n      }\n    }\n\n    // init with endContainer because we may have not a text node here\n    let endT = endContainer;\n\n    // 2. Extract end Text node,\n    const fullTextEndValue = endContainer.nodeValue;\n    // It's possible that end container value is null (if a whole paragraph is marked)\n    if (undefined !== fullTextEndValue) {\n      // Split text\n      const partTextEndValue = fullTextEndValue.slice(0, endOffset);\n      endContainer.nodeValue = fullTextEndValue.slice(endOffset, fullTextEndValue.length);\n      // End Container start offset is always 0 or parent offset.\n      endT = this._createStartOrEndContainer(endContainer, partTextEndValue,\n        Util.getOffsetParentIfHas(endContainer), endContainerIndex);\n\n      endContainer.parentNode.insertBefore(endT, endContainer);\n      this.endContainer = endT;\n      const offsetParent = Util.getOffsetParentIfHas(endContainer);\n      Util.wrap(endContainer, this._createSplitContainer(endContainer, endContainerIndex,\n        offsetParent === endOffset ? offsetParent : offsetParent + endOffset));\n    }\n\n    return {\n      startT,\n      endT\n    };\n  }\n\n  /**\n   * Renders a selection\n   * @param {Node} startContainerP\n   * @param {Node} endContainerP\n   * @param {Node} commonAncestor\n   * @param {int} startOffset\n   * @param {int} endOffsetP\n   * @returns RenderResult\n   * @private\n   */\n  _renderWithElements(startContainerP, endContainerP, commonAncestor, startOffset, endOffsetP) {\n    if (this._renderResult) {\n      return this._renderResult;\n    }\n    let startContainer = startContainerP;\n    let endContainer = endContainerP;\n    let endOffset = endOffsetP;\n    let outer = Util.parents(startContainer, commonAncestor);\n    outer = outer[outer.length - 1];\n    const contextContainer = outer || commonAncestor;\n\n    // Same Element, means the selection is fully contained in a discrete area,\n    // start and endpoint have the same parent\n    // but are different nodes:\n\n    // Start and End offset have to be recalculated because dom might be already changed by\n    // highlighting in given node\n    // 1: First detect real start offset in startContainer:\n\n    // That works by selecting the highest wrapper and get original-offset-start data element,\n    // see \"findOriginalOffset\"\n    // So first select that container:\n    const originalStartOffset = Util.findOriginalOffset(startContainer);\n    const originalEndOffset = Util.findOriginalOffset(endContainer);\n\n    // We may run into Browser Bugs:\n\n    // If both are not text nodes, use next sibling as endContainer\n    if (startContainer.nodeType !== Node.TEXT_NODE && endContainer.nodeType !== Node.TEXT_NODE) {\n      if (startContainer === endContainer) {\n        endContainer = endContainer.nextElementSibling || endContainer;\n      }\n    }\n    // IF start/end container is not type of text, select first child text node:\n    // We run in some bugs with firefox here that selects no text-nodes sometimes, trying to fix this here\n    // Sometimes does not work correctly... (specially when DOM was modified)\n    if (startContainer.nodeType !== Node.TEXT_NODE) {\n      Util.walkDom(startContainer, (el) => {\n        if (el.nodeType === Node.TEXT_NODE) {\n          startContainer = el;\n          return false;\n        }\n        return true;\n      });\n    }\n\n    if (endContainer.nodeType !== Node.TEXT_NODE) {\n      let toFindNode = startContainer;\n\n      if (endOffset === 0) {\n        toFindNode = endContainer.previousElementSibling || startContainer;\n      }\n\n      // Get the last text node:\n      const endContainerContents = Util.closest(toFindNode, `:not([${DATA_IS_SELECTION}])`).childNodes;\n      if (endContainerContents.length) {\n        const r = endContainerContents[endContainerContents.length - 1];\n        if (r.nodeType === Node.TEXT_NODE) {\n          endContainer = r;\n          endOffset = r.length;\n        } else {\n          let f = r.lastChild;\n          while (f !== null) {\n            if (f && f.nodeType === Node.TEXT_NODE) {\n              endContainer = f;\n              endOffset = f.length;\n              if (f.parentNode.hasAttribute(ATTR_DATA_ORIGINAL_OFFSET_START)) {\n                endOffset = parseInt(f.parentNode\n                    .getAttribute(ATTR_DATA_ORIGINAL_OFFSET_START), 10) + endOffset;\n              }\n            }\n            f = f.lastChild;\n          }\n        }\n      }\n      // still no textNode?\n      if (endContainer.nodeType !== Node.TEXT_NODE) {\n        throw Error('Could not found endContainer, highlighting would be unstable');\n      }\n    }\n\n    this._renderResult = new RenderResult(\n      // Real offset is calculated by relative length and absolute length\n      originalStartOffset + startOffset,\n      originalEndOffset + endOffset,\n      // get the path for this selection\n      Util.getPath(startContainer, this.context),\n      Util.getPath(endContainer, this.context)\n    );\n\n    this._renderResult.instance = this;\n\n\n    this._renderSelection(startContainer, endContainer, startOffset, endOffset, contextContainer, !!outer);\n\n    return this._renderResult;\n  }\n\n  /**\n   * Renders a given selection\n   *\n   * @param {Node} startContainer\n   * @param {Node} endContainer\n   * @param {int} startOffset\n   * @param {int} endOffset\n   * @param {Node} contextContainer\n   * @param {Boolean} outer\n   * @private\n   */\n  _renderSelection(startContainer, endContainer, startOffset, endOffset, contextContainer, outer) {\n    // if start and end-container are the same, mark text on the same node\n    if (startContainer === endContainer) {\n      this._markTextSameNode(startContainer, startOffset, endOffset);\n    } else {\n      const result = this._markTextDifferentNode(startContainer, endContainer, startOffset, endOffset);\n      const index = this.wrapperNodes.indexOf(result.endT);\n      // remove endContainer, to keep order:\n      this.wrapperNodes.splice(index, 1);\n      if (!outer) {\n        this.wrapSiblings(result.startT.nextSibling, endContainer);\n      } else {\n        this.walk(result.startT, endContainer, contextContainer);\n      }\n      this.wrapperNodes.push(result.endT);\n    }\n  }\n\n  /**\n   * Prepares to render a Selection with path selectors\n   * ```\n   * A Path looks like this:\n   *\n   * #selector;#textnode;#offset\n   * ``\n   * @param {string} startPath\n   * @param {string} endPath\n   * @returns {string}\n   */\n  renderWithPath(startPath, endPath) {\n    const startContainer = Util.deserializePath(startPath, this.context);\n    const endContainer = Util.deserializePath(endPath, this.context);\n    if (startContainer && endContainer && startContainer.node && endContainer.node) {\n      const range = document.createRange();\n      range.setStart(startContainer.node, startContainer.offset);\n      range.setEnd(endContainer.node, endContainer.offset);\n      const text = range.toString();\n      const result = this.renderWithRange(range);\n      result.text = text;\n      return text;\n    }\n    throw new Error('Could not find start- and/or end-container in document');\n  }\n\n  /**\n   * @returns {RenderResult}\n   */\n  get result() {\n    return this._renderResult;\n  }\n\n  /**\n   * Renders a result (that returned from `renderWithRange`)\n   * @param {RenderResult|Object} result\n   * @returns {string}\n   */\n  renderWithResult(result) {\n    return this.renderWithPath(\n      `${result.startContainerPath};${result.startOffset}`,\n      `${result.endContainerPath};${result.endOffset}`);\n  }\n\n  /**\n   * Prepares a selection with a range object\n   * @param {Range} range\n   * @returns {Object}\n   */\n  renderWithRange(range) {\n    const text = range.toString();\n    const result = this._renderWithElements(range.startContainer, range.endContainer,\n      range.commonAncestorContainer, range.startOffset, range.endOffset);\n    result.text = text;\n    return result;\n  }\n\n  /**\n   * Removes bindings and classNames to nodes\n   */\n  destroy() {\n    this.wrapperNodes.forEach((node) => {\n      delete node.marklibInstance;\n      node.className = '';\n    });\n    this.removeEvent();\n  }\n\n  /**\n   * @param {Node} el\n   * @param {Rendering} instance\n   * @returns {Node}\n   */\n  static setMarklibInstance(el, instance) {\n    el.marklibInstance = instance;\n    return el;\n  }\n\n  /**\n   * @param {Node} el\n   * @returns {Rendering|null|undefined}\n   */\n  static getMarklibInstance(el) {\n    return el ? el.marklibInstance : null;\n  }\n}\n\nexport default Rendering;\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/Rendering.js","\"use strict\";\n\nexports.__esModule = true;\n\nexports.default = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/classCallCheck.js\n// module id = 3\n// module chunks = 0 1","\"use strict\";\n\nexports.__esModule = true;\n\nvar _defineProperty = require(\"../core-js/object/define-property\");\n\nvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      (0, _defineProperty2.default)(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/createClass.js\n// module id = 4\n// module chunks = 0 1","module.exports = { \"default\": require(\"core-js/library/fn/object/define-property\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/define-property.js\n// module id = 5\n// module chunks = 0 1","require('../../modules/es6.object.define-property');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function defineProperty(it, key, desc){\n  return $Object.defineProperty(it, key, desc);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/fn/object/define-property.js\n// module id = 6\n// module chunks = 0 1","var $export = require('./_export');\n// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)\n$export($export.S + $export.F * !require('./_descriptors'), 'Object', {defineProperty: require('./_object-dp').f});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/es6.object.define-property.js\n// module id = 7\n// module chunks = 0 1","var global    = require('./_global')\n  , core      = require('./_core')\n  , ctx       = require('./_ctx')\n  , hide      = require('./_hide')\n  , PROTOTYPE = 'prototype';\n\nvar $export = function(type, name, source){\n  var IS_FORCED = type & $export.F\n    , IS_GLOBAL = type & $export.G\n    , IS_STATIC = type & $export.S\n    , IS_PROTO  = type & $export.P\n    , IS_BIND   = type & $export.B\n    , IS_WRAP   = type & $export.W\n    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})\n    , expProto  = exports[PROTOTYPE]\n    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]\n    , key, own, out;\n  if(IS_GLOBAL)source = name;\n  for(key in source){\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    if(own && key in exports)continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function(C){\n      var F = function(a, b, c){\n        if(this instanceof C){\n          switch(arguments.length){\n            case 0: return new C;\n            case 1: return new C(a);\n            case 2: return new C(a, b);\n          } return new C(a, b, c);\n        } return C.apply(this, arguments);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n    if(IS_PROTO){\n      (exports.virtual || (exports.virtual = {}))[key] = out;\n      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n      if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);\n    }\n  }\n};\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library` \nmodule.exports = $export;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_export.js\n// module id = 8\n// module chunks = 0 1","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();\nif(typeof __g == 'number')__g = global; // eslint-disable-line no-undef\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_global.js\n// module id = 9\n// module chunks = 0 1","var core = module.exports = {version: '2.4.0'};\nif(typeof __e == 'number')__e = core; // eslint-disable-line no-undef\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_core.js\n// module id = 10\n// module chunks = 0 1","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function(fn, that, length){\n  aFunction(fn);\n  if(that === undefined)return fn;\n  switch(length){\n    case 1: return function(a){\n      return fn.call(that, a);\n    };\n    case 2: return function(a, b){\n      return fn.call(that, a, b);\n    };\n    case 3: return function(a, b, c){\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function(/* ...args */){\n    return fn.apply(that, arguments);\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_ctx.js\n// module id = 11\n// module chunks = 0 1","module.exports = function(it){\n  if(typeof it != 'function')throw TypeError(it + ' is not a function!');\n  return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_a-function.js\n// module id = 12\n// module chunks = 0 1","var dP         = require('./_object-dp')\n  , createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function(object, key, value){\n  return dP.f(object, key, createDesc(1, value));\n} : function(object, key, value){\n  object[key] = value;\n  return object;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_hide.js\n// module id = 13\n// module chunks = 0 1","var anObject       = require('./_an-object')\n  , IE8_DOM_DEFINE = require('./_ie8-dom-define')\n  , toPrimitive    = require('./_to-primitive')\n  , dP             = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes){\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if(IE8_DOM_DEFINE)try {\n    return dP(O, P, Attributes);\n  } catch(e){ /* empty */ }\n  if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');\n  if('value' in Attributes)O[P] = Attributes.value;\n  return O;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_object-dp.js\n// module id = 14\n// module chunks = 0 1","var isObject = require('./_is-object');\nmodule.exports = function(it){\n  if(!isObject(it))throw TypeError(it + ' is not an object!');\n  return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_an-object.js\n// module id = 15\n// module chunks = 0 1","module.exports = function(it){\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_is-object.js\n// module id = 16\n// module chunks = 0 1","module.exports = !require('./_descriptors') && !require('./_fails')(function(){\n  return Object.defineProperty(require('./_dom-create')('div'), 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_ie8-dom-define.js\n// module id = 17\n// module chunks = 0 1","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function(){\n  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_descriptors.js\n// module id = 18\n// module chunks = 0 1","module.exports = function(exec){\n  try {\n    return !!exec();\n  } catch(e){\n    return true;\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_fails.js\n// module id = 19\n// module chunks = 0 1","var isObject = require('./_is-object')\n  , document = require('./_global').document\n  // in old IE typeof document.createElement is 'object'\n  , is = isObject(document) && isObject(document.createElement);\nmodule.exports = function(it){\n  return is ? document.createElement(it) : {};\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_dom-create.js\n// module id = 20\n// module chunks = 0 1","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function(it, S){\n  if(!isObject(it))return it;\n  var fn, val;\n  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;\n  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_to-primitive.js\n// module id = 21\n// module chunks = 0 1","module.exports = function(bitmap, value){\n  return {\n    enumerable  : !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable    : !(bitmap & 4),\n    value       : value\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_property-desc.js\n// module id = 22\n// module chunks = 0 1","\"use strict\";\n\nexports.__esModule = true;\n\nvar _typeof2 = require(\"../helpers/typeof\");\n\nvar _typeof3 = _interopRequireDefault(_typeof2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && ((typeof call === \"undefined\" ? \"undefined\" : (0, _typeof3.default)(call)) === \"object\" || typeof call === \"function\") ? call : self;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/possibleConstructorReturn.js\n// module id = 23\n// module chunks = 0 1","\"use strict\";\n\nexports.__esModule = true;\n\nvar _iterator = require(\"../core-js/symbol/iterator\");\n\nvar _iterator2 = _interopRequireDefault(_iterator);\n\nvar _symbol = require(\"../core-js/symbol\");\n\nvar _symbol2 = _interopRequireDefault(_symbol);\n\nvar _typeof = typeof _symbol2.default === \"function\" && typeof _iterator2.default === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof _symbol2.default === \"function\" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? \"symbol\" : typeof obj; };\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = typeof _symbol2.default === \"function\" && _typeof(_iterator2.default) === \"symbol\" ? function (obj) {\n  return typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj);\n} : function (obj) {\n  return obj && typeof _symbol2.default === \"function\" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? \"symbol\" : typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/typeof.js\n// module id = 24\n// module chunks = 0 1","module.exports = { \"default\": require(\"core-js/library/fn/symbol/iterator\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/symbol/iterator.js\n// module id = 25\n// module chunks = 0 1","require('../../modules/es6.string.iterator');\nrequire('../../modules/web.dom.iterable');\nmodule.exports = require('../../modules/_wks-ext').f('iterator');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/fn/symbol/iterator.js\n// module id = 26\n// module chunks = 0 1","'use strict';\nvar $at  = require('./_string-at')(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\nrequire('./_iter-define')(String, 'String', function(iterated){\n  this._t = String(iterated); // target\n  this._i = 0;                // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function(){\n  var O     = this._t\n    , index = this._i\n    , point;\n  if(index >= O.length)return {value: undefined, done: true};\n  point = $at(O, index);\n  this._i += point.length;\n  return {value: point, done: false};\n});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/es6.string.iterator.js\n// module id = 27\n// module chunks = 0 1","var toInteger = require('./_to-integer')\n  , defined   = require('./_defined');\n// true  -> String#at\n// false -> String#codePointAt\nmodule.exports = function(TO_STRING){\n  return function(that, pos){\n    var s = String(defined(that))\n      , i = toInteger(pos)\n      , l = s.length\n      , a, b;\n    if(i < 0 || i >= l)return TO_STRING ? '' : undefined;\n    a = s.charCodeAt(i);\n    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n      ? TO_STRING ? s.charAt(i) : a\n      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_string-at.js\n// module id = 28\n// module chunks = 0 1","// 7.1.4 ToInteger\nvar ceil  = Math.ceil\n  , floor = Math.floor;\nmodule.exports = function(it){\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_to-integer.js\n// module id = 29\n// module chunks = 0 1","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function(it){\n  if(it == undefined)throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_defined.js\n// module id = 30\n// module chunks = 0 1","'use strict';\nvar LIBRARY        = require('./_library')\n  , $export        = require('./_export')\n  , redefine       = require('./_redefine')\n  , hide           = require('./_hide')\n  , has            = require('./_has')\n  , Iterators      = require('./_iterators')\n  , $iterCreate    = require('./_iter-create')\n  , setToStringTag = require('./_set-to-string-tag')\n  , getPrototypeOf = require('./_object-gpo')\n  , ITERATOR       = require('./_wks')('iterator')\n  , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`\n  , FF_ITERATOR    = '@@iterator'\n  , KEYS           = 'keys'\n  , VALUES         = 'values';\n\nvar returnThis = function(){ return this; };\n\nmodule.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){\n  $iterCreate(Constructor, NAME, next);\n  var getMethod = function(kind){\n    if(!BUGGY && kind in proto)return proto[kind];\n    switch(kind){\n      case KEYS: return function keys(){ return new Constructor(this, kind); };\n      case VALUES: return function values(){ return new Constructor(this, kind); };\n    } return function entries(){ return new Constructor(this, kind); };\n  };\n  var TAG        = NAME + ' Iterator'\n    , DEF_VALUES = DEFAULT == VALUES\n    , VALUES_BUG = false\n    , proto      = Base.prototype\n    , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]\n    , $default   = $native || getMethod(DEFAULT)\n    , $entries   = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined\n    , $anyNative = NAME == 'Array' ? proto.entries || $native : $native\n    , methods, key, IteratorPrototype;\n  // Fix native\n  if($anyNative){\n    IteratorPrototype = getPrototypeOf($anyNative.call(new Base));\n    if(IteratorPrototype !== Object.prototype){\n      // Set @@toStringTag to native iterators\n      setToStringTag(IteratorPrototype, TAG, true);\n      // fix for some old engines\n      if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);\n    }\n  }\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if(DEF_VALUES && $native && $native.name !== VALUES){\n    VALUES_BUG = true;\n    $default = function values(){ return $native.call(this); };\n  }\n  // Define iterator\n  if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){\n    hide(proto, ITERATOR, $default);\n  }\n  // Plug for library\n  Iterators[NAME] = $default;\n  Iterators[TAG]  = returnThis;\n  if(DEFAULT){\n    methods = {\n      values:  DEF_VALUES ? $default : getMethod(VALUES),\n      keys:    IS_SET     ? $default : getMethod(KEYS),\n      entries: $entries\n    };\n    if(FORCED)for(key in methods){\n      if(!(key in proto))redefine(proto, key, methods[key]);\n    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n  }\n  return methods;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_iter-define.js\n// module id = 31\n// module chunks = 0 1","module.exports = true;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_library.js\n// module id = 32\n// module chunks = 0 1","module.exports = require('./_hide');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_redefine.js\n// module id = 33\n// module chunks = 0 1","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function(it, key){\n  return hasOwnProperty.call(it, key);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_has.js\n// module id = 34\n// module chunks = 0 1","module.exports = {};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_iterators.js\n// module id = 35\n// module chunks = 0 1","'use strict';\nvar create         = require('./_object-create')\n  , descriptor     = require('./_property-desc')\n  , setToStringTag = require('./_set-to-string-tag')\n  , IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nrequire('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function(){ return this; });\n\nmodule.exports = function(Constructor, NAME, next){\n  Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});\n  setToStringTag(Constructor, NAME + ' Iterator');\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_iter-create.js\n// module id = 36\n// module chunks = 0 1","// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject    = require('./_an-object')\n  , dPs         = require('./_object-dps')\n  , enumBugKeys = require('./_enum-bug-keys')\n  , IE_PROTO    = require('./_shared-key')('IE_PROTO')\n  , Empty       = function(){ /* empty */ }\n  , PROTOTYPE   = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function(){\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = require('./_dom-create')('iframe')\n    , i      = enumBugKeys.length\n    , lt     = '<'\n    , gt     = '>'\n    , iframeDocument;\n  iframe.style.display = 'none';\n  require('./_html').appendChild(iframe);\n  iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n  // createDict = iframe.contentWindow.Object;\n  // html.removeChild(iframe);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n  iframeDocument.close();\n  createDict = iframeDocument.F;\n  while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];\n  return createDict();\n};\n\nmodule.exports = Object.create || function create(O, Properties){\n  var result;\n  if(O !== null){\n    Empty[PROTOTYPE] = anObject(O);\n    result = new Empty;\n    Empty[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = createDict();\n  return Properties === undefined ? result : dPs(result, Properties);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_object-create.js\n// module id = 37\n// module chunks = 0 1","var dP       = require('./_object-dp')\n  , anObject = require('./_an-object')\n  , getKeys  = require('./_object-keys');\n\nmodule.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties){\n  anObject(O);\n  var keys   = getKeys(Properties)\n    , length = keys.length\n    , i = 0\n    , P;\n  while(length > i)dP.f(O, P = keys[i++], Properties[P]);\n  return O;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_object-dps.js\n// module id = 38\n// module chunks = 0 1","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys       = require('./_object-keys-internal')\n  , enumBugKeys = require('./_enum-bug-keys');\n\nmodule.exports = Object.keys || function keys(O){\n  return $keys(O, enumBugKeys);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_object-keys.js\n// module id = 39\n// module chunks = 0 1","var has          = require('./_has')\n  , toIObject    = require('./_to-iobject')\n  , arrayIndexOf = require('./_array-includes')(false)\n  , IE_PROTO     = require('./_shared-key')('IE_PROTO');\n\nmodule.exports = function(object, names){\n  var O      = toIObject(object)\n    , i      = 0\n    , result = []\n    , key;\n  for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while(names.length > i)if(has(O, key = names[i++])){\n    ~arrayIndexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_object-keys-internal.js\n// module id = 40\n// module chunks = 0 1","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject')\n  , defined = require('./_defined');\nmodule.exports = function(it){\n  return IObject(defined(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_to-iobject.js\n// module id = 41\n// module chunks = 0 1","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_iobject.js\n// module id = 42\n// module chunks = 0 1","var toString = {}.toString;\n\nmodule.exports = function(it){\n  return toString.call(it).slice(8, -1);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_cof.js\n// module id = 43\n// module chunks = 0 1","// false -> Array#indexOf\n// true  -> Array#includes\nvar toIObject = require('./_to-iobject')\n  , toLength  = require('./_to-length')\n  , toIndex   = require('./_to-index');\nmodule.exports = function(IS_INCLUDES){\n  return function($this, el, fromIndex){\n    var O      = toIObject($this)\n      , length = toLength(O.length)\n      , index  = toIndex(fromIndex, length)\n      , value;\n    // Array#includes uses SameValueZero equality algorithm\n    if(IS_INCLUDES && el != el)while(length > index){\n      value = O[index++];\n      if(value != value)return true;\n    // Array#toIndex ignores holes, Array#includes - not\n    } else for(;length > index; index++)if(IS_INCLUDES || index in O){\n      if(O[index] === el)return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_array-includes.js\n// module id = 44\n// module chunks = 0 1","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer')\n  , min       = Math.min;\nmodule.exports = function(it){\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_to-length.js\n// module id = 45\n// module chunks = 0 1","var toInteger = require('./_to-integer')\n  , max       = Math.max\n  , min       = Math.min;\nmodule.exports = function(index, length){\n  index = toInteger(index);\n  return index < 0 ? max(index + length, 0) : min(index, length);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_to-index.js\n// module id = 46\n// module chunks = 0 1","var shared = require('./_shared')('keys')\n  , uid    = require('./_uid');\nmodule.exports = function(key){\n  return shared[key] || (shared[key] = uid(key));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_shared-key.js\n// module id = 47\n// module chunks = 0 1","var global = require('./_global')\n  , SHARED = '__core-js_shared__'\n  , store  = global[SHARED] || (global[SHARED] = {});\nmodule.exports = function(key){\n  return store[key] || (store[key] = {});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_shared.js\n// module id = 48\n// module chunks = 0 1","var id = 0\n  , px = Math.random();\nmodule.exports = function(key){\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_uid.js\n// module id = 49\n// module chunks = 0 1","// IE 8- don't enum bug keys\nmodule.exports = (\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_enum-bug-keys.js\n// module id = 50\n// module chunks = 0 1","module.exports = require('./_global').document && document.documentElement;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_html.js\n// module id = 51\n// module chunks = 0 1","var def = require('./_object-dp').f\n  , has = require('./_has')\n  , TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function(it, tag, stat){\n  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_set-to-string-tag.js\n// module id = 52\n// module chunks = 0 1","var store      = require('./_shared')('wks')\n  , uid        = require('./_uid')\n  , Symbol     = require('./_global').Symbol\n  , USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function(name){\n  return store[name] || (store[name] =\n    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_wks.js\n// module id = 53\n// module chunks = 0 1","// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has         = require('./_has')\n  , toObject    = require('./_to-object')\n  , IE_PROTO    = require('./_shared-key')('IE_PROTO')\n  , ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function(O){\n  O = toObject(O);\n  if(has(O, IE_PROTO))return O[IE_PROTO];\n  if(typeof O.constructor == 'function' && O instanceof O.constructor){\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectProto : null;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_object-gpo.js\n// module id = 54\n// module chunks = 0 1","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function(it){\n  return Object(defined(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_to-object.js\n// module id = 55\n// module chunks = 0 1","require('./es6.array.iterator');\nvar global        = require('./_global')\n  , hide          = require('./_hide')\n  , Iterators     = require('./_iterators')\n  , TO_STRING_TAG = require('./_wks')('toStringTag');\n\nfor(var collections = ['NodeList', 'DOMTokenList', 'MediaList', 'StyleSheetList', 'CSSRuleList'], i = 0; i < 5; i++){\n  var NAME       = collections[i]\n    , Collection = global[NAME]\n    , proto      = Collection && Collection.prototype;\n  if(proto && !proto[TO_STRING_TAG])hide(proto, TO_STRING_TAG, NAME);\n  Iterators[NAME] = Iterators.Array;\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/web.dom.iterable.js\n// module id = 56\n// module chunks = 0 1","'use strict';\nvar addToUnscopables = require('./_add-to-unscopables')\n  , step             = require('./_iter-step')\n  , Iterators        = require('./_iterators')\n  , toIObject        = require('./_to-iobject');\n\n// 22.1.3.4 Array.prototype.entries()\n// 22.1.3.13 Array.prototype.keys()\n// 22.1.3.29 Array.prototype.values()\n// 22.1.3.30 Array.prototype[@@iterator]()\nmodule.exports = require('./_iter-define')(Array, 'Array', function(iterated, kind){\n  this._t = toIObject(iterated); // target\n  this._i = 0;                   // next index\n  this._k = kind;                // kind\n// 22.1.5.2.1 %ArrayIteratorPrototype%.next()\n}, function(){\n  var O     = this._t\n    , kind  = this._k\n    , index = this._i++;\n  if(!O || index >= O.length){\n    this._t = undefined;\n    return step(1);\n  }\n  if(kind == 'keys'  )return step(0, index);\n  if(kind == 'values')return step(0, O[index]);\n  return step(0, [index, O[index]]);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)\nIterators.Arguments = Iterators.Array;\n\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/es6.array.iterator.js\n// module id = 57\n// module chunks = 0 1","module.exports = function(){ /* empty */ };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_add-to-unscopables.js\n// module id = 58\n// module chunks = 0 1","module.exports = function(done, value){\n  return {value: value, done: !!done};\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_iter-step.js\n// module id = 59\n// module chunks = 0 1","exports.f = require('./_wks');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_wks-ext.js\n// module id = 60\n// module chunks = 0 1","module.exports = { \"default\": require(\"core-js/library/fn/symbol\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/symbol.js\n// module id = 61\n// module chunks = 0 1","require('../../modules/es6.symbol');\nrequire('../../modules/es6.object.to-string');\nrequire('../../modules/es7.symbol.async-iterator');\nrequire('../../modules/es7.symbol.observable');\nmodule.exports = require('../../modules/_core').Symbol;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/fn/symbol/index.js\n// module id = 62\n// module chunks = 0 1","'use strict';\n// ECMAScript 6 symbols shim\nvar global         = require('./_global')\n  , has            = require('./_has')\n  , DESCRIPTORS    = require('./_descriptors')\n  , $export        = require('./_export')\n  , redefine       = require('./_redefine')\n  , META           = require('./_meta').KEY\n  , $fails         = require('./_fails')\n  , shared         = require('./_shared')\n  , setToStringTag = require('./_set-to-string-tag')\n  , uid            = require('./_uid')\n  , wks            = require('./_wks')\n  , wksExt         = require('./_wks-ext')\n  , wksDefine      = require('./_wks-define')\n  , keyOf          = require('./_keyof')\n  , enumKeys       = require('./_enum-keys')\n  , isArray        = require('./_is-array')\n  , anObject       = require('./_an-object')\n  , toIObject      = require('./_to-iobject')\n  , toPrimitive    = require('./_to-primitive')\n  , createDesc     = require('./_property-desc')\n  , _create        = require('./_object-create')\n  , gOPNExt        = require('./_object-gopn-ext')\n  , $GOPD          = require('./_object-gopd')\n  , $DP            = require('./_object-dp')\n  , $keys          = require('./_object-keys')\n  , gOPD           = $GOPD.f\n  , dP             = $DP.f\n  , gOPN           = gOPNExt.f\n  , $Symbol        = global.Symbol\n  , $JSON          = global.JSON\n  , _stringify     = $JSON && $JSON.stringify\n  , PROTOTYPE      = 'prototype'\n  , HIDDEN         = wks('_hidden')\n  , TO_PRIMITIVE   = wks('toPrimitive')\n  , isEnum         = {}.propertyIsEnumerable\n  , SymbolRegistry = shared('symbol-registry')\n  , AllSymbols     = shared('symbols')\n  , OPSymbols      = shared('op-symbols')\n  , ObjectProto    = Object[PROTOTYPE]\n  , USE_NATIVE     = typeof $Symbol == 'function'\n  , QObject        = global.QObject;\n// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173\nvar setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;\n\n// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687\nvar setSymbolDesc = DESCRIPTORS && $fails(function(){\n  return _create(dP({}, 'a', {\n    get: function(){ return dP(this, 'a', {value: 7}).a; }\n  })).a != 7;\n}) ? function(it, key, D){\n  var protoDesc = gOPD(ObjectProto, key);\n  if(protoDesc)delete ObjectProto[key];\n  dP(it, key, D);\n  if(protoDesc && it !== ObjectProto)dP(ObjectProto, key, protoDesc);\n} : dP;\n\nvar wrap = function(tag){\n  var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);\n  sym._k = tag;\n  return sym;\n};\n\nvar isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function(it){\n  return typeof it == 'symbol';\n} : function(it){\n  return it instanceof $Symbol;\n};\n\nvar $defineProperty = function defineProperty(it, key, D){\n  if(it === ObjectProto)$defineProperty(OPSymbols, key, D);\n  anObject(it);\n  key = toPrimitive(key, true);\n  anObject(D);\n  if(has(AllSymbols, key)){\n    if(!D.enumerable){\n      if(!has(it, HIDDEN))dP(it, HIDDEN, createDesc(1, {}));\n      it[HIDDEN][key] = true;\n    } else {\n      if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;\n      D = _create(D, {enumerable: createDesc(0, false)});\n    } return setSymbolDesc(it, key, D);\n  } return dP(it, key, D);\n};\nvar $defineProperties = function defineProperties(it, P){\n  anObject(it);\n  var keys = enumKeys(P = toIObject(P))\n    , i    = 0\n    , l = keys.length\n    , key;\n  while(l > i)$defineProperty(it, key = keys[i++], P[key]);\n  return it;\n};\nvar $create = function create(it, P){\n  return P === undefined ? _create(it) : $defineProperties(_create(it), P);\n};\nvar $propertyIsEnumerable = function propertyIsEnumerable(key){\n  var E = isEnum.call(this, key = toPrimitive(key, true));\n  if(this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return false;\n  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;\n};\nvar $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){\n  it  = toIObject(it);\n  key = toPrimitive(key, true);\n  if(it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return;\n  var D = gOPD(it, key);\n  if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;\n  return D;\n};\nvar $getOwnPropertyNames = function getOwnPropertyNames(it){\n  var names  = gOPN(toIObject(it))\n    , result = []\n    , i      = 0\n    , key;\n  while(names.length > i){\n    if(!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META)result.push(key);\n  } return result;\n};\nvar $getOwnPropertySymbols = function getOwnPropertySymbols(it){\n  var IS_OP  = it === ObjectProto\n    , names  = gOPN(IS_OP ? OPSymbols : toIObject(it))\n    , result = []\n    , i      = 0\n    , key;\n  while(names.length > i){\n    if(has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true))result.push(AllSymbols[key]);\n  } return result;\n};\n\n// 19.4.1.1 Symbol([description])\nif(!USE_NATIVE){\n  $Symbol = function Symbol(){\n    if(this instanceof $Symbol)throw TypeError('Symbol is not a constructor!');\n    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);\n    var $set = function(value){\n      if(this === ObjectProto)$set.call(OPSymbols, value);\n      if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;\n      setSymbolDesc(this, tag, createDesc(1, value));\n    };\n    if(DESCRIPTORS && setter)setSymbolDesc(ObjectProto, tag, {configurable: true, set: $set});\n    return wrap(tag);\n  };\n  redefine($Symbol[PROTOTYPE], 'toString', function toString(){\n    return this._k;\n  });\n\n  $GOPD.f = $getOwnPropertyDescriptor;\n  $DP.f   = $defineProperty;\n  require('./_object-gopn').f = gOPNExt.f = $getOwnPropertyNames;\n  require('./_object-pie').f  = $propertyIsEnumerable;\n  require('./_object-gops').f = $getOwnPropertySymbols;\n\n  if(DESCRIPTORS && !require('./_library')){\n    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);\n  }\n\n  wksExt.f = function(name){\n    return wrap(wks(name));\n  }\n}\n\n$export($export.G + $export.W + $export.F * !USE_NATIVE, {Symbol: $Symbol});\n\nfor(var symbols = (\n  // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14\n  'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'\n).split(','), i = 0; symbols.length > i; )wks(symbols[i++]);\n\nfor(var symbols = $keys(wks.store), i = 0; symbols.length > i; )wksDefine(symbols[i++]);\n\n$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {\n  // 19.4.2.1 Symbol.for(key)\n  'for': function(key){\n    return has(SymbolRegistry, key += '')\n      ? SymbolRegistry[key]\n      : SymbolRegistry[key] = $Symbol(key);\n  },\n  // 19.4.2.5 Symbol.keyFor(sym)\n  keyFor: function keyFor(key){\n    if(isSymbol(key))return keyOf(SymbolRegistry, key);\n    throw TypeError(key + ' is not a symbol!');\n  },\n  useSetter: function(){ setter = true; },\n  useSimple: function(){ setter = false; }\n});\n\n$export($export.S + $export.F * !USE_NATIVE, 'Object', {\n  // 19.1.2.2 Object.create(O [, Properties])\n  create: $create,\n  // 19.1.2.4 Object.defineProperty(O, P, Attributes)\n  defineProperty: $defineProperty,\n  // 19.1.2.3 Object.defineProperties(O, Properties)\n  defineProperties: $defineProperties,\n  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\n  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,\n  // 19.1.2.7 Object.getOwnPropertyNames(O)\n  getOwnPropertyNames: $getOwnPropertyNames,\n  // 19.1.2.8 Object.getOwnPropertySymbols(O)\n  getOwnPropertySymbols: $getOwnPropertySymbols\n});\n\n// 24.3.2 JSON.stringify(value [, replacer [, space]])\n$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function(){\n  var S = $Symbol();\n  // MS Edge converts symbol values to JSON as {}\n  // WebKit converts symbol values to JSON as null\n  // V8 throws on boxed symbols\n  return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';\n})), 'JSON', {\n  stringify: function stringify(it){\n    if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined\n    var args = [it]\n      , i    = 1\n      , replacer, $replacer;\n    while(arguments.length > i)args.push(arguments[i++]);\n    replacer = args[1];\n    if(typeof replacer == 'function')$replacer = replacer;\n    if($replacer || !isArray(replacer))replacer = function(key, value){\n      if($replacer)value = $replacer.call(this, key, value);\n      if(!isSymbol(value))return value;\n    };\n    args[1] = replacer;\n    return _stringify.apply($JSON, args);\n  }\n});\n\n// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)\n$Symbol[PROTOTYPE][TO_PRIMITIVE] || require('./_hide')($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);\n// 19.4.3.5 Symbol.prototype[@@toStringTag]\nsetToStringTag($Symbol, 'Symbol');\n// 20.2.1.9 Math[@@toStringTag]\nsetToStringTag(Math, 'Math', true);\n// 24.3.3 JSON[@@toStringTag]\nsetToStringTag(global.JSON, 'JSON', true);\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/es6.symbol.js\n// module id = 63\n// module chunks = 0 1","var META     = require('./_uid')('meta')\n  , isObject = require('./_is-object')\n  , has      = require('./_has')\n  , setDesc  = require('./_object-dp').f\n  , id       = 0;\nvar isExtensible = Object.isExtensible || function(){\n  return true;\n};\nvar FREEZE = !require('./_fails')(function(){\n  return isExtensible(Object.preventExtensions({}));\n});\nvar setMeta = function(it){\n  setDesc(it, META, {value: {\n    i: 'O' + ++id, // object ID\n    w: {}          // weak collections IDs\n  }});\n};\nvar fastKey = function(it, create){\n  // return primitive with prefix\n  if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if(!has(it, META)){\n    // can't set metadata to uncaught frozen object\n    if(!isExtensible(it))return 'F';\n    // not necessary to add metadata\n    if(!create)return 'E';\n    // add missing metadata\n    setMeta(it);\n  // return object ID\n  } return it[META].i;\n};\nvar getWeak = function(it, create){\n  if(!has(it, META)){\n    // can't set metadata to uncaught frozen object\n    if(!isExtensible(it))return true;\n    // not necessary to add metadata\n    if(!create)return false;\n    // add missing metadata\n    setMeta(it);\n  // return hash weak collections IDs\n  } return it[META].w;\n};\n// add metadata on freeze-family methods calling\nvar onFreeze = function(it){\n  if(FREEZE && meta.NEED && isExtensible(it) && !has(it, META))setMeta(it);\n  return it;\n};\nvar meta = module.exports = {\n  KEY:      META,\n  NEED:     false,\n  fastKey:  fastKey,\n  getWeak:  getWeak,\n  onFreeze: onFreeze\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_meta.js\n// module id = 64\n// module chunks = 0 1","var global         = require('./_global')\n  , core           = require('./_core')\n  , LIBRARY        = require('./_library')\n  , wksExt         = require('./_wks-ext')\n  , defineProperty = require('./_object-dp').f;\nmodule.exports = function(name){\n  var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});\n  if(name.charAt(0) != '_' && !(name in $Symbol))defineProperty($Symbol, name, {value: wksExt.f(name)});\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_wks-define.js\n// module id = 65\n// module chunks = 0 1","var getKeys   = require('./_object-keys')\n  , toIObject = require('./_to-iobject');\nmodule.exports = function(object, el){\n  var O      = toIObject(object)\n    , keys   = getKeys(O)\n    , length = keys.length\n    , index  = 0\n    , key;\n  while(length > index)if(O[key = keys[index++]] === el)return key;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_keyof.js\n// module id = 66\n// module chunks = 0 1","// all enumerable object keys, includes symbols\nvar getKeys = require('./_object-keys')\n  , gOPS    = require('./_object-gops')\n  , pIE     = require('./_object-pie');\nmodule.exports = function(it){\n  var result     = getKeys(it)\n    , getSymbols = gOPS.f;\n  if(getSymbols){\n    var symbols = getSymbols(it)\n      , isEnum  = pIE.f\n      , i       = 0\n      , key;\n    while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))result.push(key);\n  } return result;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_enum-keys.js\n// module id = 67\n// module chunks = 0 1","exports.f = Object.getOwnPropertySymbols;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_object-gops.js\n// module id = 68\n// module chunks = 0 1","exports.f = {}.propertyIsEnumerable;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_object-pie.js\n// module id = 69\n// module chunks = 0 1","// 7.2.2 IsArray(argument)\nvar cof = require('./_cof');\nmodule.exports = Array.isArray || function isArray(arg){\n  return cof(arg) == 'Array';\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_is-array.js\n// module id = 70\n// module chunks = 0 1","// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nvar toIObject = require('./_to-iobject')\n  , gOPN      = require('./_object-gopn').f\n  , toString  = {}.toString;\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n  ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function(it){\n  try {\n    return gOPN(it);\n  } catch(e){\n    return windowNames.slice();\n  }\n};\n\nmodule.exports.f = function getOwnPropertyNames(it){\n  return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_object-gopn-ext.js\n// module id = 71\n// module chunks = 0 1","// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)\nvar $keys      = require('./_object-keys-internal')\n  , hiddenKeys = require('./_enum-bug-keys').concat('length', 'prototype');\n\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O){\n  return $keys(O, hiddenKeys);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_object-gopn.js\n// module id = 72\n// module chunks = 0 1","var pIE            = require('./_object-pie')\n  , createDesc     = require('./_property-desc')\n  , toIObject      = require('./_to-iobject')\n  , toPrimitive    = require('./_to-primitive')\n  , has            = require('./_has')\n  , IE8_DOM_DEFINE = require('./_ie8-dom-define')\n  , gOPD           = Object.getOwnPropertyDescriptor;\n\nexports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P){\n  O = toIObject(O);\n  P = toPrimitive(P, true);\n  if(IE8_DOM_DEFINE)try {\n    return gOPD(O, P);\n  } catch(e){ /* empty */ }\n  if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_object-gopd.js\n// module id = 73\n// module chunks = 0 1","require('./_wks-define')('asyncIterator');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/es7.symbol.async-iterator.js\n// module id = 75\n// module chunks = 0 1","require('./_wks-define')('observable');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/es7.symbol.observable.js\n// module id = 76\n// module chunks = 0 1","\"use strict\";\n\nexports.__esModule = true;\n\nvar _setPrototypeOf = require(\"../core-js/object/set-prototype-of\");\n\nvar _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf);\n\nvar _create = require(\"../core-js/object/create\");\n\nvar _create2 = _interopRequireDefault(_create);\n\nvar _typeof2 = require(\"../helpers/typeof\");\n\nvar _typeof3 = _interopRequireDefault(_typeof2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + (typeof superClass === \"undefined\" ? \"undefined\" : (0, _typeof3.default)(superClass)));\n  }\n\n  subClass.prototype = (0, _create2.default)(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) _setPrototypeOf2.default ? (0, _setPrototypeOf2.default)(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/inherits.js\n// module id = 77\n// module chunks = 0 1","module.exports = { \"default\": require(\"core-js/library/fn/object/set-prototype-of\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/set-prototype-of.js\n// module id = 78\n// module chunks = 0 1","require('../../modules/es6.object.set-prototype-of');\nmodule.exports = require('../../modules/_core').Object.setPrototypeOf;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/fn/object/set-prototype-of.js\n// module id = 79\n// module chunks = 0 1","// 19.1.3.19 Object.setPrototypeOf(O, proto)\nvar $export = require('./_export');\n$export($export.S, 'Object', {setPrototypeOf: require('./_set-proto').set});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/es6.object.set-prototype-of.js\n// module id = 80\n// module chunks = 0 1","// Works with __proto__ only. Old v8 can't work with null proto objects.\n/* eslint-disable no-proto */\nvar isObject = require('./_is-object')\n  , anObject = require('./_an-object');\nvar check = function(O, proto){\n  anObject(O);\n  if(!isObject(proto) && proto !== null)throw TypeError(proto + \": can't set as prototype!\");\n};\nmodule.exports = {\n  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line\n    function(test, buggy, set){\n      try {\n        set = require('./_ctx')(Function.call, require('./_object-gopd').f(Object.prototype, '__proto__').set, 2);\n        set(test, []);\n        buggy = !(test instanceof Array);\n      } catch(e){ buggy = true; }\n      return function setPrototypeOf(O, proto){\n        check(O, proto);\n        if(buggy)O.__proto__ = proto;\n        else set(O, proto);\n        return O;\n      };\n    }({}, false) : undefined),\n  check: check\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_set-proto.js\n// module id = 81\n// module chunks = 0 1","module.exports = { \"default\": require(\"core-js/library/fn/object/create\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/create.js\n// module id = 82\n// module chunks = 0 1","require('../../modules/es6.object.create');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function create(P, D){\n  return $Object.create(P, D);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/fn/object/create.js\n// module id = 83\n// module chunks = 0 1","var $export = require('./_export')\n// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\n$export($export.S, 'Object', {create: require('./_object-create')});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/es6.object.create.js\n// module id = 84\n// module chunks = 0 1","/**\n * A Render Result\n */\nexport default class RenderResult {\n  /**\n   * @param {int} startOffset\n   * @param {int} endOffset\n   * @param {String} startContainerPath\n   * @param {String} endContainerPath\n   */\n  constructor(startOffset, endOffset, startContainerPath, endContainerPath) {\n    this.startOffset = startOffset;\n    this.endOffset = endOffset;\n    this.startContainerPath = startContainerPath;\n    this.endContainerPath = endContainerPath;\n    this._renderingInstance = null;\n  }\n\n  /**\n   * @param {Object} result\n   * @return RenderResult\n   */\n  static fromObject(result) {\n    return new RenderResult(\n      result.startOffset,\n      result.endOffset,\n      result.startContainerPath,\n      result.endContainerPath\n    );\n  }\n\n  /**\n   * @returns {Object}\n   */\n  serialize() {\n    return {\n      startOffset: this.startOffset,\n      endOffset: this.endOffset,\n      startContainerPath: this.startContainerPath,\n      endContainerPath: this.endContainerPath\n    };\n  }\n\n  /**\n   * @param {String} text\n   */\n  set text(text) {\n    this._text = text;\n  }\n\n  /**\n   * @returns {String}\n   */\n  get text() {\n    return this._text;\n  }\n\n  /**\n   * @returns {null|Rendering}\n   */\n  get instance() {\n    return this._renderingInstance;\n  }\n\n  /**\n   * @param {null|Rendering} instance\n   */\n  set instance(instance) {\n    this._renderingInstance = instance;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/RenderResult.js","/* global Set */\n\nimport EventEmitter from 'wolfy87-eventemitter';\nimport Rendering from './Rendering';\nimport Util from './util/Util';\n\n/**\n * @type {string}\n */\nexport const EVENT_CLICK = 'click';\n\n/**\n * @type {string}\n */\nexport const EVENT_MOUSEENTER = 'hover-enter';\n\n/**\n * @type {string}\n */\nexport const EVENT_MOUSELEAVE = 'hover-leave';\n\n/**\n * @type {string}\n */\nexport const EVENT_PART_TREE_ENTER = 'tree-enter';\n\n/**\n * @type {string}\n */\nexport const EVENT_PART_TREE_LEAVE = 'tree-leave';\n\n/**\n * Generic Event Handlings for Renderer\n */\nexport default class RenderingEvents extends EventEmitter {\n\n  static staticEventListener = new EventEmitter();\n\n  /**\n   * @param {Object} options\n   * @param {Document} document\n   */\n  constructor(options, document) {\n    super();\n\n    /**\n     * Options\n     * @type {Object}\n     */\n    this.options = {\n      hoverClass: 'marklib--hover',\n      treeClass: 'marklib--tree',\n      className: ['marking']\n    };\n\n    this.options = Object.assign(this.options, options || {});\n\n    if (typeof this.options.className === 'string') {\n      this.options.className = this.options.className.split(' ');\n    }\n\n    /**\n     * A collection of all nodes that are part of all events\n     * @type {Array}\n     */\n    this.wrapperNodes = [];\n\n    /**\n     * @type {Document}\n     */\n    this.document = document;\n  }\n\n  /**\n   * Constructs a new Range from rendered result\n   * @returns {Range}\n   */\n  get range() {\n    const range = this.document.createRange();\n    const textNodes = [];\n\n    this.wrapperNodes.forEach((wrapper) => {\n      Util.walkTextNodes(wrapper, (node) => {\n        textNodes.push(node);\n      });\n    });\n\n    if (textNodes.length > 0) {\n      const lastTextNode = textNodes[textNodes.length - 1];\n      range.setStart(textNodes[0], 0);\n      range.setEnd(lastTextNode, lastTextNode.length);\n      return range;\n    }\n\n    return null;\n  }\n\n  static globalEmitter() {\n    return RenderingEvents.staticEventListener;\n  }\n}\n\nlet HAS_EVENTS = false;\n\nexport const registerEvents = () => {\n  if (HAS_EVENTS) {\n    return;\n  }\n\n  HAS_EVENTS = true;\n\n  const currentHoverInstances = new Set();\n  const betweenInstances = new Set();\n\n  function checkMarklibInstance(e) {\n    const instance = Rendering.getMarklibInstance(e);\n    // instanceof check will fail if used in test scenario where different DOMs are used\n    // see also http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/\n    return instance && (instance instanceof Rendering || 'wrapperNodes' in instance);\n  }\n\n  function closestInstance(e) {\n    const closest = Util.closestCallback(\n      e.target,\n      (thisE) => checkMarklibInstance(thisE)\n    );\n    if (typeof closest === 'object') {\n      return Rendering.getMarklibInstance(closest);\n    }\n    return false;\n  }\n\n  function getInstancesBetween(e, instance) {\n    return Util.parentsCallback(\n      e.target,\n      (el) => checkMarklibInstance(el) && Rendering.getMarklibInstance(el) !== instance\n    ).map(el => Rendering.getMarklibInstance(el));\n  }\n\n  function mouseOutClear() {\n    currentHoverInstances.forEach((thisInstance) => {\n      Rendering.globalEmitter().emit(EVENT_MOUSELEAVE, thisInstance);\n      thisInstance.emit(EVENT_MOUSELEAVE);\n    });\n    currentHoverInstances.clear();\n\n    betweenInstances.forEach((thisInstance) => {\n      Rendering.globalEmitter().emit(EVENT_PART_TREE_LEAVE, thisInstance);\n      thisInstance.emit(EVENT_PART_TREE_LEAVE);\n    });\n\n    betweenInstances.clear();\n  }\n\n  /**\n   * @param {Event} e\n   * @returns {Array|boolean}\n   */\n  function findTarget(e) {\n    let instance = closestInstance(e);\n    if (instance) {\n      const between = getInstancesBetween(e, instance);\n      if (e.target.textContent !== instance.result.text && between.length > 0) {\n        let allInstances = between;\n        allInstances.unshift(instance);\n        // take the smallest selection\n        allInstances = allInstances.sort(\n          (a, b) => (a.result.text.length < b.result.text.length ? -1 : 1)\n        );\n        instance = allInstances[0];\n      }\n      return [instance, between];\n    }\n    return false;\n  }\n\n  RenderingEvents.globalEmitter().on(EVENT_MOUSEENTER, (instance) => {\n    instance.wrapperNodes.forEach((node) => {\n      node.classList.add(instance.options.hoverClass);\n    });\n  });\n\n  RenderingEvents.globalEmitter().on(EVENT_MOUSELEAVE, (instance) => {\n    instance.wrapperNodes.forEach((node) => {\n      node.classList.remove(instance.options.hoverClass);\n    });\n  });\n\n  RenderingEvents.globalEmitter().on(EVENT_PART_TREE_ENTER, (instance) => {\n    instance.wrapperNodes.forEach((node) => {\n      node.classList.add(instance.options.treeClass);\n    });\n  });\n\n  RenderingEvents.globalEmitter().on(EVENT_PART_TREE_LEAVE, (instance) => {\n    instance.wrapperNodes.forEach((node) => {\n      node.classList.remove(instance.options.treeClass);\n    });\n  });\n\n  global.addEventListener('click', (e) => {\n    const target = findTarget(e);\n    if (target) {\n      const [instance, between] = target;\n      Rendering.globalEmitter().emit(EVENT_CLICK, instance, e, between);\n      instance.emit(EVENT_CLICK, e, between);\n    }\n  }, true);\n\n  global.addEventListener('mouseover', (e) => {\n    const target = findTarget(e);\n    if (target) {\n      const [instance, between] = target;\n\n      // find instances that lay in between the node\n      mouseOutClear();\n      between.forEach((instanceBetween) => {\n        betweenInstances.add(instanceBetween);\n        instanceBetween.emit(EVENT_PART_TREE_ENTER, e, between);\n        Rendering.globalEmitter().emit(EVENT_PART_TREE_ENTER, instanceBetween, e, between);\n      });\n      instance.emit(EVENT_MOUSEENTER, e, between);\n      Rendering.globalEmitter().emit(EVENT_MOUSEENTER, instance, e, between);\n      currentHoverInstances.add(instance);\n    } else {\n      mouseOutClear();\n    }\n  }, true);\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/RenderingEvents.js","\"use strict\";\n\nexports.__esModule = true;\n\nvar _isIterable2 = require(\"../core-js/is-iterable\");\n\nvar _isIterable3 = _interopRequireDefault(_isIterable2);\n\nvar _getIterator2 = require(\"../core-js/get-iterator\");\n\nvar _getIterator3 = _interopRequireDefault(_getIterator2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function () {\n  function sliceIterator(arr, i) {\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n    var _e = undefined;\n\n    try {\n      for (var _i = (0, _getIterator3.default)(arr), _s; !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"]) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n\n    return _arr;\n  }\n\n  return function (arr, i) {\n    if (Array.isArray(arr)) {\n      return arr;\n    } else if ((0, _isIterable3.default)(Object(arr))) {\n      return sliceIterator(arr, i);\n    } else {\n      throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n    }\n  };\n}();\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/helpers/slicedToArray.js\n// module id = 87\n// module chunks = 0 1","module.exports = { \"default\": require(\"core-js/library/fn/is-iterable\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/is-iterable.js\n// module id = 88\n// module chunks = 0 1","require('../modules/web.dom.iterable');\nrequire('../modules/es6.string.iterator');\nmodule.exports = require('../modules/core.is-iterable');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/fn/is-iterable.js\n// module id = 89\n// module chunks = 0 1","var classof   = require('./_classof')\n  , ITERATOR  = require('./_wks')('iterator')\n  , Iterators = require('./_iterators');\nmodule.exports = require('./_core').isIterable = function(it){\n  var O = Object(it);\n  return O[ITERATOR] !== undefined\n    || '@@iterator' in O\n    || Iterators.hasOwnProperty(classof(O));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/core.is-iterable.js\n// module id = 90\n// module chunks = 0 1","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof')\n  , TAG = require('./_wks')('toStringTag')\n  // ES3 wrong here\n  , ARG = cof(function(){ return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function(it, key){\n  try {\n    return it[key];\n  } catch(e){ /* empty */ }\n};\n\nmodule.exports = function(it){\n  var O, T, B;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n    // builtinTag case\n    : ARG ? cof(O)\n    // ES3 arguments fallback\n    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_classof.js\n// module id = 91\n// module chunks = 0 1","module.exports = { \"default\": require(\"core-js/library/fn/get-iterator\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/get-iterator.js\n// module id = 92\n// module chunks = 0 1","require('../modules/web.dom.iterable');\nrequire('../modules/es6.string.iterator');\nmodule.exports = require('../modules/core.get-iterator');\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/fn/get-iterator.js\n// module id = 93\n// module chunks = 0 1","var anObject = require('./_an-object')\n  , get      = require('./core.get-iterator-method');\nmodule.exports = require('./_core').getIterator = function(it){\n  var iterFn = get(it);\n  if(typeof iterFn != 'function')throw TypeError(it + ' is not iterable!');\n  return anObject(iterFn.call(it));\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/core.get-iterator.js\n// module id = 94\n// module chunks = 0 1","var classof   = require('./_classof')\n  , ITERATOR  = require('./_wks')('iterator')\n  , Iterators = require('./_iterators');\nmodule.exports = require('./_core').getIteratorMethod = function(it){\n  if(it != undefined)return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/core.get-iterator-method.js\n// module id = 95\n// module chunks = 0 1","module.exports = { \"default\": require(\"core-js/library/fn/set\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/set.js\n// module id = 96\n// module chunks = 0 1","require('../modules/es6.object.to-string');\nrequire('../modules/es6.string.iterator');\nrequire('../modules/web.dom.iterable');\nrequire('../modules/es6.set');\nrequire('../modules/es7.set.to-json');\nmodule.exports = require('../modules/_core').Set;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/fn/set.js\n// module id = 97\n// module chunks = 0 1","'use strict';\nvar strong = require('./_collection-strong');\n\n// 23.2 Set Objects\nmodule.exports = require('./_collection')('Set', function(get){\n  return function Set(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };\n}, {\n  // 23.2.3.1 Set.prototype.add(value)\n  add: function add(value){\n    return strong.def(this, value = value === 0 ? 0 : value, value);\n  }\n}, strong);\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/es6.set.js\n// module id = 98\n// module chunks = 0 1","'use strict';\nvar dP          = require('./_object-dp').f\n  , create      = require('./_object-create')\n  , redefineAll = require('./_redefine-all')\n  , ctx         = require('./_ctx')\n  , anInstance  = require('./_an-instance')\n  , defined     = require('./_defined')\n  , forOf       = require('./_for-of')\n  , $iterDefine = require('./_iter-define')\n  , step        = require('./_iter-step')\n  , setSpecies  = require('./_set-species')\n  , DESCRIPTORS = require('./_descriptors')\n  , fastKey     = require('./_meta').fastKey\n  , SIZE        = DESCRIPTORS ? '_s' : 'size';\n\nvar getEntry = function(that, key){\n  // fast case\n  var index = fastKey(key), entry;\n  if(index !== 'F')return that._i[index];\n  // frozen object case\n  for(entry = that._f; entry; entry = entry.n){\n    if(entry.k == key)return entry;\n  }\n};\n\nmodule.exports = {\n  getConstructor: function(wrapper, NAME, IS_MAP, ADDER){\n    var C = wrapper(function(that, iterable){\n      anInstance(that, C, NAME, '_i');\n      that._i = create(null); // index\n      that._f = undefined;    // first entry\n      that._l = undefined;    // last entry\n      that[SIZE] = 0;         // size\n      if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);\n    });\n    redefineAll(C.prototype, {\n      // 23.1.3.1 Map.prototype.clear()\n      // 23.2.3.2 Set.prototype.clear()\n      clear: function clear(){\n        for(var that = this, data = that._i, entry = that._f; entry; entry = entry.n){\n          entry.r = true;\n          if(entry.p)entry.p = entry.p.n = undefined;\n          delete data[entry.i];\n        }\n        that._f = that._l = undefined;\n        that[SIZE] = 0;\n      },\n      // 23.1.3.3 Map.prototype.delete(key)\n      // 23.2.3.4 Set.prototype.delete(value)\n      'delete': function(key){\n        var that  = this\n          , entry = getEntry(that, key);\n        if(entry){\n          var next = entry.n\n            , prev = entry.p;\n          delete that._i[entry.i];\n          entry.r = true;\n          if(prev)prev.n = next;\n          if(next)next.p = prev;\n          if(that._f == entry)that._f = next;\n          if(that._l == entry)that._l = prev;\n          that[SIZE]--;\n        } return !!entry;\n      },\n      // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)\n      // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)\n      forEach: function forEach(callbackfn /*, that = undefined */){\n        anInstance(this, C, 'forEach');\n        var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3)\n          , entry;\n        while(entry = entry ? entry.n : this._f){\n          f(entry.v, entry.k, this);\n          // revert to the last existing entry\n          while(entry && entry.r)entry = entry.p;\n        }\n      },\n      // 23.1.3.7 Map.prototype.has(key)\n      // 23.2.3.7 Set.prototype.has(value)\n      has: function has(key){\n        return !!getEntry(this, key);\n      }\n    });\n    if(DESCRIPTORS)dP(C.prototype, 'size', {\n      get: function(){\n        return defined(this[SIZE]);\n      }\n    });\n    return C;\n  },\n  def: function(that, key, value){\n    var entry = getEntry(that, key)\n      , prev, index;\n    // change existing entry\n    if(entry){\n      entry.v = value;\n    // create new entry\n    } else {\n      that._l = entry = {\n        i: index = fastKey(key, true), // <- index\n        k: key,                        // <- key\n        v: value,                      // <- value\n        p: prev = that._l,             // <- previous entry\n        n: undefined,                  // <- next entry\n        r: false                       // <- removed\n      };\n      if(!that._f)that._f = entry;\n      if(prev)prev.n = entry;\n      that[SIZE]++;\n      // add to index\n      if(index !== 'F')that._i[index] = entry;\n    } return that;\n  },\n  getEntry: getEntry,\n  setStrong: function(C, NAME, IS_MAP){\n    // add .keys, .values, .entries, [@@iterator]\n    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11\n    $iterDefine(C, NAME, function(iterated, kind){\n      this._t = iterated;  // target\n      this._k = kind;      // kind\n      this._l = undefined; // previous\n    }, function(){\n      var that  = this\n        , kind  = that._k\n        , entry = that._l;\n      // revert to the last existing entry\n      while(entry && entry.r)entry = entry.p;\n      // get next entry\n      if(!that._t || !(that._l = entry = entry ? entry.n : that._t._f)){\n        // or finish the iteration\n        that._t = undefined;\n        return step(1);\n      }\n      // return step by kind\n      if(kind == 'keys'  )return step(0, entry.k);\n      if(kind == 'values')return step(0, entry.v);\n      return step(0, [entry.k, entry.v]);\n    }, IS_MAP ? 'entries' : 'values' , !IS_MAP, true);\n\n    // add [@@species], 23.1.2.2, 23.2.2.2\n    setSpecies(NAME);\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_collection-strong.js\n// module id = 99\n// module chunks = 0 1","var hide = require('./_hide');\nmodule.exports = function(target, src, safe){\n  for(var key in src){\n    if(safe && target[key])target[key] = src[key];\n    else hide(target, key, src[key]);\n  } return target;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_redefine-all.js\n// module id = 100\n// module chunks = 0 1","module.exports = function(it, Constructor, name, forbiddenField){\n  if(!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)){\n    throw TypeError(name + ': incorrect invocation!');\n  } return it;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_an-instance.js\n// module id = 101\n// module chunks = 0 1","var ctx         = require('./_ctx')\n  , call        = require('./_iter-call')\n  , isArrayIter = require('./_is-array-iter')\n  , anObject    = require('./_an-object')\n  , toLength    = require('./_to-length')\n  , getIterFn   = require('./core.get-iterator-method')\n  , BREAK       = {}\n  , RETURN      = {};\nvar exports = module.exports = function(iterable, entries, fn, that, ITERATOR){\n  var iterFn = ITERATOR ? function(){ return iterable; } : getIterFn(iterable)\n    , f      = ctx(fn, that, entries ? 2 : 1)\n    , index  = 0\n    , length, step, iterator, result;\n  if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!');\n  // fast case for arrays with default iterator\n  if(isArrayIter(iterFn))for(length = toLength(iterable.length); length > index; index++){\n    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);\n    if(result === BREAK || result === RETURN)return result;\n  } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){\n    result = call(iterator, f, step.value, entries);\n    if(result === BREAK || result === RETURN)return result;\n  }\n};\nexports.BREAK  = BREAK;\nexports.RETURN = RETURN;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_for-of.js\n// module id = 102\n// module chunks = 0 1","// call something on iterator step with safe closing on error\nvar anObject = require('./_an-object');\nmodule.exports = function(iterator, fn, value, entries){\n  try {\n    return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n  // 7.4.6 IteratorClose(iterator, completion)\n  } catch(e){\n    var ret = iterator['return'];\n    if(ret !== undefined)anObject(ret.call(iterator));\n    throw e;\n  }\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_iter-call.js\n// module id = 103\n// module chunks = 0 1","// check on default Array iterator\nvar Iterators  = require('./_iterators')\n  , ITERATOR   = require('./_wks')('iterator')\n  , ArrayProto = Array.prototype;\n\nmodule.exports = function(it){\n  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_is-array-iter.js\n// module id = 104\n// module chunks = 0 1","'use strict';\nvar global      = require('./_global')\n  , core        = require('./_core')\n  , dP          = require('./_object-dp')\n  , DESCRIPTORS = require('./_descriptors')\n  , SPECIES     = require('./_wks')('species');\n\nmodule.exports = function(KEY){\n  var C = typeof core[KEY] == 'function' ? core[KEY] : global[KEY];\n  if(DESCRIPTORS && C && !C[SPECIES])dP.f(C, SPECIES, {\n    configurable: true,\n    get: function(){ return this; }\n  });\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_set-species.js\n// module id = 105\n// module chunks = 0 1","'use strict';\nvar global         = require('./_global')\n  , $export        = require('./_export')\n  , meta           = require('./_meta')\n  , fails          = require('./_fails')\n  , hide           = require('./_hide')\n  , redefineAll    = require('./_redefine-all')\n  , forOf          = require('./_for-of')\n  , anInstance     = require('./_an-instance')\n  , isObject       = require('./_is-object')\n  , setToStringTag = require('./_set-to-string-tag')\n  , dP             = require('./_object-dp').f\n  , each           = require('./_array-methods')(0)\n  , DESCRIPTORS    = require('./_descriptors');\n\nmodule.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK){\n  var Base  = global[NAME]\n    , C     = Base\n    , ADDER = IS_MAP ? 'set' : 'add'\n    , proto = C && C.prototype\n    , O     = {};\n  if(!DESCRIPTORS || typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function(){\n    new C().entries().next();\n  }))){\n    // create collection constructor\n    C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);\n    redefineAll(C.prototype, methods);\n    meta.NEED = true;\n  } else {\n    C = wrapper(function(target, iterable){\n      anInstance(target, C, NAME, '_c');\n      target._c = new Base;\n      if(iterable != undefined)forOf(iterable, IS_MAP, target[ADDER], target);\n    });\n    each('add,clear,delete,forEach,get,has,set,keys,values,entries,toJSON'.split(','),function(KEY){\n      var IS_ADDER = KEY == 'add' || KEY == 'set';\n      if(KEY in proto && !(IS_WEAK && KEY == 'clear'))hide(C.prototype, KEY, function(a, b){\n        anInstance(this, C, KEY);\n        if(!IS_ADDER && IS_WEAK && !isObject(a))return KEY == 'get' ? undefined : false;\n        var result = this._c[KEY](a === 0 ? 0 : a, b);\n        return IS_ADDER ? this : result;\n      });\n    });\n    if('size' in proto)dP(C.prototype, 'size', {\n      get: function(){\n        return this._c.size;\n      }\n    });\n  }\n\n  setToStringTag(C, NAME);\n\n  O[NAME] = C;\n  $export($export.G + $export.W + $export.F, O);\n\n  if(!IS_WEAK)common.setStrong(C, NAME, IS_MAP);\n\n  return C;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_collection.js\n// module id = 106\n// module chunks = 0 1","// 0 -> Array#forEach\n// 1 -> Array#map\n// 2 -> Array#filter\n// 3 -> Array#some\n// 4 -> Array#every\n// 5 -> Array#find\n// 6 -> Array#findIndex\nvar ctx      = require('./_ctx')\n  , IObject  = require('./_iobject')\n  , toObject = require('./_to-object')\n  , toLength = require('./_to-length')\n  , asc      = require('./_array-species-create');\nmodule.exports = function(TYPE, $create){\n  var IS_MAP        = TYPE == 1\n    , IS_FILTER     = TYPE == 2\n    , IS_SOME       = TYPE == 3\n    , IS_EVERY      = TYPE == 4\n    , IS_FIND_INDEX = TYPE == 6\n    , NO_HOLES      = TYPE == 5 || IS_FIND_INDEX\n    , create        = $create || asc;\n  return function($this, callbackfn, that){\n    var O      = toObject($this)\n      , self   = IObject(O)\n      , f      = ctx(callbackfn, that, 3)\n      , length = toLength(self.length)\n      , index  = 0\n      , result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined\n      , val, res;\n    for(;length > index; index++)if(NO_HOLES || index in self){\n      val = self[index];\n      res = f(val, index, O);\n      if(TYPE){\n        if(IS_MAP)result[index] = res;            // map\n        else if(res)switch(TYPE){\n          case 3: return true;                    // some\n          case 5: return val;                     // find\n          case 6: return index;                   // findIndex\n          case 2: result.push(val);               // filter\n        } else if(IS_EVERY)return false;          // every\n      }\n    }\n    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_array-methods.js\n// module id = 107\n// module chunks = 0 1","// 9.4.2.3 ArraySpeciesCreate(originalArray, length)\nvar speciesConstructor = require('./_array-species-constructor');\n\nmodule.exports = function(original, length){\n  return new (speciesConstructor(original))(length);\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_array-species-create.js\n// module id = 108\n// module chunks = 0 1","var isObject = require('./_is-object')\n  , isArray  = require('./_is-array')\n  , SPECIES  = require('./_wks')('species');\n\nmodule.exports = function(original){\n  var C;\n  if(isArray(original)){\n    C = original.constructor;\n    // cross-realm fallback\n    if(typeof C == 'function' && (C === Array || isArray(C.prototype)))C = undefined;\n    if(isObject(C)){\n      C = C[SPECIES];\n      if(C === null)C = undefined;\n    }\n  } return C === undefined ? Array : C;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_array-species-constructor.js\n// module id = 109\n// module chunks = 0 1","// https://github.com/DavidBruant/Map-Set.prototype.toJSON\nvar $export  = require('./_export');\n\n$export($export.P + $export.R, 'Set', {toJSON: require('./_collection-to-json')('Set')});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/es7.set.to-json.js\n// module id = 110\n// module chunks = 0 1","// https://github.com/DavidBruant/Map-Set.prototype.toJSON\nvar classof = require('./_classof')\n  , from    = require('./_array-from-iterable');\nmodule.exports = function(NAME){\n  return function toJSON(){\n    if(classof(this) != NAME)throw TypeError(NAME + \"#toJSON isn't generic\");\n    return from(this);\n  };\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_collection-to-json.js\n// module id = 111\n// module chunks = 0 1","var forOf = require('./_for-of');\n\nmodule.exports = function(iter, ITERATOR){\n  var result = [];\n  forOf(iter, false, result.push, result, ITERATOR);\n  return result;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_array-from-iterable.js\n// module id = 112\n// module chunks = 0 1","module.exports = { \"default\": require(\"core-js/library/fn/object/assign\"), __esModule: true };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/core-js/object/assign.js\n// module id = 113\n// module chunks = 0 1","require('../../modules/es6.object.assign');\nmodule.exports = require('../../modules/_core').Object.assign;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/fn/object/assign.js\n// module id = 114\n// module chunks = 0 1","// 19.1.3.1 Object.assign(target, source)\nvar $export = require('./_export');\n\n$export($export.S + $export.F, 'Object', {assign: require('./_object-assign')});\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/es6.object.assign.js\n// module id = 115\n// module chunks = 0 1","'use strict';\n// 19.1.2.1 Object.assign(target, source, ...)\nvar getKeys  = require('./_object-keys')\n  , gOPS     = require('./_object-gops')\n  , pIE      = require('./_object-pie')\n  , toObject = require('./_to-object')\n  , IObject  = require('./_iobject')\n  , $assign  = Object.assign;\n\n// should work with symbols and should have deterministic property order (V8 bug)\nmodule.exports = !$assign || require('./_fails')(function(){\n  var A = {}\n    , B = {}\n    , S = Symbol()\n    , K = 'abcdefghijklmnopqrst';\n  A[S] = 7;\n  K.split('').forEach(function(k){ B[k] = k; });\n  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;\n}) ? function assign(target, source){ // eslint-disable-line no-unused-vars\n  var T     = toObject(target)\n    , aLen  = arguments.length\n    , index = 1\n    , getSymbols = gOPS.f\n    , isEnum     = pIE.f;\n  while(aLen > index){\n    var S      = IObject(arguments[index++])\n      , keys   = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)\n      , length = keys.length\n      , j      = 0\n      , key;\n    while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];\n  } return T;\n} : $assign;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/babel-runtime/~/core-js/library/modules/_object-assign.js\n// module id = 116\n// module chunks = 0 1","/*!\n * EventEmitter v5.1.0 - git.io/ee\n * Unlicense - http://unlicense.org/\n * Oliver Caldwell - http://oli.me.uk/\n * @preserve\n */\n\n;(function (exports) {\n    'use strict';\n\n    /**\n     * Class for managing events.\n     * Can be extended to provide event functionality in other classes.\n     *\n     * @class EventEmitter Manages event registering and emitting.\n     */\n    function EventEmitter() {}\n\n    // Shortcuts to improve speed and size\n    var proto = EventEmitter.prototype;\n    var originalGlobalValue = exports.EventEmitter;\n\n    /**\n     * Finds the index of the listener for the event in its storage array.\n     *\n     * @param {Function[]} listeners Array of listeners to search through.\n     * @param {Function} listener Method to look for.\n     * @return {Number} Index of the specified listener, -1 if not found\n     * @api private\n     */\n    function indexOfListener(listeners, listener) {\n        var i = listeners.length;\n        while (i--) {\n            if (listeners[i].listener === listener) {\n                return i;\n            }\n        }\n\n        return -1;\n    }\n\n    /**\n     * Alias a method while keeping the context correct, to allow for overwriting of target method.\n     *\n     * @param {String} name The name of the target method.\n     * @return {Function} The aliased method\n     * @api private\n     */\n    function alias(name) {\n        return function aliasClosure() {\n            return this[name].apply(this, arguments);\n        };\n    }\n\n    /**\n     * Returns the listener array for the specified event.\n     * Will initialise the event object and listener arrays if required.\n     * Will return an object if you use a regex search. The object contains keys for each matched event. So /ba[rz]/ might return an object containing bar and baz. But only if you have either defined them with defineEvent or added some listeners to them.\n     * Each property in the object response is an array of listener functions.\n     *\n     * @param {String|RegExp} evt Name of the event to return the listeners from.\n     * @return {Function[]|Object} All listener functions for the event.\n     */\n    proto.getListeners = function getListeners(evt) {\n        var events = this._getEvents();\n        var response;\n        var key;\n\n        // Return a concatenated array of all matching events if\n        // the selector is a regular expression.\n        if (evt instanceof RegExp) {\n            response = {};\n            for (key in events) {\n                if (events.hasOwnProperty(key) && evt.test(key)) {\n                    response[key] = events[key];\n                }\n            }\n        }\n        else {\n            response = events[evt] || (events[evt] = []);\n        }\n\n        return response;\n    };\n\n    /**\n     * Takes a list of listener objects and flattens it into a list of listener functions.\n     *\n     * @param {Object[]} listeners Raw listener objects.\n     * @return {Function[]} Just the listener functions.\n     */\n    proto.flattenListeners = function flattenListeners(listeners) {\n        var flatListeners = [];\n        var i;\n\n        for (i = 0; i < listeners.length; i += 1) {\n            flatListeners.push(listeners[i].listener);\n        }\n\n        return flatListeners;\n    };\n\n    /**\n     * Fetches the requested listeners via getListeners but will always return the results inside an object. This is mainly for internal use but others may find it useful.\n     *\n     * @param {String|RegExp} evt Name of the event to return the listeners from.\n     * @return {Object} All listener functions for an event in an object.\n     */\n    proto.getListenersAsObject = function getListenersAsObject(evt) {\n        var listeners = this.getListeners(evt);\n        var response;\n\n        if (listeners instanceof Array) {\n            response = {};\n            response[evt] = listeners;\n        }\n\n        return response || listeners;\n    };\n\n    function isValidListener (listener) {\n        if (typeof listener === 'function' || listener instanceof RegExp) {\n            return true\n        } else if (listener && typeof listener === 'object') {\n            return isValidListener(listener.listener)\n        } else {\n            return false\n        }\n    }\n\n    /**\n     * Adds a listener function to the specified event.\n     * The listener will not be added if it is a duplicate.\n     * If the listener returns true then it will be removed after it is called.\n     * If you pass a regular expression as the event name then the listener will be added to all events that match it.\n     *\n     * @param {String|RegExp} evt Name of the event to attach the listener to.\n     * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     */\n    proto.addListener = function addListener(evt, listener) {\n        if (!isValidListener(listener)) {\n            throw new TypeError('listener must be a function');\n        }\n\n        var listeners = this.getListenersAsObject(evt);\n        var listenerIsWrapped = typeof listener === 'object';\n        var key;\n\n        for (key in listeners) {\n            if (listeners.hasOwnProperty(key) && indexOfListener(listeners[key], listener) === -1) {\n                listeners[key].push(listenerIsWrapped ? listener : {\n                    listener: listener,\n                    once: false\n                });\n            }\n        }\n\n        return this;\n    };\n\n    /**\n     * Alias of addListener\n     */\n    proto.on = alias('addListener');\n\n    /**\n     * Semi-alias of addListener. It will add a listener that will be\n     * automatically removed after its first execution.\n     *\n     * @param {String|RegExp} evt Name of the event to attach the listener to.\n     * @param {Function} listener Method to be called when the event is emitted. If the function returns true then it will be removed after calling.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     */\n    proto.addOnceListener = function addOnceListener(evt, listener) {\n        return this.addListener(evt, {\n            listener: listener,\n            once: true\n        });\n    };\n\n    /**\n     * Alias of addOnceListener.\n     */\n    proto.once = alias('addOnceListener');\n\n    /**\n     * Defines an event name. This is required if you want to use a regex to add a listener to multiple events at once. If you don't do this then how do you expect it to know what event to add to? Should it just add to every possible match for a regex? No. That is scary and bad.\n     * You need to tell it what event names should be matched by a regex.\n     *\n     * @param {String} evt Name of the event to create.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     */\n    proto.defineEvent = function defineEvent(evt) {\n        this.getListeners(evt);\n        return this;\n    };\n\n    /**\n     * Uses defineEvent to define multiple events.\n     *\n     * @param {String[]} evts An array of event names to define.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     */\n    proto.defineEvents = function defineEvents(evts) {\n        for (var i = 0; i < evts.length; i += 1) {\n            this.defineEvent(evts[i]);\n        }\n        return this;\n    };\n\n    /**\n     * Removes a listener function from the specified event.\n     * When passed a regular expression as the event name, it will remove the listener from all events that match it.\n     *\n     * @param {String|RegExp} evt Name of the event to remove the listener from.\n     * @param {Function} listener Method to remove from the event.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     */\n    proto.removeListener = function removeListener(evt, listener) {\n        var listeners = this.getListenersAsObject(evt);\n        var index;\n        var key;\n\n        for (key in listeners) {\n            if (listeners.hasOwnProperty(key)) {\n                index = indexOfListener(listeners[key], listener);\n\n                if (index !== -1) {\n                    listeners[key].splice(index, 1);\n                }\n            }\n        }\n\n        return this;\n    };\n\n    /**\n     * Alias of removeListener\n     */\n    proto.off = alias('removeListener');\n\n    /**\n     * Adds listeners in bulk using the manipulateListeners method.\n     * If you pass an object as the second argument you can add to multiple events at once. The object should contain key value pairs of events and listeners or listener arrays. You can also pass it an event name and an array of listeners to be added.\n     * You can also pass it a regular expression to add the array of listeners to all events that match it.\n     * Yeah, this function does quite a bit. That's probably a bad thing.\n     *\n     * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to add to multiple events at once.\n     * @param {Function[]} [listeners] An optional array of listener functions to add.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     */\n    proto.addListeners = function addListeners(evt, listeners) {\n        // Pass through to manipulateListeners\n        return this.manipulateListeners(false, evt, listeners);\n    };\n\n    /**\n     * Removes listeners in bulk using the manipulateListeners method.\n     * If you pass an object as the second argument you can remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.\n     * You can also pass it an event name and an array of listeners to be removed.\n     * You can also pass it a regular expression to remove the listeners from all events that match it.\n     *\n     * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to remove from multiple events at once.\n     * @param {Function[]} [listeners] An optional array of listener functions to remove.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     */\n    proto.removeListeners = function removeListeners(evt, listeners) {\n        // Pass through to manipulateListeners\n        return this.manipulateListeners(true, evt, listeners);\n    };\n\n    /**\n     * Edits listeners in bulk. The addListeners and removeListeners methods both use this to do their job. You should really use those instead, this is a little lower level.\n     * The first argument will determine if the listeners are removed (true) or added (false).\n     * If you pass an object as the second argument you can add/remove from multiple events at once. The object should contain key value pairs of events and listeners or listener arrays.\n     * You can also pass it an event name and an array of listeners to be added/removed.\n     * You can also pass it a regular expression to manipulate the listeners of all events that match it.\n     *\n     * @param {Boolean} remove True if you want to remove listeners, false if you want to add.\n     * @param {String|Object|RegExp} evt An event name if you will pass an array of listeners next. An object if you wish to add/remove from multiple events at once.\n     * @param {Function[]} [listeners] An optional array of listener functions to add/remove.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     */\n    proto.manipulateListeners = function manipulateListeners(remove, evt, listeners) {\n        var i;\n        var value;\n        var single = remove ? this.removeListener : this.addListener;\n        var multiple = remove ? this.removeListeners : this.addListeners;\n\n        // If evt is an object then pass each of its properties to this method\n        if (typeof evt === 'object' && !(evt instanceof RegExp)) {\n            for (i in evt) {\n                if (evt.hasOwnProperty(i) && (value = evt[i])) {\n                    // Pass the single listener straight through to the singular method\n                    if (typeof value === 'function') {\n                        single.call(this, i, value);\n                    }\n                    else {\n                        // Otherwise pass back to the multiple function\n                        multiple.call(this, i, value);\n                    }\n                }\n            }\n        }\n        else {\n            // So evt must be a string\n            // And listeners must be an array of listeners\n            // Loop over it and pass each one to the multiple method\n            i = listeners.length;\n            while (i--) {\n                single.call(this, evt, listeners[i]);\n            }\n        }\n\n        return this;\n    };\n\n    /**\n     * Removes all listeners from a specified event.\n     * If you do not specify an event then all listeners will be removed.\n     * That means every event will be emptied.\n     * You can also pass a regex to remove all events that match it.\n     *\n     * @param {String|RegExp} [evt] Optional name of the event to remove all listeners for. Will remove from every event if not passed.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     */\n    proto.removeEvent = function removeEvent(evt) {\n        var type = typeof evt;\n        var events = this._getEvents();\n        var key;\n\n        // Remove different things depending on the state of evt\n        if (type === 'string') {\n            // Remove all listeners for the specified event\n            delete events[evt];\n        }\n        else if (evt instanceof RegExp) {\n            // Remove all events matching the regex.\n            for (key in events) {\n                if (events.hasOwnProperty(key) && evt.test(key)) {\n                    delete events[key];\n                }\n            }\n        }\n        else {\n            // Remove all listeners in all events\n            delete this._events;\n        }\n\n        return this;\n    };\n\n    /**\n     * Alias of removeEvent.\n     *\n     * Added to mirror the node API.\n     */\n    proto.removeAllListeners = alias('removeEvent');\n\n    /**\n     * Emits an event of your choice.\n     * When emitted, every listener attached to that event will be executed.\n     * If you pass the optional argument array then those arguments will be passed to every listener upon execution.\n     * Because it uses `apply`, your array of arguments will be passed as if you wrote them out separately.\n     * So they will not arrive within the array on the other side, they will be separate.\n     * You can also pass a regular expression to emit to all events that match it.\n     *\n     * @param {String|RegExp} evt Name of the event to emit and execute listeners for.\n     * @param {Array} [args] Optional array of arguments to be passed to each listener.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     */\n    proto.emitEvent = function emitEvent(evt, args) {\n        var listenersMap = this.getListenersAsObject(evt);\n        var listeners;\n        var listener;\n        var i;\n        var key;\n        var response;\n\n        for (key in listenersMap) {\n            if (listenersMap.hasOwnProperty(key)) {\n                listeners = listenersMap[key].slice(0);\n\n                for (i = 0; i < listeners.length; i++) {\n                    // If the listener returns true then it shall be removed from the event\n                    // The function is executed either with a basic call or an apply if there is an args array\n                    listener = listeners[i];\n\n                    if (listener.once === true) {\n                        this.removeListener(evt, listener.listener);\n                    }\n\n                    response = listener.listener.apply(this, args || []);\n\n                    if (response === this._getOnceReturnValue()) {\n                        this.removeListener(evt, listener.listener);\n                    }\n                }\n            }\n        }\n\n        return this;\n    };\n\n    /**\n     * Alias of emitEvent\n     */\n    proto.trigger = alias('emitEvent');\n\n    /**\n     * Subtly different from emitEvent in that it will pass its arguments on to the listeners, as opposed to taking a single array of arguments to pass on.\n     * As with emitEvent, you can pass a regex in place of the event name to emit to all events that match it.\n     *\n     * @param {String|RegExp} evt Name of the event to emit and execute listeners for.\n     * @param {...*} Optional additional arguments to be passed to each listener.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     */\n    proto.emit = function emit(evt) {\n        var args = Array.prototype.slice.call(arguments, 1);\n        return this.emitEvent(evt, args);\n    };\n\n    /**\n     * Sets the current value to check against when executing listeners. If a\n     * listeners return value matches the one set here then it will be removed\n     * after execution. This value defaults to true.\n     *\n     * @param {*} value The new value to check for when executing listeners.\n     * @return {Object} Current instance of EventEmitter for chaining.\n     */\n    proto.setOnceReturnValue = function setOnceReturnValue(value) {\n        this._onceReturnValue = value;\n        return this;\n    };\n\n    /**\n     * Fetches the current value to check against when executing listeners. If\n     * the listeners return value matches this one then it should be removed\n     * automatically. It will return true by default.\n     *\n     * @return {*|Boolean} The current value to check for or the default, true.\n     * @api private\n     */\n    proto._getOnceReturnValue = function _getOnceReturnValue() {\n        if (this.hasOwnProperty('_onceReturnValue')) {\n            return this._onceReturnValue;\n        }\n        else {\n            return true;\n        }\n    };\n\n    /**\n     * Fetches the events object and creates one if required.\n     *\n     * @return {Object} The events storage object.\n     * @api private\n     */\n    proto._getEvents = function _getEvents() {\n        return this._events || (this._events = {});\n    };\n\n    /**\n     * Reverts the global {@link EventEmitter} to its previous value and returns a reference to this version.\n     *\n     * @return {Function} Non conflicting EventEmitter class.\n     */\n    EventEmitter.noConflict = function noConflict() {\n        exports.EventEmitter = originalGlobalValue;\n        return EventEmitter;\n    };\n\n    // Expose the class either via AMD, CommonJS or the global object\n    if (typeof define === 'function' && define.amd) {\n        define(function () {\n            return EventEmitter;\n        });\n    }\n    else if (typeof module === 'object' && module.exports){\n        module.exports = EventEmitter;\n    }\n    else {\n        exports.EventEmitter = EventEmitter;\n    }\n}(this || {}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/wolfy87-eventemitter/EventEmitter.js\n// module id = 117\n// module chunks = 0 1","/* global Node, NodeList, Element */\n\n/**\n * @type {string}\n */\nexport const ATTR_DATA_ORIGINAL_INDEX = 'data-original-index';\n/**\n * @type {string}\n */\nexport const DATA_IS_SELECTION = 'data-is-selection';\n/**\n * @type {string}\n */\nconst SERIALIZE_SEPARATOR = \";\";\n\nimport { ATTR_DATA_ORIGINAL_OFFSET_START } from '../Rendering';\n\n// polyfill for matchesSelector, IE 10/11 does not support Element.matches\nif (Element && !Element.prototype.matches) {\n  const p = Element.prototype;\n  p.matches = p.matchesSelector ||\n    p.mozMatchesSelector || p.msMatchesSelector ||\n    p.oMatchesSelector || p.webkitMatchesSelector;\n}\n\n/**\n * Utility class\n * Contains DOM/Node manipulation helpers\n */\nexport default\nclass Util {\n\n  /**\n   * Filter for a NodeList\n   * @param {NodeList} nodes\n   * @param {Function} func\n   *\n   * @returns {Array.<HTMLElement>}\n   */\n  static nodeListFilter(nodes, func) {\n    return Array.prototype.filter.call(nodes || [], func);\n  }\n\n\n  /**\n   * Generates a unique id\n   * @return {String}\n   */\n  static guid() {\n    function s4() {\n      return Math.floor((1 + Math.random()) * 0x10000)\n        .toString(16)\n        .substring(1);\n    }\n\n    return `${s4() + s4()}-${s4()}-${s4()}-${s4()}-${s4() + s4() + s4()}`;\n  }\n\n  /**\n   * Checks if a given node is empty\n   * @param {HTMLElement} node\n   *\n   * @returns {*}\n   */\n  static nodeIsEmpty(node) {\n    return node.nodeValue.match(/^[\\s]*$/g);\n  }\n\n\n  /**\n   * @param {HTMLElement} node\n   * @param [optionalList]\n   *\n   * @return {int} the index of this node in context to it's siblings\n   */\n  static index(node, optionalList) {\n    const children = optionalList || (node.nodeType === Node.TEXT_NODE ?\n        node.parentNode.childNodes : node.parentNode.children);\n    return Array.prototype.indexOf.call(children || [], node);\n  }\n\n  /**\n   * Wraps given `elms` in given `wrapper`\n   *\n   * @param {HTMLElement|Array.<HTMLElement>|Node} elms\n   * @param {HTMLElement|Node} wrapper\n   *\n   * @return {HTMLElement}\n   */\n  static wrap(elms, wrapper) {\n    let thisElms = elms;\n\n    if (!thisElms) {\n      return wrapper;\n    }\n    // Convert `elms` to an array, if necessary.\n    if (!(thisElms instanceof NodeList || thisElms instanceof Array)) {\n      thisElms = [thisElms];\n    }\n    for (let i = thisElms.length - 1; i >= 0; i--) {\n      const child = (i > 0) ? wrapper.cloneNode(true) : wrapper;\n      const el = thisElms[i];\n      // Cache the current parent and sibling.\n      const parent = el.parentNode;\n      const sibling = el.nextSibling;\n\n      child.appendChild(el);\n      if (sibling) {\n        parent.insertBefore(child, sibling);\n      } else {\n        parent.appendChild(child);\n      }\n    }\n    return wrapper;\n  }\n\n  /**\n   * Will calculate an index depending on an already modified dom by marklib\n   * @param {HTMLElement|Node} node\n   *\n   * @returns {int|boolean}\n   */\n  static calcIndex(node) {\n    let calculatedIndex = 0;\n    let foundWrapper = false;\n    const nodes = node.parentNode.childNodes;\n    const length = nodes.length;\n    for (let thisIndex = 0; thisIndex < length; thisIndex++) {\n      const el = nodes[thisIndex];\n      if (el === node) {\n        break;\n      }\n      // reset index when original index is found\n      const maybeIndexOfOriginal = el.getAttribute ?\n        el.getAttribute(ATTR_DATA_ORIGINAL_INDEX) : null;\n\n      if (maybeIndexOfOriginal) {\n        calculatedIndex = parseInt(maybeIndexOfOriginal, 10);\n        foundWrapper = true;\n      }\n      calculatedIndex++;\n    }\n    return foundWrapper ? calculatedIndex : Util.index(node);\n  }\n\n  /**\n   * @param {HTMLElement|Node} el\n   * @param {String} [optionalSelector] will test given element against a selector\n   *  if matches, returns this element immediately\n   *\n   * @return {Array.<HTMLElement>} an array of all found parents of given element (and optional selector)\n   */\n  static parents(el, optionalSelector) {\n    return Util.parentsCallback(el, (element) => {\n      if (optionalSelector && ((element === optionalSelector) ||\n        ((typeof optionalSelector === 'string') && element.matches &&\n        element.matches(optionalSelector)))) {\n        return true;\n      } else if (!optionalSelector) {\n        return true;\n      }\n      return false;\n    });\n  }\n\n  /**\n   * @param {HTMLElement|Node} el\n   * @param {Function} callback\n   * @return {Array.<HTMLElement>} an array of all found parents of given element (and optional selector)\n   */\n  static parentsCallback(el, callback) {\n    let element = el;\n    const foundElements = [];\n    while (element.parentNode !== null) {\n      element = element.parentNode;\n      if (callback(element)) {\n        foundElements.push(element);\n      }\n    }\n    return foundElements;\n  }\n\n  /**\n   * Finds a parent node (the closest) with a given selector\n   * @param {Node} el\n   * @param {String} selector\n   *\n   * @returns {Node|boolean}\n   */\n  static parent(el, selector) {\n    let element = el;\n    while (element.parentNode !== null) {\n      element = element.parentNode;\n      if (element.matches && element.matches(selector)) {\n        return element;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Finds the closest element including itself matching a given selector\n   * @param {Node} el\n   * @param selector\n   *\n   * @returns {Node|boolean}\n   */\n  static closest(el, selector) {\n    return Util.closestCallback(el, (element) => element.matches && element.matches(selector));\n  }\n\n  /**\n   * Finds the closest element including itself matching a callback\n   * @param {Node} el\n   * @param {Function} callback\n   * @returns {Node|boolean}\n   */\n  static closestCallback(el, callback) {\n    let element = el;\n    while (element !== null) {\n      if (callback(element)) {\n        return element;\n      }\n      element = element.parentNode;\n    }\n    return false;\n  }\n\n  /**\n   * Finds the outermost fitting element that matches callback\n   * @param {Node} el\n   * @param {Function} callback\n   * @returns {Node|boolean}\n   */\n  static outerMostCallback(el, callback) {\n    let element = el;\n    let lastValid = false;\n    while (element !== null) {\n      if (callback(element)) {\n        lastValid = element;\n      }\n      element = element.parentNode;\n    }\n    return lastValid;\n  }\n\n  /**\n   * @param {HTMLElement} n\n   *\n   * @return {boolean}\n   */\n  static isMarkNode(n) {\n    return n instanceof HTMLElement && n.hasAttribute(DATA_IS_SELECTION);\n  }\n\n  /**\n   * Determines the correct paths and excludes all `marklib` generated content\n   * TODO: To improve performance we could shorten the path if an ID is present in it.\n   * @param {HTMLElement|Node} el\n   * @param {HTMLElement|Node} [context] if given extraction path is relative to this element\n   * @returns {string}\n   */\n  static getPath(el, context) {\n    let path = null;\n    let node = el;\n\n    const filterSiblings = (thisEl) => !Util.isMarkNode(thisEl) && thisEl.nodeName === node.nodeName;\n\n    while (node) {\n      let name = null;\n      // If node is a text-node, save index\n      if (Node.TEXT_NODE === node.nodeType) {\n        /* Because nodes may wrapped inside a highlighting node, we need to find the original index that was\n         * valid before the dom changes. We store the last known index position inside all wrapper elements\n         * We select the outermost\n         */\n\n        // Extract original index of this node:\n        // Outer most data-original-index is original index\n        const outerMostElement = Util.parents(node, `[${ATTR_DATA_ORIGINAL_INDEX}]`).reverse()[0];\n        // if element is not yet wrapped in span, recalculate index based on parent container:\n        // We have to do this because text node indexes != element indexes...\n        let calculatedIndex = 0;\n        if (!outerMostElement) {\n          calculatedIndex = Util.calcIndex(node);\n        }\n        const index = outerMostElement ? parseInt(\n          outerMostElement.getAttribute(ATTR_DATA_ORIGINAL_INDEX), 10) : calculatedIndex;\n        name = SERIALIZE_SEPARATOR + index;\n      } else {\n        name = node.nodeName;\n      }\n\n      if (!name) {\n        break;\n      }\n\n      name = name.toLowerCase();\n\n      const parent = node.parentNode;\n\n      if (Util.isMarkNode(node)) {\n        if (parent !== context) {\n          node = parent;\n          continue;\n        } else {\n          break;\n        }\n      }\n\n      // Select only siblings that are not part of selection and are of the same type\n      // (because we use nth-of-type selector later)\n      const siblings = Util.nodeListFilter(parent.children, filterSiblings);\n      const nodeIndex = Util.index(node, siblings);\n\n      if (siblings.length > 1 && nodeIndex >= 0) {\n        name += `:nth-of-type(${(nodeIndex + 1)})`;\n      }\n\n      path = name + (path ? `>${path}` : '');\n\n\n      if (parent === context) {\n        break;\n      }\n\n      node = parent;\n    }\n\n    return path.replace(\"#document>\", \"\").replace('>;', ';');\n  }\n\n  /**\n   * Will return the first original offset value that is found\n   * @param {Node} element\n   *\n   * @returns {int}\n   */\n  static findOriginalOffset(element) {\n    if (!element.parentNode.hasAttribute(ATTR_DATA_ORIGINAL_OFFSET_START)) {\n      return 0;\n    }\n    const lengthElement = Util.parent(element, `[${ATTR_DATA_ORIGINAL_OFFSET_START}]`);\n    return lengthElement ? parseInt(lengthElement.getAttribute(ATTR_DATA_ORIGINAL_OFFSET_START), 10) : 0;\n  }\n\n\n  /**\n   * Deserialize a specific path and finds the right textNodes\n   * This even works when DOM has been manipulated before by `marklib`\n   * @param {string} path the serialized path (including offsets)\n   * @param {Node|HTMLElement} context\n   *\n   * @return {Node}\n   */\n  static deserializePath(path, context) {\n    const pSplit = path.split(';');\n    const p = pSplit[0];\n    const objectIndex = parseInt(pSplit[1], 10);\n    const charOffset = parseInt(pSplit[2], 10);\n    const container = !p.trim() ? context : context.querySelector(p);\n\n    let maybeFoundNode = null;\n\n    Util.walkDom(container, (n) => {\n      let atrOffsetStart = n.parentNode.getAttribute(ATTR_DATA_ORIGINAL_OFFSET_START);\n      atrOffsetStart = atrOffsetStart === null ? 0 : atrOffsetStart;\n      let atrIndex = n.parentNode.getAttribute(ATTR_DATA_ORIGINAL_INDEX);\n      atrIndex = atrIndex === null ? Util.calcIndex(n) : atrIndex;\n      if (parseInt(atrIndex, 10) === objectIndex && charOffset >= atrOffsetStart &&\n        ((parseInt(atrOffsetStart, 10) + n.length) >= charOffset)) {\n        const thisOffset = n.parentNode\n          .hasAttribute(ATTR_DATA_ORIGINAL_OFFSET_START) ? charOffset -\n        parseInt(n.parentNode\n          .getAttribute(ATTR_DATA_ORIGINAL_OFFSET_START), 10) : charOffset;\n\n        maybeFoundNode = {\n          node: n,\n          offset: thisOffset\n        };\n\n        return false;\n      }\n      return true;\n    });\n\n    return maybeFoundNode;\n  }\n\n\n  /**\n   * Recursively walks the dom tree unless func returns false\n   * This is a lot more efficient then using any jQuery operations\n   *\n   * Applies node to function\n   * @param {Node} node\n   * @param {Function} func\n   *\n   * @returns {*}\n   */\n  static walkDom(node, func) {\n    if (!node) {\n      return false;\n    }\n    const children = node.childNodes;\n    if (!children) {\n      return false;\n    }\n    for (let i = 0; i < children.length; i++) {\n      if (!Util.walkDom(children[i], func)) {\n        return false;\n      }\n    }\n    return func(node);\n  }\n\n  /**\n   * Extracts all TextNodes inside a container\n   * @param {Node} el\n   * @param {Function} func\n   * @returns {Array.<Text>}\n   */\n  static walkTextNodes(el, func) {\n    Util.walkDom(el, (node) => {\n      if (Node.TEXT_NODE === node.nodeType && !Util.nodeIsEmpty(node)) {\n        func(node);\n      }\n      return true;\n    });\n  }\n\n  /**\n   * @param {Node} container\n   * @param {Number} thisIndex\n   * @returns {int|string} index of parent or original\n   */\n  static getIndexParentIfHas(container, thisIndex) {\n    const p = container.parentNode;\n    const index = parseInt(p.getAttribute(ATTR_DATA_ORIGINAL_INDEX), 10);\n    return index > thisIndex ? index : thisIndex;\n  }\n\n  /**\n   * @param container\n   * @returns {int} offset start of parent if has, else 0\n   */\n  static getOffsetParentIfHas(container) {\n    const p = container.parentNode;\n    const offset = parseInt(p.getAttribute(ATTR_DATA_ORIGINAL_OFFSET_START), 10);\n    return offset > 0 ? offset : 0;\n  }\n\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/main/util/Util.js"],"sourceRoot":""}